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 |
|---|---|---|---|---|---|---|
UString | UString-master/script/extract_res101_dad.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os.path as osp
import numpy as np
import os, cv2
import argparse, sys
from tqdm import tqdm
import torch
import torch.nn as nn
from torchvision import models, transforms
from torch.autograd import Varia... | 7,692 | 38.654639 | 146 | py |
SelfDeblur | SelfDeblur-master/selfdeblur_levin_reproduce.py |
# coding: utf-8
from __future__ import print_function
import matplotlib.pyplot as plt
import argparse
import os
import numpy as np
import cv2
import torch
import torch.optim
import glob
from skimage.io import imread
from skimage.io import imsave
import warnings
from tqdm import tqdm
from torch.optim.lr_scheduler imp... | 5,559 | 33.75 | 156 | py |
SelfDeblur | SelfDeblur-master/SSIM.py | import torch
import torch.nn.functional as F
from torch.autograd import Variable
import numpy as np
from math import exp
def gaussian(window_size, sigma):
gauss = torch.Tensor([exp(-(x - window_size // 2) ** 2 / float(2 * sigma ** 2)) for x in range(window_size)])
return gauss / gauss.sum()
def create_windo... | 2,620 | 33.038961 | 114 | py |
SelfDeblur | SelfDeblur-master/selfdeblur_lai_reproduce.py |
# coding: utf-8
from __future__ import print_function
import matplotlib.pyplot as plt
import argparse
import os
import numpy as np
import cv2
import torch
import torch.optim
import glob
from skimage.io import imread
from skimage.io import imsave
import warnings
from tqdm import tqdm
from torch.optim.lr_scheduler imp... | 5,294 | 33.835526 | 156 | py |
SelfDeblur | SelfDeblur-master/selfdeblur_lai.py |
from __future__ import print_function
import matplotlib.pyplot as plt
import argparse
import os
import numpy as np
from networks.skip import skip
from networks.fcn import *
import cv2
import torch
import torch.optim
import glob
from skimage.io import imread
from skimage.io import imsave
import warnings
from tqdm impo... | 5,242 | 33.045455 | 156 | py |
SelfDeblur | SelfDeblur-master/selfdeblur_nonblind.py |
from __future__ import print_function
import matplotlib.pyplot as plt
import argparse
import os
import numpy as np
from networks.skip import skip
from networks.fcn import *
import cv2
import torch
import torch.optim
import glob
from skimage.io import imread
from skimage.io import imsave
import warnings
from tqdm impor... | 4,721 | 32.489362 | 128 | py |
SelfDeblur | SelfDeblur-master/selfdeblur_ycbcr.py |
from __future__ import print_function
import matplotlib.pyplot as plt
import argparse
import os
import numpy as np
from networks.skip import skip
from networks.fcn import fcn
import cv2
import torch
import torch.optim
from torch.autograd import Variable
import glob
from skimage.io import imread
from skimage.io import ... | 5,714 | 34.06135 | 156 | py |
SelfDeblur | SelfDeblur-master/selfdeblur_levin.py |
from __future__ import print_function
import matplotlib.pyplot as plt
import argparse
import os
import numpy as np
from networks.skip import skip
from networks.fcn import fcn
import cv2
import torch
import torch.optim
import glob
from skimage.io import imread
from skimage.io import imsave
import warnings
from tqdm imp... | 5,395 | 32.515528 | 126 | py |
SelfDeblur | SelfDeblur-master/networks/fcn.py | import torch
import torch.nn as nn
from .common import *
def fcn(num_input_channels=200, num_output_channels=1, num_hidden=1000):
model = nn.Sequential()
model.add(nn.Linear(num_input_channels, num_hidden,bias=True))
model.add(nn.ReLU6())
#
model.add(nn.Linear(num_hidden, num_output_channels))
# m... | 398 | 13.25 | 72 | py |
SelfDeblur | SelfDeblur-master/networks/non_local_embedded_gaussian.py | import torch
from torch import nn
from torch.nn import functional as F
class _NonLocalBlockND(nn.Module):
def __init__(self, in_channels, inter_channels=None, dimension=3, sub_sample=True, bn_layer=True):
super(_NonLocalBlockND, self).__init__()
assert dimension in [1, 2, 3]
self.dimensi... | 4,916 | 36.25 | 102 | py |
SelfDeblur | SelfDeblur-master/networks/skip.py | import torch
import torch.nn as nn
from .common import *
#from .non_local_embedded_gaussian import NONLocalBlock2D
#from .non_local_concatenation import NONLocalBlock2D
#from .non_local_gaussian import NONLocalBlock2D
from .non_local_dot_product import NONLocalBlock2D
def skip(
num_input_channels=2, num_out... | 4,045 | 36.119266 | 144 | py |
SelfDeblur | SelfDeblur-master/networks/resnet.py | import torch
import torch.nn as nn
from numpy.random import normal
from numpy.linalg import svd
from math import sqrt
import torch.nn.init
from .common import *
class ResidualSequential(nn.Sequential):
def __init__(self, *args):
super(ResidualSequential, self).__init__(*args)
def forward(self, x):
... | 2,945 | 29.371134 | 195 | py |
SelfDeblur | SelfDeblur-master/networks/downsampler.py | import numpy as np
import torch
import torch.nn as nn
class Downsampler(nn.Module):
'''
http://www.realitypixels.com/turk/computergraphics/ResamplingFilters.pdf
'''
def __init__(self, n_planes, factor, kernel_type, phase=0, kernel_width=None, support=None, sigma=None, preserve_size=False):
... | 7,872 | 31.66805 | 129 | py |
SelfDeblur | SelfDeblur-master/networks/non_local_dot_product.py | import torch
from torch import nn
from torch.nn import functional as F
class _NonLocalBlockND(nn.Module):
def __init__(self, in_channels, inter_channels=None, dimension=3, sub_sample=True, bn_layer=True):
super(_NonLocalBlockND, self).__init__()
assert dimension in [1, 2, 3]
self.dimensi... | 4,926 | 35.496296 | 102 | py |
SelfDeblur | SelfDeblur-master/networks/non_local_concatenation.py | import torch
from torch import nn
from torch.nn import functional as F
class _NonLocalBlockND(nn.Module):
def __init__(self, in_channels, inter_channels=None, dimension=3, sub_sample=True, bn_layer=True):
super(_NonLocalBlockND, self).__init__()
assert dimension in [1, 2, 3]
self.dimensi... | 5,350 | 35.155405 | 102 | py |
SelfDeblur | SelfDeblur-master/networks/common.py | import torch
import torch.nn as nn
import numpy as np
from .downsampler import Downsampler
def add_module(self, module):
self.add_module(str(len(self) + 1), module)
torch.nn.Module.add = add_module
class Concat(nn.Module):
def __init__(self, dim, *args):
super(Concat, self).__init__()
sel... | 3,531 | 27.483871 | 128 | py |
SelfDeblur | SelfDeblur-master/networks/unet.py | import torch.nn as nn
import torch
import torch.nn as nn
import torch.nn.functional as F
from .common import *
class ListModule(nn.Module):
def __init__(self, *args):
super(ListModule, self).__init__()
idx = 0
for module in args:
self.add_module(str(idx), module)
id... | 7,408 | 36.045 | 164 | py |
SelfDeblur | SelfDeblur-master/networks/non_local_gaussian.py | import torch
from torch import nn
from torch.nn import functional as F
class _NonLocalBlockND(nn.Module):
def __init__(self, in_channels, inter_channels=None, dimension=3, sub_sample=True, bn_layer=True):
super(_NonLocalBlockND, self).__init__()
assert dimension in [1, 2, 3]
self.dimensi... | 4,674 | 33.124088 | 102 | py |
SelfDeblur | SelfDeblur-master/models/skipfc.py | import torch
import torch.nn as nn
from .common import *
def skipfc(num_input_channels=2, num_output_channels=3,
num_channels_down=[16, 32, 64, 128, 128], num_channels_up=[16, 32, 64, 128, 128], num_channels_skip=[4, 4, 4, 4, 4],
filter_size_down=3, filter_size_up=1, filter_skip_size=1,
... | 5,145 | 34.489655 | 128 | py |
SelfDeblur | SelfDeblur-master/models/non_local_embedded_gaussian.py | import torch
from torch import nn
from torch.nn import functional as F
class _NonLocalBlockND(nn.Module):
def __init__(self, in_channels, inter_channels=None, dimension=3, sub_sample=True, bn_layer=True):
super(_NonLocalBlockND, self).__init__()
assert dimension in [1, 2, 3]
self.dimensi... | 4,916 | 36.25 | 102 | py |
SelfDeblur | SelfDeblur-master/models/skip.py | import torch
import torch.nn as nn
from .common import *
from .non_local_dot_product import NONLocalBlock2D
def skip(
num_input_channels=2, num_output_channels=3,
num_channels_down=[16, 32, 64, 128, 128], num_channels_up=[16, 32, 64, 128, 128], num_channels_skip=[4, 4, 4, 4, 4],
filter_si... | 3,885 | 35.317757 | 144 | py |
SelfDeblur | SelfDeblur-master/models/resnet.py | import torch
import torch.nn as nn
from numpy.random import normal
from numpy.linalg import svd
from math import sqrt
import torch.nn.init
from .common import *
class ResidualSequential(nn.Sequential):
def __init__(self, *args):
super(ResidualSequential, self).__init__(*args)
def forward(self, x):
... | 2,945 | 29.371134 | 195 | py |
SelfDeblur | SelfDeblur-master/models/downsampler.py | import numpy as np
import torch
import torch.nn as nn
class Downsampler(nn.Module):
'''
http://www.realitypixels.com/turk/computergraphics/ResamplingFilters.pdf
'''
def __init__(self, n_planes, factor, kernel_type, phase=0, kernel_width=None, support=None, sigma=None, preserve_size=False):
... | 7,872 | 31.66805 | 129 | py |
SelfDeblur | SelfDeblur-master/models/non_local_dot_product.py | import torch
from torch import nn
from torch.nn import functional as F
class _NonLocalBlockND(nn.Module):
def __init__(self, in_channels, inter_channels=None, dimension=3, sub_sample=True, bn_layer=True):
super(_NonLocalBlockND, self).__init__()
assert dimension in [1, 2, 3]
self.dimensi... | 4,926 | 35.496296 | 102 | py |
SelfDeblur | SelfDeblur-master/models/texture_nets.py | import torch
import torch.nn as nn
from .common import *
normalization = nn.BatchNorm2d
def conv(in_f, out_f, kernel_size, stride=1, bias=True, pad='zero'):
if pad == 'zero':
return nn.Conv2d(in_f, out_f, kernel_size, stride, padding=(kernel_size - 1) / 2, bias=bias)
elif pad == 'reflection':
... | 2,315 | 27.95 | 146 | py |
SelfDeblur | SelfDeblur-master/models/non_local_concatenation.py | import torch
from torch import nn
from torch.nn import functional as F
class _NonLocalBlockND(nn.Module):
def __init__(self, in_channels, inter_channels=None, dimension=3, sub_sample=True, bn_layer=True):
super(_NonLocalBlockND, self).__init__()
assert dimension in [1, 2, 3]
self.dimensi... | 5,350 | 35.155405 | 102 | py |
SelfDeblur | SelfDeblur-master/models/common.py | import torch
import torch.nn as nn
import numpy as np
from .downsampler import Downsampler
def add_module(self, module):
self.add_module(str(len(self) + 1), module)
torch.nn.Module.add = add_module
class Concat(nn.Module):
def __init__(self, dim, *args):
super(Concat, self).__init__()
sel... | 3,531 | 27.483871 | 128 | py |
SelfDeblur | SelfDeblur-master/models/unet.py | import torch.nn as nn
import torch
import torch.nn as nn
import torch.nn.functional as F
from .common import *
class ListModule(nn.Module):
def __init__(self, *args):
super(ListModule, self).__init__()
idx = 0
for module in args:
self.add_module(str(idx), module)
id... | 7,408 | 36.045 | 164 | py |
SelfDeblur | SelfDeblur-master/models/__init__.py | from .skip import skip
from .texture_nets import get_texture_nets
from .resnet import ResNet
from .unet import UNet
import torch.nn as nn
def get_net(input_depth, NET_TYPE, pad, upsample_mode, n_channels=3, act_fun='LeakyReLU', skip_n33d=128, skip_n33u=128, skip_n11=4, num_scales=5, downsample_mode='stride'):
if ... | 1,639 | 50.25 | 172 | py |
SelfDeblur | SelfDeblur-master/models/non_local_gaussian.py | import torch
from torch import nn
from torch.nn import functional as F
class _NonLocalBlockND(nn.Module):
def __init__(self, in_channels, inter_channels=None, dimension=3, sub_sample=True, bn_layer=True):
super(_NonLocalBlockND, self).__init__()
assert dimension in [1, 2, 3]
self.dimensi... | 4,674 | 33.124088 | 102 | py |
SelfDeblur | SelfDeblur-master/utils/common_utils.py | import torch
import torch.nn as nn
import torchvision
import sys
import cv2
import numpy as np
from PIL import Image
import PIL
import numpy as np
import matplotlib.pyplot as plt
import random
def crop_image(img, d=32):
'''Make dimensions divisible by `d`'''
imgsize = img.shape
new_size = (imgsize[0] - ... | 8,824 | 28.915254 | 138 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/eval_analyze.py | # Rdkit import should be first, do not move it
try:
from rdkit import Chem
except ModuleNotFoundError:
pass
import utils
import argparse
from qm9 import dataset
from qm9.models import get_model
import os
from equivariant_diffusion.utils import assert_mean_zero_with_mask, remove_mean_with_mask,\
assert_corre... | 7,795 | 38.175879 | 120 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/analyse_geom.py | from rdkit import Chem
import os
import numpy as np
import torch
from torch.utils.data import BatchSampler, DataLoader, Dataset, SequentialSampler
import argparse
import collections
import pickle
import os
import json
from tqdm import tqdm
from IPython.display import display
from matplotlib import pyplot as plt
import ... | 10,412 | 37.283088 | 125 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/utils.py | import numpy as np
import getpass
import os
import torch
# Folders
def create_folders(args):
try:
os.makedirs('outputs')
except OSError:
pass
try:
os.makedirs('outputs/' + args.exp_name)
except OSError:
pass
# Model checkpoints
def save_model(model, path):
torch.s... | 4,012 | 25.058442 | 74 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/build_geom_dataset.py | import msgpack
import os
import numpy as np
import torch
from torch.utils.data import BatchSampler, DataLoader, Dataset, SequentialSampler
import argparse
from qm9.data import collate as qm9_collate
def extract_conformers(args):
drugs_file = os.path.join(args.data_dir, args.data_file)
save_file = f"geom_drugs... | 9,281 | 36.885714 | 101 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/main_geom_drugs.py | # Rdkit import should be first, do not move it
try:
from rdkit import Chem
except ModuleNotFoundError:
pass
import build_geom_dataset
from configs.datasets_config import geom_with_h
import copy
import utils
import argparse
import wandb
from os.path import join
from qm9.models import get_optim, get_model
from eq... | 12,752 | 44.384342 | 138 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/eval_conditional_qm9.py | import argparse
from os.path import join
import torch
import pickle
from qm9.models import get_model
from configs.datasets_config import get_dataset_info
from qm9 import dataset
from qm9.utils import compute_mean_mad
from qm9.sampling import sample
from qm9.property_prediction.main_qm9_prop import test
from qm9.propert... | 10,394 | 43.613734 | 125 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/eval_sample.py | # Rdkit import should be first, do not move it
try:
from rdkit import Chem
except ModuleNotFoundError:
pass
import utils
import argparse
from configs.datasets_config import qm9_with_h, qm9_without_h
from qm9 import dataset
from qm9.models import get_model
from equivariant_diffusion.utils import assert_correct... | 5,606 | 32.981818 | 90 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/main_qm9.py | # Rdkit import should be first, do not move it
try:
from rdkit import Chem
except ModuleNotFoundError:
pass
import copy
import utils
import argparse
import wandb
from configs.datasets_config import get_dataset_info
from os.path import join
from qm9 import dataset
from qm9.models import get_optim, get_model
from... | 13,079 | 44.103448 | 118 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/train_test.py | import wandb
from equivariant_diffusion.utils import assert_mean_zero_with_mask, remove_mean_with_mask,\
assert_correctly_masked, sample_center_gravity_zero_gaussian_with_mask
import numpy as np
import qm9.visualizer as vis
from qm9.analyze import analyze_stability_for_molecules
from qm9.sampling import sample_chai... | 9,409 | 44.240385 | 117 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/equivariant_diffusion/distributions.py | import torch
from equivariant_diffusion.utils import \
center_gravity_zero_gaussian_log_likelihood_with_mask, \
standard_gaussian_log_likelihood_with_mask, \
center_gravity_zero_gaussian_log_likelihood, \
sample_center_gravity_zero_gaussian_with_mask, \
sample_center_gravity_zero_gaussian, \
sam... | 1,865 | 31.172414 | 80 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/equivariant_diffusion/utils.py | import torch
import numpy as np
class EMA():
def __init__(self, beta):
super().__init__()
self.beta = beta
def update_model_average(self, ma_model, current_model):
for current_params, ma_params in zip(current_model.parameters(), ma_model.parameters()):
old_weight, up_weigh... | 4,243 | 29.099291 | 96 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/equivariant_diffusion/en_diffusion.py | from equivariant_diffusion import utils
import numpy as np
import math
import torch
from egnn import models
from torch.nn import functional as F
from equivariant_diffusion import utils as diffusion_utils
# Defining some useful util functions.
def expm1(x: torch.Tensor) -> torch.Tensor:
return torch.expm1(x)
def... | 48,360 | 38.510621 | 178 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/losses.py | import torch
def sum_except_batch(x):
return x.view(x.size(0), -1).sum(dim=-1)
def assert_correctly_masked(variable, node_mask):
assert (variable * (1 - node_mask)).abs().sum().item() < 1e-8
def compute_loss_and_nll(args, generative_model, nodes_dist, x, h, node_mask, edge_mask, context):
bs, n_nodes,... | 1,067 | 25.04878 | 98 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/rdkit_functions.py | from rdkit import Chem
import numpy as np
from qm9.bond_analyze import get_bond_order, geom_predictor
from . import dataset
import torch
from configs.datasets_config import get_dataset_info
import pickle
import os
def compute_qm9_smiles(dataset_name, remove_h):
'''
:param dataset_name: qm9 or qm9_second_half... | 7,154 | 35.136364 | 134 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/utils.py | import torch
def compute_mean_mad(dataloaders, properties, dataset_name):
if dataset_name == 'qm9':
return compute_mean_mad_from_dataloader(dataloaders['train'], properties)
elif dataset_name == 'qm9_second_half' or dataset_name == 'qm9_second_half':
return compute_mean_mad_from_dataloader(dat... | 3,400 | 36.373626 | 92 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/dataset.py | from torch.utils.data import DataLoader
from qm9.data.args import init_argparse
from qm9.data.collate import PreprocessQM9
from qm9.data.utils import initialize_datasets
import os
def retrieve_dataloaders(cfg):
if 'qm9' in cfg.dataset:
batch_size = cfg.batch_size
num_workers = cfg.num_workers
... | 3,840 | 46.419753 | 127 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/sampling.py | import numpy as np
import torch
import torch.nn.functional as F
from equivariant_diffusion.utils import assert_mean_zero_with_mask, remove_mean_with_mask,\
assert_correctly_masked
from qm9.analyze import check_stability
def rotate_chain(z):
assert z.size(0) == 1
z_h = z[:, :, 3:]
n_steps = 30
th... | 6,002 | 34.105263 | 160 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/visualizer.py | import torch
import numpy as np
import os
import glob
import random
import matplotlib
import imageio
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from qm9 import bond_analyze
##############
### Files ####
###########-->
def save_xyz_file(path, one_hot, charges, positions, dataset_info, id_from=0, name='mol... | 15,855 | 34.002208 | 154 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/models.py | import torch
from torch.distributions.categorical import Categorical
import numpy as np
from egnn.models import EGNN_dynamics_QM9
from equivariant_diffusion.en_diffusion import EnVariationalDiffusion
def get_model(args, device, dataset_info, dataloader_train):
histogram = dataset_info['n_nodes']
in_node_nf ... | 6,334 | 34 | 109 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/analyze.py | try:
from rdkit import Chem
from qm9.rdkit_functions import BasicMolecularMetrics
use_rdkit = True
except ModuleNotFoundError:
use_rdkit = False
import qm9.dataset as dataset
import torch
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
import scipy.stats as sp_... | 13,305 | 32.686076 | 594 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/property_prediction/main_qm9_prop.py | import sys, os
sys.path.append(os.path.abspath(os.path.join('../../')))
from qm9.property_prediction.models_property import EGNN, Naive, NumNodes
import torch
from torch import nn, optim
import argparse
from qm9.property_prediction import prop_utils
import json
from qm9 import dataset, utils
import pickle
loss_l1 = nn... | 10,043 | 44.654545 | 197 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/property_prediction/models_property.py | from .models.gcl import E_GCL, unsorted_segment_sum
import torch
from torch import nn
class E_GCL_mask(E_GCL):
"""Graph Neural Net with global state and fixed number of nodes per graph.
Args:
hidden_dim: Number of hidden units.
num_nodes: Maximum number of nodes (for self-attentive pooling... | 6,706 | 40.91875 | 233 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/property_prediction/prop_utils.py | import os
import matplotlib
matplotlib.use('Agg')
import torch
import matplotlib.pyplot as plt
def create_folders(args):
try:
os.makedirs(args.outf)
except OSError:
pass
try:
os.makedirs(args.outf + '/' + args.exp_name)
except OSError:
pass
try:
os.makedirs... | 3,051 | 28.346154 | 128 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/property_prediction/models/gcl.py | from torch import nn
import torch
class MLP(nn.Module):
""" a simple 4-layer MLP """
def __init__(self, nin, nout, nh):
super().__init__()
self.net = nn.Sequential(
nn.Linear(nin, nh),
nn.LeakyReLU(0.2),
nn.Linear(nh, nh),
nn.LeakyReLU(0.2),
... | 12,996 | 36.02849 | 230 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/data/utils.py | import torch
import numpy as np
import logging
import os
from torch.utils.data import DataLoader
from qm9.data.dataset_class import ProcessedDataset
from qm9.data.prepare import prepare_dataset
def initialize_datasets(args, datadir, dataset, subset=None, splits=None,
force_download=False, su... | 7,481 | 39.443243 | 136 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/data/collate.py | import torch
def batch_stack(props):
"""
Stack a list of torch.tensors so they are padded to the size of the
largest tensor along each axis.
Parameters
----------
props : list of Pytorch Tensors
Pytorch tensors to stack
Returns
-------
props : Pytorch tensor
Stack... | 2,718 | 25.144231 | 103 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/data/dataset_class.py | import torch
from torch.utils.data import Dataset
import os
from itertools import islice
from math import inf
import logging
class ProcessedDataset(Dataset):
"""
Data structure for a pre-processed cormorant dataset. Extends PyTorch Dataset.
Parameters
----------
data : dict
Dictionary o... | 3,510 | 36.351064 | 175 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/data/prepare/md17.py | from os.path import join as join
import urllib.request
import numpy as np
import torch
import logging, os, urllib
from qm9.data.prepare.utils import download_data, is_int, cleanup_file
md17_base_url = 'http://quantum-machine.org/gdml/data/npz/'
md17_subsets = {'benzene': 'benzene_old_dft',
'uracil':... | 3,992 | 34.972973 | 156 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/data/prepare/qm9.py | import numpy as np
import torch
import logging
import os
import urllib
from os.path import join as join
import urllib.request
from qm9.data.prepare.process import process_xyz_files, process_xyz_gdb9
from qm9.data.prepare.utils import download_data, is_int, cleanup_file
def download_dataset_qm9(datadir, dataname, s... | 8,060 | 34.355263 | 114 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/qm9/data/prepare/process.py | import logging
import os
import torch
import tarfile
from torch.nn.utils.rnn import pad_sequence
charge_dict = {'H': 1, 'C': 6, 'N': 7, 'O': 8, 'F': 9}
def split_dataset(data, split_idxs):
"""
Splits a dataset according to the indices given.
Parameters
----------
data : dict
Dictionary t... | 6,929 | 33.137931 | 138 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/generated_samples/gschnet/analyze_gschnet.py | # Rdkit import should be first, do not move it
try:
from rdkit import Chem
except ModuleNotFoundError:
pass
import pickle
import torch.nn.functional as F
from qm9.analyze import analyze_stability_for_molecules
import numpy as np
import torch
def flatten_sample_dictionary(samples):
results = {'one_hot': [... | 1,647 | 29.518519 | 96 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/egnn/egnn_new.py | from torch import nn
import torch
import math
class GCL(nn.Module):
def __init__(self, input_nf, output_nf, hidden_nf, normalization_factor, aggregation_method,
edges_in_d=0, nodes_att_dim=0, act_fn=nn.SiLU(), attention=False):
super(GCL, self).__init__()
input_edge = input_nf * 2
... | 12,294 | 43.709091 | 131 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/egnn/egnn.py | import torch
from torch import Tensor
from torch import nn
import torch.nn.functional as F
class E_GCL(nn.Module):
"""Graph Neural Net with global state and fixed number of nodes per graph.
Args:
hidden_dim: Number of hidden units.
num_nodes: Maximum number of nodes (for self-attentive poo... | 14,826 | 41.976812 | 264 | py |
e3_diffusion_for_molecules | e3_diffusion_for_molecules-main/egnn/models.py | import torch
import torch.nn as nn
from egnn.egnn_new import EGNN, GNN
from equivariant_diffusion.utils import remove_mean, remove_mean_with_mask
import numpy as np
class EGNN_dynamics_QM9(nn.Module):
def __init__(self, in_node_nf, context_node_nf,
n_dims, hidden_nf=64, device='cpu',
... | 5,555 | 40.155556 | 107 | py |
deep_bingham | deep_bingham-master/evaluate.py | import argparse
import os
import torch
import torchvision.transforms as transforms
import yaml
import data_loaders
import modules.network
from modules import angular_loss, BinghamFixedDispersionLoss, \
BinghamHybridLoss, BinghamLoss, BinghamMixtureLoss, \
CosineLoss, MSELoss, VonMisesLoss, VonMisesFixedKappaL... | 4,542 | 30.769231 | 79 | py |
deep_bingham | deep_bingham-master/train.py | """
Deep Orientation Estimation Training
"""
import argparse
import os
import sys
import torch
import torch.optim as optim
import torchvision.transforms as transforms
import yaml
from tensorboardX import SummaryWriter
import data_loaders
import modules.network
from modules import BinghamLoss, BinghamMixtureLoss, \
... | 6,909 | 32.543689 | 105 | py |
deep_bingham | deep_bingham-master/modules/maad.py | import torch
from modules.gram_schmidt import gram_schmidt, gram_schmidt_batched
from modules.quaternion_matrix import quaternion_matrix
from utils.utils import \
convert_euler_to_quaternion
from modules.vm_operations import *
import math
def angular_loss_single_sample(target, predicted):
""" Returns the angle... | 4,931 | 37.834646 | 80 | py |
deep_bingham | deep_bingham-master/modules/vm_operations.py | import torch
def output_to_kappas(output):
zero_vec = torch.zeros(len(output), 3)
if output.is_cuda:
device = output.get_device()
zero_vec = torch.zeros(len(output), 3).to(device)
kappas = torch.where(output[:, :3] > 0, output[:, :3], zero_vec)
return kappas
def output_to_angles(outpu... | 1,093 | 27.051282 | 75 | py |
deep_bingham | deep_bingham-master/modules/bingham_mixture_loss.py | """Implementation of the Bingham Mixture Loss"""
import torch
from .maad import angular_loss_single_sample
from .bingham_fixed_dispersion import BinghamFixedDispersionLoss
from .bingham_loss import BinghamLoss
from .gram_schmidt import gram_schmidt_batched
from utils import vec_to_bingham_z_many
class BinghamMixture... | 5,574 | 41.234848 | 83 | py |
deep_bingham | deep_bingham-master/modules/bingham_fixed_dispersion.py | import torch
from modules.gram_schmidt import gram_schmidt_batched
from modules.bingham_loss import batched_logprob
from modules.quaternion_matrix import quaternion_matrix
class BinghamFixedDispersionLoss(object):
"""
Class for calculating bingham loss assuming a fixed Z.
Parameters:
bd_z (list)... | 4,440 | 36.008333 | 80 | py |
deep_bingham | deep_bingham-master/modules/network.py | import torch.nn as nn
from torchvision import models
def get_model(name, pretrained, num_channels, num_classes):
"""
Method that returns a torchvision model given a model
name, pretrained (or not), number of channels,
and number of outputs
Inputs:
name - string corresponding to model name... | 1,587 | 32.083333 | 80 | py |
deep_bingham | deep_bingham-master/modules/von_mises.py | """Implementation of von Mises loss function
Code based on:
https://github.com/sergeyprokudin/deep_direct_stat/blob/master/utils/losses.py
"""
import numpy as np
import torch
import math
import sys
from scipy.interpolate import Rbf
import utils
from utils import generate_coordinates
from modules.maad import maad_bite... | 5,116 | 33.574324 | 79 | py |
deep_bingham | deep_bingham-master/modules/gram_schmidt.py | import torch
def gram_schmidt(input_mat, reverse=False, modified=False):
""" Carries out the Gram-Schmidt orthogonalization of a matrix.
Arguments:
input_mat (torch.Tensor): A quadratic matrix that will be turned into an
orthogonal matrix.
reverse (bool): Starts gram Schmidt metho... | 3,837 | 35.207547 | 80 | py |
deep_bingham | deep_bingham-master/modules/mse.py | import torch
import torch.nn as nn
from modules.maad import maad_mse
class MSELoss(object):
"""
Class for the MSE loss function
"""
def __init__(self):
self.loss = nn.MSELoss(reduction='sum')
def __call__(self, target, output):
"""
Calculates the MSE loss on a batch of targe... | 1,325 | 32.15 | 95 | py |
deep_bingham | deep_bingham-master/modules/bingham_loss.py | """Implementation of the Bingham loss function"""
from __future__ import print_function
import dill
import os
import bingham_distribution as ms
import numpy as np
import torch
from scipy.interpolate import Rbf
import utils
from modules.maad import maad_bingham
from modules.gram_schmidt import gram_schmidt, gram_sch... | 11,124 | 34.205696 | 94 | py |
deep_bingham | deep_bingham-master/modules/cosine.py | from modules.maad import output_to_angles, maad_cosine
from utils import radians
import torch
class CosineLoss():
"""
Class for calculating Cosine Loss assuming biternion representation of pose.
"""
def __init__(self):
self.stats = 0
def __call__(self, target, output):
"""
... | 2,160 | 33.301587 | 86 | py |
deep_bingham | deep_bingham-master/modules/quaternion_matrix.py | import torch
def quaternion_matrix(quat):
""" Computes an orthogonal matrix from a quaternion.
We use the representation from the NeurIPS 2018 paper "Bayesian Pose
Graph Optimization via Bingham Distributions and Tempred Geodesic MCMC" by
Birdal et al. There, the presentation is given above eq. (6). ... | 1,042 | 27.189189 | 78 | py |
deep_bingham | deep_bingham-master/training/trainer.py | import time
import torch
from modules import maad
from utils import AverageMeter
class Trainer(object):
""" Trainer for Bingham Orientation Uncertainty estimation.
Arguments:
device (torch.device): The device on which the training will happen.
"""
def __init__(self, device, floating_point_t... | 8,449 | 39.430622 | 83 | py |
deep_bingham | deep_bingham-master/utils/utils.py | """ Utilities for learning pipeline."""
from __future__ import print_function
import copy
import dill
import hashlib
import itertools
import bingham_distribution as ms
import math
import numpy as np
import os
import scipy
import scipy.integrate as integrate
import scipy.special
import sys
import torch
from pathos.mult... | 15,063 | 33.629885 | 83 | py |
deep_bingham | deep_bingham-master/utils/evaluation.py | import torch
from modules import maad
from utils import AverageMeter, eaad_bingham, eaad_von_mises
import numpy as np
def run_evaluation(model, dataset, loss_function, device, floating_point_type="float"):
model.eval()
losses = AverageMeter()
log_likelihoods = AverageMeter()
maads = AverageMeter()
... | 4,120 | 40.21 | 105 | py |
deep_bingham | deep_bingham-master/data_loaders/t_less_dataset.py | from .utils import *
from torch.utils.data import Dataset, random_split, Subset
import yaml
import os
try:
from yaml import CLoader as Loader
except ImportError:
from yaml import Loader
from PIL import Image
import numpy as np
from skimage import io
import torch
import quaternion
import cv2
import h5py
torch.... | 7,101 | 34.688442 | 103 | py |
deep_bingham | deep_bingham-master/data_loaders/upna_dataset.py | import os
import torch
from PIL import Image
from skimage import io
from torch.utils.data import Dataset
import h5py
from .upna_preprocess import *
from .utils import *
from bingham_distribution import BinghamDistribution
def make_hdf5_file(config, image_transform):
dataset_path = config["preprocess_path"]
csv... | 9,853 | 36.9 | 102 | py |
deep_bingham | deep_bingham-master/data_loaders/idiap_dataset.py | """
Data loading methods from matlab file from:
https://github.com/lucasb-eyer/BiternionNet
"""
import os
import h5py
import yaml
import torch
from PIL import Image
from skimage import io
from torch.utils.data import Dataset
from .utils import *
from bingham_distribution import BinghamDistribution
class IDIAPTrainTest... | 6,671 | 34.679144 | 95 | py |
WSLVideoDenseAnticipation | WSLVideoDenseAnticipation-main/main.py | import argparse
import time
import os
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader
from sklearn.metrics import accuracy_score
from dataloader import DatasetLoader, collate_fn
from primary_pred_module import primModel
from ancill... | 23,720 | 51.596452 | 228 | py |
WSLVideoDenseAnticipation | WSLVideoDenseAnticipation-main/data_preprocessing.py | import os.path
import pickle
import numpy as np
import torch
def read_mapping_dict(mapping_file):
file_ptr = open(mapping_file, 'r')
actions = file_ptr.read().split('\n')[:-1]
actions_dict = dict()
for a in actions:
actions_dict[a.split()[1]] = int(a.split()[0])
return actions_dict
def get... | 17,121 | 48.060172 | 167 | py |
WSLVideoDenseAnticipation | WSLVideoDenseAnticipation-main/ancillary_pred_module.py | '''
input: a video and its weak label
output: predicted frame-wise action
Ancillary predction model outputs a frame-wise action prediction given a video and first second label.
This model generates an initial prediction for the weak set, which will aid training the primary model.
'''
import torch
import torch.nn as nn... | 4,229 | 51.875 | 174 | py |
WSLVideoDenseAnticipation | WSLVideoDenseAnticipation-main/dataloader.py | import torch
import torch.utils.data as data
from data_preprocessing import DataClass
class DatasetLoader(data.Dataset):
def __init__(self, args, path, mode, half=False):
self.dataset = DataClass(args, path, mode, half)
self.obs = float(args.observation[-3:]) #observation portion
self.pred ... | 4,177 | 48.152941 | 212 | py |
WSLVideoDenseAnticipation | WSLVideoDenseAnticipation-main/self_correction_module.py | '''
input: outputs from ancillary module and primary module of weak set
output: full label of weak set
Self-correction module refines predictions generated by the ancillary model and the current primary model for the weak set.
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class selfcorrModel(n... | 2,235 | 53.536585 | 217 | py |
WSLVideoDenseAnticipation | WSLVideoDenseAnticipation-main/primary_pred_module.py | '''
input: a video
output: predicted frame-wise action
Primary prediction model generates a frame-wise prediction of actions given an video.
This is the main model that is subject to the training and is used at test time.
'''
import torch.nn as nn
from blocks import TABlock
import torch
import torch.nn.functional as F... | 4,186 | 51.3375 | 173 | py |
WSLVideoDenseAnticipation | WSLVideoDenseAnticipation-main/blocks.py | import torch
import torch.nn as nn
import torch.nn.functional as F
class NONLocalBlock(nn.Module):
#Non Local Block
def __init__(self, args, dim_1, dim_2, video_feat_dim):
super(NONLocalBlock, self).__init__()
self.dim_1 = dim_1
self.dim_2 = dim_2
self.video_feat_dim = video_fe... | 7,659 | 41.555556 | 153 | py |
fmm2d | fmm2d-main/docs/conf.py | # -*- coding: utf-8 -*-
#
# fmm2d documentation build configuration file, created by
# sphinx-quickstart on Wed Nov 1 16:19:13 2017.
#
# 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... | 10,222 | 32.299674 | 119 | py |
Progressive-Face-Super-Resolution | Progressive-Face-Super-Resolution-master/ssim.py | import torch
import torch.nn.functional as F
from math import exp
import numpy as np
def gaussian(window_size, sigma):
gauss = torch.Tensor([exp(-(x - window_size//2)**2/float(2*sigma**2)) for x in range(window_size)]).double()
# gauss.requires_grad = True
return gauss/gauss.sum()
def create_window(windo... | 3,447 | 30.925926 | 118 | py |
Progressive-Face-Super-Resolution | Progressive-Face-Super-Resolution-master/dataloader.py | from torch.utils.data.dataset import Dataset
import torchvision.transforms as transforms
from os.path import join
from PIL import Image
class CelebDataSet(Dataset):
"""CelebA dataset
Parameters:
data_path (str) -- CelebA dataset main directory(inculduing '/Img' and '/Anno') path
state (str)... | 3,841 | 39.87234 | 125 | py |
Progressive-Face-Super-Resolution | Progressive-Face-Super-Resolution-master/model.py | import torch
import torch.nn as nn
from torch.nn import functional as F
from math import sqrt
"""Original EqualConv2d code is at
https://github.com/rosinality/style-based-gan-pytorch/blob/master/model.py
"""
class EqualLR:
def __init__(self, name):
self.name = name
def compute_weight(self, mo... | 7,795 | 35.773585 | 132 | py |
Progressive-Face-Super-Resolution | Progressive-Face-Super-Resolution-master/demo.py | import torch
import argparse
from model import Generator
from PIL import Image
import torchvision.transforms as transforms
from torchvision import utils
if __name__ == '__main__':
parser = argparse.ArgumentParser('Demo of Progressive Face Super-Resolution')
parser.add_argument('--image-path', type=str)
par... | 2,016 | 41.020833 | 105 | py |
Progressive-Face-Super-Resolution | Progressive-Face-Super-Resolution-master/eval.py | import torch
from torch import optim, nn
import argparse
from dataloader import CelebDataSet
from torch.utils.data import DataLoader
from model import Generator
import os
from torch.autograd import Variable, grad
import sys
from torchvision import utils
from math import log10
from ssim import ssim, msssim
def test(dat... | 4,296 | 41.97 | 166 | py |
ExtendedBitPlaneCompression | ExtendedBitPlaneCompression-master/algoEvals/dataCollect.py | # Copyright (c) 2019 ETH Zurich, Lukas Cavigelli, Georg Rutishauser, Luca Benini
import torch
import numpy as np
import tensorboard
from tensorboard.backend.event_processing.event_accumulator import EventAccumulator
import os
import glob
import csv
import sys
sys.path.append('./quantLab')
def getModel(modelName, ep... | 5,473 | 33.64557 | 123 | py |
blp | blp-master/utils.py | import torch
import logging
import models
def get_model(model, dim, rel_model, loss_fn, num_entities, num_relations,
encoder_name, regularizer):
if model == 'blp':
return models.BertEmbeddingsLP(dim, rel_model, loss_fn, num_relations,
encoder_name, regu... | 7,375 | 39.306011 | 79 | py |
blp | blp-master/data.py | import os.path as osp
import torch
from torch.utils.data import Dataset
import transformers
import string
import nltk
from tqdm import tqdm
from nltk.corpus import stopwords
import logging
UNK = '[UNK]'
nltk.download('stopwords')
nltk.download('punkt')
STOP_WORDS = stopwords.words('english')
DROPPED = STOP_WORDS + lis... | 13,290 | 36.866097 | 79 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.