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 |
|---|---|---|---|---|---|---|
bi-MP-HyeokjinK | bi-MP-HyeokjinK/nets/molecules_graph_regression/bi_gated_gcn_net.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl
"""
ResGatedGCN: Residual Gated Graph ConvNets
An Experimental Study of Neural Networks for Variable Graphs (Xavier Bresson and Thomas Laurent, ICLR 2018)
https://arxiv.org/pdf/1711.07553v2.pdf
"""
from layers.bi_gated_gcn_layer... | 5,158 | 40.272 | 135 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/nets/molecules_graph_regression/bi_graphsage_net.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl
"""
GraphSAGE:
William L. Hamilton, Rex Ying, Jure Leskovec, Inductive Representation Learning on Large Graphs (NeurIPS 2017)
https://cs.stanford.edu/people/jure/pubs/graphsage-nips17.pdf
"""
from layers.graphsage_layer import... | 4,479 | 40.869159 | 135 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/nets/molecules_graph_regression/bi_gat_net.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl.function as fn
import dgl
"""
GAT: Graph Attention Network
Graph Attention Networks (Veličković et al., ICLR 2018)
https://arxiv.org/abs/1710.10903
"""
from layers.gat_layer import GATLayer
from layers.bi_gat_layer import biGATL... | 4,553 | 38.947368 | 135 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/layers/graphsage_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl.function as fn
from dgl.nn.pytorch import SAGEConv
"""
GraphSAGE:
William L. Hamilton, Rex Ying, Jure Leskovec, Inductive Representation Learning on Large Graphs (NeurIPS 2017)
https://cs.stanford.edu/people/jure/pubs/graphsage... | 11,577 | 30.207547 | 114 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/layers/mlp_readout_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
"""
MLP Layer used after graph vector representation
"""
class MLPReadout(nn.Module):
def __init__(self, input_dim, output_dim, L=2): #L=nb_hidden_layers
super().__init__()
list_FC_layers = [ nn.Linear( input_dim//2**l , input... | 726 | 29.291667 | 109 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/layers/bi_graphsage_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl.function as fn
"""
GraphSAGE:
William L. Hamilton, Rex Ying, Jure Leskovec, Inductive Representation Learning on Large Graphs (NeurIPS 2017)
https://cs.stanford.edu/people/jure/pubs/graphsage-nips17.pdf
"""
class biGraphSageLa... | 11,753 | 30.260638 | 114 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/layers/model_utils.py | import torch as th
from torch.autograd import Function
def batch2tensor(batch_adj, batch_feat, node_per_pool_graph):
"""
transform a batched graph to batched adjacency tensor and node feature tensor
"""
batch_size = int(batch_adj.size()[0] / node_per_pool_graph)
adj_list = []
feat_list = []
... | 1,648 | 35.644444 | 81 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/layers/gated_gcn_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl.function as fn
"""
ResGatedGCN: Residual Gated Graph ConvNets
An Experimental Study of Neural Networks for Variable Graphs (Xavier Bresson and Thomas Laurent, ICLR 2018)
https://arxiv.org/pdf/1711.07553v2.pdf
"""
class GatedGCNL... | 6,852 | 33.964286 | 111 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/layers/gat_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from dgl.nn.pytorch import GATConv
"""
GAT: Graph Attention Network
Graph Attention Networks (Veličković et al., ICLR 2018)
https://arxiv.org/abs/1710.10903
"""
class GATLayer(nn.Module):
"""
Parameters
----------
in_dim :... | 10,429 | 29.949555 | 107 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/layers/bi_gated_gcn_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl.function as fn
import numpy as np
"""
ResGatedGCN: Residual Gated Graph ConvNets
An Experimental Study of Neural Networks for Variable Graphs (Xavier Bresson and Thomas Laurent, ICLR 2018)
https://arxiv.org/pdf/1711.07553v2.pdf
"... | 14,818 | 41.583333 | 114 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/layers/gcn_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl
import dgl.function as fn
from dgl.nn.pytorch import GraphConv
"""
GCN: Graph Convolutional Networks
Thomas N. Kipf, Max Welling, Semi-Supervised Classification with Graph Convolutional Networks (ICLR 2017)
http://arxiv.org/abs/... | 2,624 | 31.012195 | 109 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/layers/bi_gat_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl.function as fn
from dgl.nn.pytorch import GATConv
"""
GAT: Graph Attention Network
Graph Attention Networks (Veličković et al., ICLR 2018)
https://arxiv.org/abs/1710.10903
"""
class biGATHeadLayer(nn.Module):
def __init__(s... | 4,247 | 35.307692 | 108 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/layers/bi_gcn_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl
import dgl.function as fn
from dgl.nn.pytorch import GraphConv
"""
GCN: Graph Convolutional Networks
Thomas N. Kipf, Max Welling, Semi-Supervised Classification with Graph Convolutional Networks (ICLR 2017)
http://arxiv.org/abs/... | 3,193 | 37.02381 | 110 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/train/train_superpixels_graph_classification.py | """
Utility functions for training one epoch
and evaluating one epoch
"""
import torch
import torch.nn as nn
import math
from train.metrics import accuracy_MNIST_CIFAR as accuracy
"""
For GCNs
"""
def train_epoch_sparse(model, optimizer, device, data_loader, epoch, mode):
model.train()
epoch_loss... | 4,114 | 32.729508 | 114 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/train/train_molecules_graph_regression.py | """
Utility functions for training one epoch
and evaluating one epoch
"""
import torch
import torch.nn as nn
import math
from train.metrics import MAE
"""
For GCNs
"""
def train_epoch_sparse(model, optimizer, device, data_loader, epoch, mode):
model.train()
epoch_loss = 0
epoch_train_mae = 0
... | 5,399 | 37.297872 | 115 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/train/train_TSP_edge_classification.py | """
Utility functions for training one epoch
and evaluating one epoch
"""
import torch
import torch.nn as nn
import math
import dgl
from train.metrics import binary_f1_score
"""
For GCNs
"""
def train_epoch_sparse(model, optimizer, device, data_loader, epoch, mode):
model.train()
epoch_loss = 0
... | 4,434 | 33.115385 | 114 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/train/metrics.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from sklearn.metrics import confusion_matrix
from sklearn.metrics import f1_score
import numpy as np
def MAE(scores, targets):
MAE = F.l1_loss(scores, targets)
MAE = MAE.detach().item()
return MAE
def accuracy_TU(scores, targets):
s... | 1,988 | 27.826087 | 84 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/train/train_TUs_graph_classification.py | """
Utility functions for training one epoch
and evaluating one epoch
"""
import torch
import torch.nn as nn
import math
from train.metrics import accuracy_TU as accuracy
"""
For GCNs
"""
def train_epoch_sparse(model, optimizer, device, data_loader, epoch, mode):
model.train()
epoch_loss = 0
... | 4,314 | 32.192308 | 113 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/train/train_SBMs_node_classification_for_Eval.py | """
Utility functions for training one epoch
and evaluating one epoch
"""
import torch
import torch.nn as nn
import math
import dgl
from train.metrics import accuracy_SBM as accuracy
"""
For GCNs
"""
def train_epoch_sparse(model, optimizer, device, data_loader, epoch, mode):
model.train()
epoch_... | 4,130 | 30.295455 | 114 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/train/train_SBMs_node_classification.py | """
Utility functions for training one epoch
and evaluating one epoch
"""
import torch
import torch.nn as nn
import math
import dgl
from train.metrics import accuracy_SBM as accuracy
"""
For GCNs
"""
def train_epoch_sparse(model, optimizer, device, data_loader, epoch, mode):
model.train()
epoch_... | 4,940 | 33.3125 | 114 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/data/TSP.py | import time
import pickle
import numpy as np
import itertools
from scipy.spatial.distance import pdist, squareform
import dgl
import torch
from torch.utils.data import Dataset
class TSP(Dataset):
def __init__(self, data_dir, split="train", num_neighbors=25, max_samples=10000):
self.data_dir = data_di... | 9,283 | 41.587156 | 127 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/data/superpixels.py | import os
import pickle
from scipy.spatial.distance import cdist
import numpy as np
import itertools
import dgl
import torch
import torch.utils.data
import time
import csv
from sklearn.model_selection import StratifiedShuffleSplit
def sigma(dists, kth=8):
# Compute sigma and reshape
try:
# Get k-... | 13,741 | 37.385475 | 127 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/data/molecules.py | import torch
import pickle
import torch.utils.data
import time
import os
import numpy as np
import csv
import dgl
from scipy import sparse as sp
import numpy as np
# *NOTE
# The dataset pickle and index files are in ./zinc_molecules/ dir
# [<split>.pickle and <split>.index; for split 'train', 'val' and 'test']
... | 11,339 | 38.65035 | 127 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/data/TUs.py | import torch
import pickle
import torch.utils.data
import time
import os
import numpy as np
import csv
import dgl
from dgl.data import TUDataset
from dgl.data import LegacyTUDataset
import random
random.seed(42)
from sklearn.model_selection import StratifiedKFold, train_test_split
import csv
def get_all_split... | 10,421 | 40.357143 | 129 | py |
bi-MP-HyeokjinK | bi-MP-HyeokjinK/data/SBMs.py |
import time
import os
import pickle
import numpy as np
import dgl
import torch
from scipy import sparse as sp
import numpy as np
class load_SBMsDataSetDGL(torch.utils.data.Dataset):
def __init__(self,
data_dir,
name,
split):
self.split = split
... | 9,012 | 34.908367 | 127 | py |
TextNormSeq2Seq | TextNormSeq2Seq-master/parameters.py | import torch
from torch.backends import cudnn
from torch import cuda
import numpy as np
import argparse
import random
import os
import logging
import lib
logger = logging.getLogger("main")
parser = argparse.ArgumentParser(description='train.py')
## Data options
parser.add_argument('-traindata', default='dataset/train... | 6,371 | 67.516129 | 147 | py |
TextNormSeq2Seq | TextNormSeq2Seq-master/lib/metric/loss.py | import torch
import torch.nn.functional as F
from torch.autograd import Variable
def weighted_xent_loss(logits, targets, mask, normalize=True):
logits_flat = logits.contiguous().view(-1, logits.size(-1))
targets_flat = targets.contiguous().view(-1,)
log_dist = F.log_softmax(logits_flat, dim=-1)
losse... | 1,354 | 41.34375 | 113 | py |
TextNormSeq2Seq | TextNormSeq2Seq-master/lib/metric/utils.py | import torch.nn.functional as F
from torch.autograd import Variable
import lib
import functools
import torch
import logging
logger = logging.getLogger("model")
def clean_sentence(sent, remove_unk=False, remove_eos=True, remove_bos=True):
if lib.constants.EOS_WORD in sent:
sent = sent[:sent.index(lib.cons... | 6,223 | 40.771812 | 196 | py |
TextNormSeq2Seq | TextNormSeq2Seq-master/lib/train/optim.py | from torch.nn.utils import clip_grad_norm_
import torch.optim as optim
import logging
logger = logging.getLogger("optim")
class Optim(object):
def _makeOptimizer(self):
if self.method == 'sgd':
self.optimizer = optim.SGD(self.params, lr=self.lr)
elif self.method == 'adagrad':
... | 1,825 | 34.803922 | 109 | py |
TextNormSeq2Seq | TextNormSeq2Seq-master/lib/train/trainer.py | import os
import time
import torch
import logging
import lib
logger = logging.getLogger("train")
class Trainer(object):
def __init__(self, model, evaluator, train_data, eval_data, optim, opt, test_eval=None):
self.model = model
self.evaluator = evaluator
self.train_data = train_data
... | 3,167 | 44.913043 | 110 | py |
TextNormSeq2Seq | TextNormSeq2Seq-master/lib/data/Dataset.py | from torch.autograd import Variable
import torch
import lib
class Dataset(object):
def __init__(self, data, opt):
self.DATA_KEYS = data.keys()
self.TENSOR_KEYS = ['src', 'tgt']
for key in self.DATA_KEYS:
setattr(self, key, data[key])
self.opt = opt
self.size = le... | 1,906 | 38.729167 | 93 | py |
TextNormSeq2Seq | TextNormSeq2Seq-master/lib/data/Dict.py | from collections import Counter
from .constants import *
import torch
class Dict(object):
def __init__(self, vocab_size, bosWord=None, eosWord=None):
self.vocab = []
self.vocab_counts = None
self.vocab_size = vocab_size
self.bosWord=bosWord
self.eosWord=eosWord
self.... | 3,135 | 32.72043 | 73 | py |
TextNormSeq2Seq | TextNormSeq2Seq-master/lib/model/model_factory.py | import lib
import torch
import logging
logger = logging.getLogger("model")
def build_model(vocabs, opt):
src_vocab, tgt_vocab = vocabs
encoder = lib.model.EncoderRNN(opt, src_vocab)
decoder = lib.model.LuongAttnDecoderRNN(opt, tgt_vocab)
s2smodel = lib.model.Seq2Seq(encoder, decoder, opt)
optim =... | 1,834 | 38.042553 | 101 | py |
TextNormSeq2Seq | TextNormSeq2Seq-master/lib/model/model.py | import torch.nn.functional as F
from torch.autograd import Variable
import torch.nn as nn
import numpy as np
import torch
import lib
import random
class EncoderRNN(nn.Module):
def __init__(self, opt, vocab):
super(EncoderRNN, self).__init__()
self.vocab = vocab
self.opt = opt
self.... | 7,541 | 46.433962 | 130 | py |
booksum | booksum-main/alignments/paragraph-level-summary-alignments/align_data_bi_encoder_paraphrase.py | """
/*
* Copyright (c) 2021, salesforce.com, inc.
* All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
* For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
*/
Script used to generate alignments of the paragraphs with sentences from the summary us... | 12,003 | 37.474359 | 200 | py |
simple-sashimi | simple-sashimi-master/hubconf.py | dependencies = ['torch', 'torchaudio', 'einops', 'opt_einsum', 'fastprogress', 'omegaconf']
import torch
from pathlib import Path
from sashimi.model import Sashimi, SashimiAR
from omegaconf import OmegaConf
def sashimi_ar_sc09(pretrained=True, progress=True, device='cuda'):
""" SaShiMi autoregressive model train... | 893 | 34.76 | 105 | py |
simple-sashimi | simple-sashimi-master/train.py | import argparse
import logging
import os, gc
import math
import random
import time
from dataclasses import dataclass, field
from typing import Tuple, Union
import numpy as np
import pandas as pd
import torch
import torch.multiprocessing as mp
import torch.nn.functional as F
from fastprogress import master_bar, progres... | 15,155 | 42.179487 | 155 | py |
simple-sashimi | simple-sashimi-master/sashimi/model.py | """
SaShiMi backbone.
Use this backbone in your own models. You'll also need to copy over the
standalone S4 layer, which can be found at
`state-spaces/src/models/sequence/ss/standalone/s4.py`.
It's Raw! Audio Generation with State-Space Models
Karan Goel, Albert Gu, Chris Donahue, Christopher Re.
Adapted from http... | 30,791 | 34.638889 | 140 | py |
simple-sashimi | simple-sashimi-master/sashimi/dataset.py | from typing import List, Tuple
import torch
from torch import Tensor
import torch.nn.functional as F
import torchaudio
from torch.utils.data import Dataset, DataLoader
from pathlib import Path
import logging
import random
from glob import glob
from torch.utils.data.distributed import DistributedSampler
import os
import... | 5,266 | 39.206107 | 121 | py |
simple-sashimi | simple-sashimi-master/sashimi/s4.py | """
Standalone version of Structured (Sequence) State Space (S4) model.
Adapted from https://github.com/HazyResearch/state-spaces/blob/diffwave/src/models/sequence/ss/standalone/s4.py
"""
import logging
import math
from functools import partial, wraps
from typing import Any, Callable, Optional, Union
import numpy ... | 40,938 | 34.942932 | 218 | py |
CanineCutaneousTumors | CanineCutaneousTumors-main/evaluation/evaluation_helper.py | import sys
sys.path.insert(0, '../')
from torchvision import transforms
from fastai.vision import *
from sklearn.metrics import confusion_matrix
from tqdm import tqdm
from torch.nn.functional import fold
def segmentation_inference(slide,store, patch_size, level, batch_size, learner, overlap_factor, indices = None):
... | 7,564 | 53.818841 | 166 | py |
CanineCutaneousTumors | CanineCutaneousTumors-main/evaluation/metrics.py | from fastai.vision import *
from sklearn.metrics import jaccard_score
def iou(outputs: torch.Tensor, labels: torch.Tensor):
outputs_max = outputs.argmax(dim=1)
labels_squeezed = labels.squeeze(1)
return tensor(np.mean(jaccard_score(to_np(outputs_max.view(-1)),to_np(labels_squeezed.view(-1)), average=None))... | 1,958 | 50.552632 | 128 | py |
CanineCutaneousTumors | CanineCutaneousTumors-main/segmentation/custom_loss_functions.py | from fastai.vision import *
class FocalLoss(nn.modules.loss._WeightedLoss):
def __init__(self, weight=None, gamma=2,reduction='mean', ignore_index=-1):
super(FocalLoss, self).__init__(weight,reduction=reduction)
self.gamma = gamma
self.ignore_index = ignore_index
self.weight = we... | 2,765 | 34.461538 | 118 | py |
CanineCutaneousTumors | CanineCutaneousTumors-main/segmentation/custom_callbacks.py | from fastai.vision import *
from fastai.callbacks import TrackerCallback
class UpdateProbabilitiesCallback(TrackerCallback):
def __init__(self, learn:Learner, trainslides):
self.iou_dict = dict.fromkeys(["background_iou" , "dermis_iou", "epidermis_iou", "subcutis_iou", "infl_nec_iou", "tumor_iou"],0)
... | 1,111 | 60.777778 | 148 | py |
CanineCutaneousTumors | CanineCutaneousTumors-main/slide/slide_container.py | import openslide
import cv2
from fastai.vision import *
from shapely import geometry
class SlideContainer:
def __init__(self, file: Path,
annotation_file,
level: int = 0,
width: int = 256, height: int = 256,
sample_func = None,dataset_type=None, ... | 5,420 | 43.801653 | 130 | py |
CanineCutaneousTumors | CanineCutaneousTumors-main/slide/slide_helper.py | from fastai.vision import *
from fastai.data_block import *
from fastai.vision.data import SegmentationProcessor
from slide.slide_container import SlideContainer
PreProcessors = Union[PreProcessor, Collection[PreProcessor]]
fastai_types[PreProcessors] = 'PreProcessors'
class SlideLabelList(LabelList):
def __getit... | 4,123 | 36.153153 | 106 | py |
Aegean | Aegean-main/doc/conf.py | # -*- coding: utf-8 -*-
#
# AegeanTools documentation build configuration file, created by
# sphinx-quickstart on Wed Dec 27 14:54:34 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.
#... | 5,022 | 30.006173 | 79 | py |
FLM | FLM-master/run.py | import os
import copy
import json
import torch
import pytorch_lightning as pl
from flm.modules import FLMTransformerSS
from flm.datamodules.multitask_datamodule import MTDataModule
from flm.config import ex
def args_checker(config):
if config['enable_flm_aux_lm_loss']:
assert config['loss_names']['flm'] >... | 4,191 | 33.081301 | 95 | py |
FLM | FLM-master/flm/datamodules/multitask_datamodule.py | from builtins import hasattr
import functools
from pytorch_lightning import LightningDataModule
from torch.utils.data import DataLoader
from torch.utils.data.dataset import ConcatDataset
from torch.utils.data.distributed import DistributedSampler
from . import _datamodules
import webdataset as wds
# datamodule for ... | 4,666 | 34.625954 | 93 | py |
FLM | FLM-master/flm/datamodules/datamodule_base.py | from random import shuffle
import torch
import functools
from pytorch_lightning import LightningDataModule
from torch.utils.data import DataLoader
from transformers import (
DataCollatorForLanguageModeling,
# DataCollatorForWholeWordMask,
BertTokenizer,
RobertaTokenizer,
)
from flm.utils.whole_word_mas... | 11,900 | 35.959627 | 95 | py |
FLM | FLM-master/flm/gadgets/my_metrics.py | import torch
from pytorch_lightning.metrics import Metric
class Accuracy(Metric):
"""log the accuracy metric"""
def __init__(self, dist_sync_on_step=False):
super().__init__(dist_sync_on_step=dist_sync_on_step)
self.add_state("correct", default=torch.tensor(
0.0), dist_reduce_fx="... | 2,553 | 30.925 | 72 | py |
FLM | FLM-master/flm/modules/clip_model.py | # ------------------------------------------------------------------------
# CLIP
# Modified from https://github.com/openai/CLIP/blob/main/clip/model.py
# Copyright (c) OpenAI
# ------------------------------------------------------------------------
import warnings
from tqdm import tqdm
import urllib
import hashlib
i... | 12,963 | 37.698507 | 154 | py |
FLM | FLM-master/flm/modules/flm_tools.py | import torch
import torch.nn.functional as F
def get_corr_bi_attention_mask(mask, mask_r, span_corr_rate=0):
"""prepare the attention mask in reconstrctor"""
bs, L, M, N = mask.shape
org_bi_mask = torch.cat([mask, mask_r], dim=-1)
bi_mask = org_bi_mask.detach().clone()
bi_mask[:, :, torch.arange(1... | 1,859 | 52.142857 | 117 | py |
FLM | FLM-master/flm/modules/meter_utils.py | import torch
import random
from transformers.optimization import AdamW
from transformers import (
get_polynomial_decay_schedule_with_warmup,
get_cosine_schedule_with_warmup,
)
from .dist_utils import all_gather
from .objectives import compute_irtr_recall, compute_caption
from ..gadgets.my_metrics import Accura... | 14,272 | 38.537396 | 102 | py |
FLM | FLM-master/flm/modules/bert_model.py | # coding=utf-8
# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a cop... | 81,268 | 40.719199 | 213 | py |
FLM | FLM-master/flm/modules/dist_utils.py | # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
"""
This file contains primitives for multi-gpu communication.
This is useful when doing distributed training.
"""
import functools
import logging
import numpy as np
import pickle
import torch
import torch.distributed as dist
import torch
_LOCAL_... | 7,810 | 27.822878 | 100 | py |
FLM | FLM-master/flm/modules/objectives.py | # flake8: noqa
import torch
import torch.nn as nn
import torch.nn.functional as F
import os
import glob
import json
import tqdm
import functools
from torch.utils.data.distributed import DistributedSampler
from einops import rearrange
from pycocotools.coco import COCO
from flm.pycocoevalcap.eval import COCOEvalCap
from ... | 26,228 | 35.994358 | 111 | py |
FLM | FLM-master/flm/modules/flm_module.py | import torch
import torch.nn as nn
import pytorch_lightning as pl
from transformers.models.bert.modeling_bert import BertConfig, BertModel
from .bert_model import BertCrossLayer
from . import heads, objectives, meter_utils
from .clip_model import build_model, adapt_position_encoding
from transformers import RobertaConf... | 33,610 | 41.871173 | 122 | py |
FLM | FLM-master/flm/modules/heads.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import pdb
from transformers.models.bert.modeling_bert import BertPredictionHeadTransform
class Pooler(nn.Module):
def __init__(self, hidden_size):
super().__init__()
self.dense = nn.Linear(hidden_size, hidden_size)
self.ac... | 1,280 | 27.466667 | 78 | py |
FLM | FLM-master/flm/datasets/base_dataset.py | import random
import torch
import io
import pyarrow as pa
import os
import pdb
from PIL import Image
from ..transforms import keys_to_transforms
import pdb
import copy
class BaseDataset(torch.utils.data.Dataset):
def __init__(
self,
data_dir: str,
transform_keys: list,
image_size: ... | 12,994 | 38.618902 | 111 | py |
FLM | FLM-master/flm/utils/utils.py | import torch
import torch.nn as nn
from flm.modules import heads, objectives, meter_utils
@torch.no_grad()
def adapt_vocab_size(state_dict, new_vocab_size):
for name in state_dict.keys():
if 'embeddings.word_embeddings.weight' in name or 'fusion_token_embedding.word_embeddings.weight' in name:
... | 2,054 | 36.363636 | 114 | py |
FLM | FLM-master/flm/utils/whole_word_masking.py | import random
import warnings
from dataclasses import dataclass
from typing import Any, Callable, Dict, List, NewType, Optional, Tuple, Union
import torch
from torch.nn.utils.rnn import pad_sequence
# from ..file_utils import PaddingStrategy
# from ..modeling_utils import PreTrainedModel
from transformers.tokenizatio... | 7,709 | 40.902174 | 165 | py |
FLM | FLM-master/flm/transforms/transform.py | from .utils import (
inception_normalize,
imagenet_normalize,
MinMaxResize,
)
from PIL import Image
from torchvision import transforms
from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize
from .randaug import RandAugment
def pixelbert_transform(size=800):
longer = int((1... | 3,695 | 26.176471 | 83 | py |
FLM | FLM-master/flm/transforms/utils.py | from torchvision import transforms
from PIL import Image
class MinMaxResize:
def __init__(self, shorter=800, longer=1333):
self.min = shorter
self.max = longer
def __call__(self, x):
w, h = x.size
scale = self.min / min(w, h)
if h < w:
newh, neww = self.min... | 1,818 | 27.873016 | 98 | py |
FLM | FLM-master/flm/transforms/randaug.py | # code in this file is adpated from rpmcruz/autoaugment
# https://github.com/rpmcruz/autoaugment/blob/master/transformations.py
import random
import PIL
import PIL.ImageOps
import PIL.ImageEnhance
import PIL.ImageDraw
import numpy as np
import torch
from PIL import Image
def ShearX(img, v): # [-0.3, 0.3]
assert... | 7,008 | 24.673993 | 134 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/DWT_IDWT_layer.py | """
自定义 pytorch 层，实现一维、二维、三维张量的 DWT 和 IDWT，未考虑边界延拓
只有当图像行列数都是偶数，且重构滤波器组低频分量长度为 2 时，才能精确重构，否则在边界处有误差。
"""
import numpy as np
import math
from torch.nn import Module
from DWT_IDWT_Functions import *
import pywt
__all__ = ['DWT_1D', 'IDWT_1D', 'DWT_2D', 'IDWT_2D', 'DWT_3D', 'IDWT_3D', 'DWT_2D_tiny']
class DWT_1D(Module):... | 33,457 | 43.081686 | 163 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/preactresnet.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
track_running_stats=True
affine=True
normal_func = nn.BatchNorm2d
# track_runn... | 7,760 | 37.044118 | 152 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/utils.py | import numpy as np
from collections import namedtuple
import torch
from torch import nn
import torchvision
from torch.optim.optimizer import Optimizer, required
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
################################################################
## Components from htt... | 9,281 | 34.7 | 122 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/eval_cifar.py | import argparse
import copy
import logging
import os
import time
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from preactresnet import PreActResNet18
from wideresnet import WideResNet
from wideresnet_wavelet import WideResNetWavelet
from utils_plus import (upper_limit, lower_l... | 3,856 | 33.747748 | 114 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/wideresnet_wavelet.py | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from DWT_IDWT_layer import *
class Downsample_v1(nn.Module):
def __init__(self, wavename = 'haar'):
super(Downsample_v1, self).__init__()
self.dwt = DWT_2D(wavename = wavename)
def forward(self, input):
LL, ... | 8,087 | 39.643216 | 141 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/utils_plus.py | #import apex.amp as amp
import torch
import torch.nn.functional as F
from torchvision import datasets, transforms
from torch.utils.data.sampler import SubsetRandomSampler
import numpy as np
from torch.autograd import Variable
cifar10_mean = (0.4914, 0.4822, 0.4465)
cifar10_std = (0.2471, 0.2435, 0.2616)
mu = torch.t... | 8,417 | 36.247788 | 122 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/DWT_IDWT_Functions.py | # Copyright (c) 2019, Adobe Inc. All rights reserved.
#
# This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike
# 4.0 International Public License. To view a copy of this license, visit
# https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode.
"""
自定义pytorch函数，实现一维、二维、三维张量的DWT和IDWT... | 10,296 | 59.928994 | 205 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/train_cifar.py | import argparse
import logging
import sys
import time
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 os
from wideresnet_wavelet import WideResNetWavelet
from wideresnet import WideResNet
from preactresnet import PreActResNe... | 40,405 | 41.177453 | 208 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/wideresnet.py | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class BasicBlock(nn.Module):
def __init__(self, in_planes, out_planes, stride, dropRate=0.0, activation='ReLU', softplus_beta=1):
super(BasicBlock, self).__init__()
self.bn1 = nn.BatchNorm2d(in_planes)
self.conv1 ... | 5,747 | 43.90625 | 141 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/shufflenetv2.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__()
... | 5,530 | 32.932515 | 107 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/regnet.py | '''RegNet in PyTorch.
Paper: "Designing Network Design Spaces".
Reference: https://github.com/keras-team/keras-applications/blob/master/keras_applications/efficientnet.py
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class SE(nn.Module):
'''Squeeze-and-Excitation block.'''
def __in... | 4,548 | 28.160256 | 106 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/efficientnet.py | '''EfficientNet in PyTorch.
Paper: "EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks".
Reference: https://github.com/keras-team/keras-applications/blob/master/keras_applications/efficientnet.py
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
def swish(x):
return x ... | 5,719 | 31.5 | 106 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/pnasnet.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... | 4,258 | 32.801587 | 105 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/resnet.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 torch
import torch.nn as nn
import torch.nn.functional as F
class BasicBlock(nn.Module):
expansi... | 4,218 | 30.721805 | 83 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/mobilenetv2.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... | 3,092 | 34.551724 | 114 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/vgg.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... | 1,442 | 29.0625 | 117 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/densenet.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... | 3,542 | 31.805556 | 96 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/googlenet.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(
... | 3,221 | 28.833333 | 83 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/resnext.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... | 3,478 | 35.239583 | 129 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/senet.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(... | 4,027 | 32.016393 | 102 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/shufflenet.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... | 3,542 | 31.209091 | 126 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/lenet.py | '''LeNet in PyTorch.'''
import torch.nn as nn
import torch.nn.functional as F
class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16*5*5, 120)
self.fc2 = nn.Linear... | 699 | 28.166667 | 43 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/mobilenet.py | '''MobileNet in PyTorch.
See the paper "MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications"
for more details.
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class Block(nn.Module):
'''Depthwise conv + Pointwise conv'''
def __init__(self, in_planes, out_... | 2,025 | 31.677419 | 123 | py |
AdversarialWaveletTraining | AdversarialWaveletTraining-main/models/dpn.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... | 3,562 | 34.989899 | 116 | py |
IGEV | IGEV-main/IGEV-MVS/train_mvs.py | import argparse
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2'
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.optim as optim
from torch.utils.data import DataLoader
import torch.nn.functional as F
import numpy as np
import random
import time
from to... | 12,780 | 42.472789 | 173 | py |
IGEV | IGEV-main/IGEV-MVS/utils.py | import numpy as np
import torchvision.utils as vutils
import torch
import torch.nn.functional as F
# print arguments
def print_args(args):
print("################################ args ################################")
for k, v in args.__dict__.items():
print("{0: <10}\t{1: <30}\t{2: <20}".format(k,... | 5,160 | 32.296774 | 103 | py |
IGEV | IGEV-main/IGEV-MVS/evaluate_mvs.py | import argparse
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.optim as optim
from torch.utils.data import DataLoader
import torch.nn.functional as F
import numpy as np
import time
from datasets import find... | 21,822 | 47.388027 | 138 | py |
IGEV | IGEV-main/IGEV-MVS/core/corr.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from .submodule import *
class CorrBlock1D_Cost_Volume:
def __init__(self, init_corr, corr, num_levels=2, radius=4, inverse_depth_min=None, inverse_depth_max=None, num_sample=None):
self.num_levels = 2
self.radius = radius
s... | 2,064 | 32.852459 | 129 | py |
IGEV | IGEV-main/IGEV-MVS/core/update.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from .submodule import *
class BasicMotionEncoder(nn.Module):
def __init__(self):
super(BasicMotionEncoder, self).__init__()
self.corr_levels = 2
self.corr_radius = 4
cor_planes = 2 * self.corr_levels * (2*self.cor... | 3,718 | 38.56383 | 107 | py |
IGEV | IGEV-main/IGEV-MVS/core/submodule.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import math
class SubModule(nn.Module):
def __init__(self):
super(SubModule, self).__init__()
def weight_init(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.ker... | 16,724 | 41.234848 | 151 | py |
IGEV | IGEV-main/IGEV-MVS/core/igev_mvs.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from .submodule import *
from .corr import *
from .extractor import *
from .update import *
try:
autocast = torch.cuda.amp.autocast
except:
class autocast:
def __init__(self, enabled):
pass
def __enter__(self):
... | 8,325 | 41.479592 | 227 | py |
IGEV | IGEV-main/IGEV-MVS/core/extractor.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import timm
import math
from .submodule import *
class ResidualBlock(nn.Module):
def __init__(self, in_planes, planes, norm_fn='group', stride=1):
super(ResidualBlock, self).__init__()
self.conv1 = nn.Conv2d(in_planes, planes, ke... | 7,497 | 34.367925 | 102 | py |
IGEV | IGEV-main/IGEV-MVS/datasets/custom.py | from torch.utils.data import Dataset
from datasets.data_io import *
import os
import numpy as np
import cv2
from PIL import Image
from torchvision import transforms as T
import math
class MVSDataset(Dataset):
def __init__(self, datapath, n_views=5, img_wh=(640,480)):
self.levels = 4
self.datapath =... | 5,490 | 36.609589 | 101 | py |
IGEV | IGEV-main/IGEV-MVS/datasets/eth3d.py | from torch.utils.data import Dataset
from datasets.data_io import *
import os
import numpy as np
import cv2
from PIL import Image
class MVSDataset(Dataset):
def __init__(self, datapath, split='test', n_views=7, img_wh=(1920,1280)):
self.levels = 4
self.datapath = datapath
self.img_wh = img_... | 6,164 | 37.773585 | 101 | py |
IGEV | IGEV-main/IGEV-MVS/datasets/dtu_yao_eval.py | from torch.utils.data import Dataset
import numpy as np
import os
from PIL import Image
from datasets.data_io import *
import cv2
class MVSDataset(Dataset):
def __init__(self, datapath, listfile, nviews=5, img_wh=(1600, 1152)):
super(MVSDataset, self).__init__()
self.levels = 4
self.datapa... | 5,897 | 36.09434 | 105 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.