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 |
|---|---|---|---|---|---|---|
perm_hmm | perm_hmm-master/perm_hmm/policies/ignore_transitions.py | """For the special case of two states and two outcomes, computes the optimal
permutations for the related HMM that has transition matrix equal to the
identity matrix.
Because there are only two states, we adopt the convention that the two states
are called the ``dark`` and ``bright`` states. The ``dark`` state is the ... | 5,005 | 40.371901 | 111 | py |
perm_hmm | perm_hmm-master/perm_hmm/policies/min_tree.py | """Make a belief tree labelled with costs, then select the paths giving lowest
costs.
This module contains the
:py:class:`~perm_hmm.policies.min_tree.MinTreePolicy` class, which is a
:py:class:`~perm_hmm.policies.policy.PermPolicy` that selects the
permutations that minimize the cost, computed using a belief tree.
"""... | 18,477 | 42.683215 | 153 | py |
perm_hmm | perm_hmm-master/perm_hmm/policies/policy.py | """This module contains the abstract class
:py:class:`~perm_hmm.policies.policy.PermPolicy`. This class provides
boilerplate to implement a policy for the permutation-based HMM.
"""
import warnings
import torch
from perm_hmm.util import flatten_batch_dims
class PermPolicy(object):
"""
This is an abstract cl... | 8,293 | 39.458537 | 80 | py |
perm_hmm | perm_hmm-master/perm_hmm/policies/rotator_policy.py | """This is an example of a very simple PermPolicy.
The :py:class:`~perm_hmm.policies.policy.PermPolicy` is a class that is
used to select a permutation based on data seen thus far. It takes care of some
boilerplate, but should be subclassed to implement the actual selection
algorithm, and done so in a particular way. ... | 3,629 | 38.456522 | 80 | py |
perm_hmm | perm_hmm-master/perm_hmm/training/interrupted_training.py | r"""Trains the interrupted classifier.
The :py:class:`~perm_hmm.classifiers.interrupted.InterruptedClassifier` has a
parameter that dictates when the likelihood has risen to the point that we can
conclude the inference early. This parameter needs to be learned, which is what
this module provides methods for.
"""
impor... | 6,869 | 40.636364 | 134 | py |
perm_hmm | perm_hmm-master/perm_hmm/models/hmms.py | """
An adaptation of the `pyro.distributions.DiscreteHMM`_ class.
The additions are to the log_prob method (which is incorrect as written in the
pyro package), and the ability to sample from the model, functionality which is
not included in the `pyro`_ model.
.. _pyro.distributions.DiscreteHMM: https://docs.pyro.ai/e... | 34,164 | 41.23115 | 146 | py |
perm_hmm | perm_hmm-master/perm_hmm/analysis/policy_viz.py | """Tools for visualizing permutation policies.
"""
import os
import argparse
from copy import deepcopy
import torch
import anytree as at
from anytree.exporter import UniqueDotExporter
from perm_hmm.util import id_and_transpositions
from perm_hmm.policies.policy import PermPolicy
from perm_hmm.policies.min_tree import M... | 4,371 | 33.425197 | 154 | py |
perm_hmm | perm_hmm-master/perm_hmm/classifiers/generic_classifiers.py | class Classifier(object):
"""
A generic classifier, has only the classify method.
"""
def classify(self, data, verbosity=0):
"""Performs classification
:param torch.Tensor data: Data to classify. Arbitrary shape.
:param verbosity: Flag to return ancillary data generated in the ... | 2,015 | 37.769231 | 93 | py |
perm_hmm | perm_hmm-master/perm_hmm/classifiers/perm_classifier.py | from perm_hmm.classifiers.generic_classifiers import MAPClassifier
class PermClassifier(MAPClassifier):
"""
MAP classifier for an HMM with permutations.
"""
def classify(self, data, perms=None, verbosity=0):
"""Classifies data.
Calls MAPClassifier(self.model.expand_with_perm(perms)).... | 979 | 38.2 | 96 | py |
perm_hmm | perm_hmm-master/perm_hmm/classifiers/interrupted.py | """
This module defines the interrupted classification scheme.
Using an iid model, we can make an inference based on data
which "collects enough evidence".
"""
import torch
from perm_hmm.util import first_nonzero, indices
from perm_hmm.classifiers.generic_classifiers import Classifier
class IIDInterruptedClassifier... | 9,158 | 41.207373 | 145 | py |
perm_hmm | perm_hmm-master/tests/sample_min_entropy_test.py | import unittest
from perm_hmm.models.hmms import PermutedDiscreteHMM
import torch
import pyro
import pyro.distributions as dist
from perm_hmm.util import ZERO
from perm_hmm.policies.min_tree import MinEntPolicy
class MyTestCase(unittest.TestCase):
def setUp(self):
self.num_states = 2
self.observat... | 4,700 | 46.01 | 99 | py |
perm_hmm | perm_hmm-master/tests/postprocessing_tests.py | import unittest
import torch
import torch.distributions
import pyro.distributions as dist
from perm_hmm.policies.min_tree import MinEntPolicy
from perm_hmm.models.hmms import DiscreteHMM, PermutedDiscreteHMM
from perm_hmm.classifiers.interrupted import IIDInterruptedClassifier
from perm_hmm.training.interrupted_trainin... | 6,561 | 47.25 | 114 | py |
perm_hmm | perm_hmm-master/tests/ignore_transitions_tests.py | import pytest
import numpy as np
from scipy.special import logsumexp, log1p
import torch
import pyro.distributions as dist
from perm_hmm.util import num_to_data
from perm_hmm.policies.ignore_transitions import IgnoreTransitions
from perm_hmm.models.hmms import PermutedDiscreteHMM
from perm_hmm.classifiers.perm_classi... | 4,190 | 37.1 | 105 | py |
perm_hmm | perm_hmm-master/tests/loss_function_tests.py | import torch
import perm_hmm.loss_functions as lf
from perm_hmm.util import ZERO
def expanded_log_zero_one(state, classification):
sl = state // 2
cl = classification // 2
loss = sl != cl
floss = loss.float()
floss[~loss] = ZERO
log_loss = floss.log()
log_loss[~loss] = 2*log_loss[~loss]
... | 751 | 22.5 | 49 | py |
perm_hmm | perm_hmm-master/tests/perm_hmm_tests.py | import numpy as np
import torch
import pyro.distributions as dist
from perm_hmm.models.hmms import PermutedDiscreteHMM
from perm_hmm.policies.policy import PermPolicy
from perm_hmm.policies.min_tree import MinEntPolicy
from perm_hmm.policies.rotator_policy import RotatorPolicy, cycles
from perm_hmm.util import ZERO, ... | 7,129 | 36.925532 | 116 | py |
perm_hmm | perm_hmm-master/tests/tree_strategy_tests.py | import pytest
import numpy as np
import torch
import pyro.distributions as dist
from example_systems.three_states import three_state_hmm
from perm_hmm.models.hmms import PermutedDiscreteHMM
from perm_hmm.util import all_strings, id_and_transpositions, ZERO
from tests.min_ent import MinEntropyPolicy
from perm_hmm.polici... | 5,907 | 52.225225 | 138 | py |
perm_hmm | perm_hmm-master/tests/test_min_ent_again.py | from functools import wraps
from functools import reduce
from operator import mul
import numpy as np
import pytest
import torch
import pyro.distributions as dist
from pyro.distributions.hmm import _logmatmulexp
from perm_hmm.models.hmms import PermutedDiscreteHMM
from typing import NamedTuple
from perm_hmm.util impor... | 31,332 | 37.778465 | 140 | py |
perm_hmm | perm_hmm-master/tests/perm_selector_tests.py | import pytest
import unittest
from copy import deepcopy
import numpy as np
import torch
import pyro.distributions as dist
from perm_hmm.models.hmms import DiscreteHMM, PermutedDiscreteHMM
from perm_hmm.policies.min_tree import MinEntPolicy
from perm_hmm.util import bin_ent, ZERO, perm_idxs_from_perms
def get_marginal... | 8,690 | 38.148649 | 148 | py |
perm_hmm | perm_hmm-master/tests/skip_first_tests.py | import numpy as np
import torch
import pyro.distributions as dist
from perm_hmm.models.hmms import SkipFirstDiscreteHMM
from perm_hmm.util import num_to_data, all_strings
def state_sequence_lp(seq, il, tl):
n = len(seq) - 1
return il[seq[0]] + tl.expand((n,) + tl.shape)[
torch.arange(n), seq[:-1], seq... | 3,666 | 35.67 | 167 | py |
perm_hmm | perm_hmm-master/tests/test_exhaustive.py | import pytest
from operator import mul
from functools import reduce
import numpy as np
from scipy.special import logsumexp
import matplotlib.pyplot as plt
import torch
import pyro.distributions as dist
import adapt_hypo_test.two_states.util as twotil
from perm_hmm.models.hmms import PermutedDiscreteHMM, random_phmm
... | 5,647 | 43.472441 | 244 | py |
perm_hmm | perm_hmm-master/tests/confusion_matrix_test.py | import unittest
import torch
import torch.distributions as dist
from perm_hmm.postprocessing import EmpiricalPostprocessor, ExactPostprocessor
from perm_hmm.util import ZERO
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.num_states = 10
self.testing_states = torch.tensor([0, 3,... | 5,022 | 58.094118 | 129 | py |
perm_hmm | perm_hmm-master/tests/bernoulli_tests.py | import unittest
import torch
import pyro.distributions as dist
from perm_hmm.classifiers.interrupted import IIDInterruptedClassifier
from perm_hmm.models.hmms import DiscreteHMM, PermutedDiscreteHMM
from perm_hmm.simulator import HMMSimulator
from perm_hmm.util import transpositions, num_to_data
from perm_hmm.policies.... | 3,643 | 41.870588 | 90 | py |
perm_hmm | perm_hmm-master/tests/interrupted_tests.py | import unittest
import torch
import pyro.distributions as dist
from perm_hmm.classifiers.interrupted import IIDInterruptedClassifier, IIDBinaryIntClassifier
from perm_hmm.models.hmms import DiscreteHMM, PermutedDiscreteHMM
from perm_hmm.postprocessing import ExactPostprocessor, EmpiricalPostprocessor
import perm_hmm.tr... | 5,890 | 48.091667 | 207 | py |
perm_hmm | perm_hmm-master/tests/sample_test.py | import unittest
import torch
import numpy as np
import pyro.distributions as dist
from pyro.distributions import DiscreteHMM
from perm_hmm.models.hmms import DiscreteHMM as MyDiscreteHMM
from perm_hmm.models.hmms import PermutedDiscreteHMM
from perm_hmm.util import ZERO, num_to_data
def to_base(x, y, max_length=None)... | 6,266 | 41.632653 | 131 | py |
perm_hmm | perm_hmm-master/tests/util_tests.py | import unittest
import torch
from perm_hmm import util
class MyTestCase(unittest.TestCase):
def test_first_nonzero(self):
batch_shape = (5,)
sample_shape = (100, 6, 7)
foos = torch.distributions.Bernoulli(torch.rand(batch_shape)).sample(sample_shape).bool()
for foo in foos:
... | 2,652 | 41.111111 | 97 | py |
perm_hmm | perm_hmm-master/tests/binning_tests.py | import pytest
import torch
import pyro.distributions as dist
from perm_hmm.binning import bin_histogram, bin_log_histogram, binned_expanded_hmm, binned_hmm, optimally_binned_consecutive
from perm_hmm.models.hmms import DiscreteHMM, PermutedDiscreteHMM, ExpandedHMM
from example_systems.bin_beryllium import binned_hmm_c... | 4,281 | 29.585714 | 124 | py |
perm_hmm | perm_hmm-master/example_systems/three_states.py | r"""
This module implements a simple three state model shown in the figure. The
circles on the left represent states, while the squares on the right are
outputs.
.. image:: _static/three_state_model.svg
"""
import numpy as np
import torch
import pyro.distributions as dist
from perm_hmm.util import ZERO, log1mexp
from ... | 2,438 | 30.269231 | 136 | py |
perm_hmm | perm_hmm-master/example_systems/bin_beryllium.py | import os
import argparse
from itertools import combinations
import numpy as np
import matplotlib.pyplot as plt
import torch
from scipy.special import logsumexp
import pyro.distributions as dist
from pyro.distributions import Categorical
from perm_hmm.models.hmms import ExpandedHMM
from perm_hmm.simulator import HMMSim... | 8,753 | 37.906667 | 223 | py |
AdaGCN_TKDE | AdaGCN_TKDE-main/layers.py | from inits import *
import tensorflow as tf
flags = tf.app.flags
FLAGS = flags.FLAGS
# global unique layer ID dictionary for layer name assignment
_LAYER_UIDS = {}
def get_layer_uid(layer_name=''):
"""Helper function, assigns unique layer IDs."""
if layer_name not in _LAYER_UIDS:
_LAYER_UIDS[layer_n... | 6,120 | 28.427885 | 84 | py |
GOAD | GOAD-master/opt_tc.py | import torch.utils.data
import numpy as np
import torch
import torch.utils.data
from torch.backends import cudnn
from wideresnet import WideResNet
from sklearn.metrics import roc_auc_score
cudnn.benchmark = True
def tc_loss(zs, m):
means = zs.mean(0).unsqueeze(0)
res = ((zs.unsqueeze(2) - means.unsqueeze(1)) ... | 3,871 | 38.510204 | 124 | py |
GOAD | GOAD-master/data_loader.py | import scipy.io
import numpy as np
import pandas as pd
import torchvision.datasets as dset
import os
class Data_Loader:
def __init__(self, n_trains=None):
self.n_train = n_trains
self.urls = [
"http://kdd.ics.uci.edu/databases/kddcup99/kddcup.data_10_percent.gz",
"http://kdd.ics.uc... | 7,157 | 34.79 | 98 | py |
GOAD | GOAD-master/transformations.py | import abc
import itertools
import numpy as np
from keras.preprocessing.image import apply_affine_transform
# The code is adapted from https://github.com/izikgo/AnomalyDetectionTransformations/blob/master/transformations.py
def get_transformer(type_trans):
if type_trans == 'complicated':
tr_x, tr_y = 8, 8
... | 2,988 | 33.755814 | 115 | py |
GOAD | GOAD-master/opt_tc_tabular.py | import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import fcnet as model
from sklearn.metrics import precision_recall_fscore_support as prf
def tc_loss(zs, m):
means = zs.mean(0).unsqueeze(0)
res = ((zs.unsqueeze(2) - means.unsqueeze(1)) ** 2).sum(-1)
pos = torch.diagonal(res... | 3,968 | 39.5 | 128 | py |
GOAD | GOAD-master/fcnet.py | import torch.nn as nn
import torch.nn.init as init
import numpy as np
def weights_init(m):
classname = m.__class__.__name__
if isinstance(m, nn.Linear):
init.xavier_normal_(m.weight, gain=np.sqrt(2.0))
elif classname.find('Conv') != -1:
init.xavier_normal_(m.weight, gain=np.sqrt(2.0))
e... | 1,759 | 30.428571 | 56 | py |
GOAD | GOAD-master/wideresnet.py | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
# The code is adapted from https://github.com/xternalz/WideResNet-pytorch/blob/master/wideresnet.py
class BasicBlock(nn.Module):
def __init__(self, in_planes, out_planes, stride, dropRate=0.0):
super(BasicBlock, self).__init__(... | 4,139 | 40.4 | 116 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/test.py | import time
import os
from tqdm import tqdm
import torch
from torch import nn
from torch.utils.data import DataLoader
from datasets import load_data
from utils import AverageMeter, load_checkpoint, parse_opt
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
def test(model: nn.Module, model_name: ... | 2,873 | 37.837838 | 142 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/nlp_dl_bench_train.py | import os
os.environ['CUDA_VISIBLE_DEVICES'] = '1'
import torch
import torch.backends.cudnn as cudnn
from torch import optim, nn
import time
import random
import models
from trainer import Trainer
from datasets import load_data
from utils import load_embeddings, load_checkpoint, parse_opt
def set_trainer(config, ... | 6,811 | 31.438095 | 162 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/classify.py | import os
import json
from nltk.tokenize import PunktSentenceTokenizer, TreebankWordTokenizer
from typing import Tuple, Dict
import torch
from torch import nn
from datasets import get_clean_text, get_label_map, load_data
from utils import *
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# path... | 6,739 | 32.039216 | 172 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/trainer/trainer.py | import time
from typing import Optional, Dict
import torch
from torch import nn, optim
from torch.utils.data import DataLoader
import os
import torch.backends.cudnn as cudnn
from tqdm import tqdm
from utils import TensorboardWriter, AverageMeter, save_checkpoint, \
clip_gradient, adjust_learning_rate
def get_cu... | 15,444 | 35.426887 | 146 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/__init__.py | import torch
from .HAN import HAN
from .fastText import fastText
from .AttBiLSTM import AttBiLSTM
from .TextCNN import TextCNN1D, TextCNN2D
from .Transformer import Transformer
from utils.opts import Config
def make(
config: Config,
n_classes: int,
vocab_size: int,
embeddings: torch.Tensor,
emb_si... | 3,745 | 31.293103 | 83 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/TextCNN/cnn2d.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import List
class TextCNN2D(nn.Module):
"""
Implementation of 2D version of TextCNN proposed in paper [1].
`Here <https://github.com/yoonkim/CNN_sentence>`_ is the official
implementation of TextCNN.
Parameters
---... | 4,764 | 29.544872 | 145 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/TextCNN/cnn1d.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import List
class TextCNN1D(nn.Module):
"""
Implementation of 1D version of TextCNN proposed in paper [1].
`Here <https://github.com/yoonkim/CNN_sentence>`_ is the official
implementation of TextCNN.
Parameters
---... | 4,842 | 29.459119 | 134 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/Transformer/encoder_layer.py | import torch
import torch.nn as nn
from typing import Optional, Tuple
from .attention import MultiHeadAttention
from .ffn import PositionWiseFeedForward
class EncoderLayer(nn.Module):
"""
An encoder layer.
Parameters
----------
d_model : int
Size of word embeddings
n_heads : int
... | 1,824 | 29.416667 | 141 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/Transformer/ffn.py | import torch
import torch.nn as nn
class PositionWiseFeedForward(nn.Module):
"""
Position-Wise Feed-Forward Network
Parameters
----------
d_model : int
Size of word embeddings
hidden_size : int
Size of position-wise feed forward network
dropout : float
Dropout
... | 1,361 | 26.24 | 85 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/Transformer/transformer.py | import copy
import torch
from torch import nn
from .pe import PositionalEncoding
from .encoder_layer import EncoderLayer
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
def get_padding_mask(seq: torch.Tensor, pad_idx: int = 0) -> torch.Tensor:
"""
Mask tokens that are pads (not pad: 1, ... | 4,632 | 28.509554 | 105 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/Transformer/pe.py | import torch
import torch.nn as nn
import numpy as np
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
class PositionalEncoding(nn.Module):
"""
Positional Encoding
Parameters
----------
d_model : int
Size of word embeddings
word_pad_len : int
Length of th... | 1,596 | 29.132075 | 87 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/Transformer/attention.py | import torch
import torch.nn as nn
from typing import Optional, Tuple
class ScaledDotProductAttention(nn.Module):
"""
Scaled Dot-Product Attention
Parameters
----------
scale : float
Scale factor (sqrt(d_k))
dropout : float
Dropout
"""
def __init__(self, scale: float, ... | 4,635 | 29.906667 | 145 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/AttBiLSTM/att_bilstm.py | import torch
from torch import nn
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence, PackedSequence
from .attention import Attention
class AttBiLSTM(nn.Module):
"""
Implementation of Attention-based bidirectional LSTM proposed in paper [1].
Parameters
----------
n_classes :... | 4,575 | 31 | 137 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/AttBiLSTM/attention.py | import torch
from torch import nn
from typing import Tuple
class Attention(nn.Module):
"""
Attention network
Parameters
----------
rnn_size : int
Size of Bi-LSTM
"""
def __init__(self, rnn_size: int) -> None:
super(Attention, self).__init__()
self.w = nn.Linear(rnn_... | 1,279 | 26.234043 | 76 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/HAN/word_encoder.py | import torch
import torch.nn as nn
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence, PackedSequence
from typing import Tuple
class WordEncoder(nn.Module):
"""
Word-level attention module
Parameters
----------
vocab_size : int
Number of words in the vocabulary
e... | 5,016 | 33.363014 | 147 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/HAN/han.py | import torch
import torch.nn as nn
from typing import Tuple
from .sent_encoder import *
class HAN(nn.Module):
"""
Implementation of Hierarchial Attention Network (HAN) proposed in paper [1].
Parameters
----------
n_classes : int
Number of classes
vocab_size : int
Number of wo... | 3,401 | 26.885246 | 162 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/HAN/sent_encoder.py | import torch
import torch.nn as nn
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence, PackedSequence
from typing import Tuple
from .word_encoder import WordEncoder
class SentenceEncoder(nn.Module):
"""
Sentence-level attention module
Parameters
----------
vocab_size : int
... | 6,680 | 35.508197 | 175 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/models/fastText/fasttext.py | import torch
from torch import nn
class fastText(nn.Module):
"""
Implementation of fastText proposed in paper [1].
`Here <https://github.com/facebookresearch/fastText>`_ is the official
implementation of fastText.
Parameters
----------
n_classes : int
Number of classes
vocab_... | 3,017 | 28.019231 | 92 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/datasets/dataloader.py | """
Load data from manually preprocessed data (see ``datasets/prepocess/``).
"""
import os
import json
from typing import Dict, Tuple, Union
import torch
from torch.utils.data import Dataset, DataLoader
from utils import load_embeddings
from utils.opts import Config
from .info import get_label_map
import sys
sys.pa... | 12,615 | 33.659341 | 139 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/datasets/torchtext.py | '''
script for loading data for sentence classification using torchtext (never used)
I abandon this because torchtext loads all data in one go, which occupies
too much memory and slows down the training speed, expecially when the dataset
is big.
So I finally choose to preprocess data manually (see datasets/prepoces... | 4,413 | 34.596774 | 152 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/datasets/preprocess/document.py | """
Preprocess data for document classification.
"""
import torch
from typing import Tuple, Dict
from collections import Counter
from nltk.tokenize import PunktSentenceTokenizer, TreebankWordTokenizer
from tqdm import tqdm
import pandas as pd
import os
import json
from .utils import get_clean_text
# tokenizers
sent_... | 6,873 | 30.972093 | 142 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/datasets/preprocess/sentence.py | """
Preprocess data for sentence classification.
"""
import torch
from typing import Tuple, Dict
from collections import Counter
from nltk.tokenize import PunktSentenceTokenizer, TreebankWordTokenizer
from tqdm import tqdm
import pandas as pd
import os
import json
from .utils import get_clean_text
# tokenizers
word_... | 5,431 | 29.516854 | 142 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/utils/embedding.py | import os
from tqdm import tqdm
from typing import Dict, Tuple
import numpy as np
import torch
def init_embeddings(embeddings: torch.Tensor) -> None:
"""
Fill embedding tensor with values from the uniform distribution.
Parameters
----------
embeddings : torch.Tensor
Word embedding tensor
... | 2,499 | 28.411765 | 104 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/utils/tensorboard.py | import importlib
from typing import Optional, Callable
from datetime import datetime
class TensorboardWriter:
"""
Log metrics into a directory for visualization within the TensorBoard.
Parameters
----------
log_dir : str, optional
Paht to the folder to save logs for TensorBoard
enable... | 2,982 | 35.82716 | 122 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlp_dl_bench/utils/common.py | import os
from typing import Tuple, Dict
import torch
from torch import nn, optim
def save_checkpoint(
epoch: int,
model: nn.Module,
model_name: str,
optimizer: optim.Optimizer,
dataset_name: str,
word_map: Dict[str, int],
checkpoint_path: str,
checkpoint_basename: str = 'checkpoint'
) ... | 4,047 | 24.459119 | 83 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/imagenet_dl_bench/pre_process/images_raw_to_tfrecord.py | import matplotlib.pyplot as plt
from PIL import Image
from torchvision import transforms
import numpy as np
import torch
import sys
import os
import datetime
sys.path.append("../shuffleformat/tfrecord")
sys.path.append("../shuffleformat/corgipile")
sys.path.append(".")
import shuffleformat.tfrecord as tfrecord
import... | 8,062 | 35.31982 | 138 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/imagenet_dl_bench/normal_node/imagenet_corgipile_raw_train.py | import argparse
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0, 1, 2, 3, 4, 5, 6, 7'
import random
import shutil
import time
import warnings
from enum import Enum
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.optim
fr... | 30,945 | 35.025611 | 137 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/imagenet_dl_bench/euler/imagenet_corgipile_raw_train_on_euler.py | import argparse
import os
import random
import shutil
import time
import warnings
from enum import Enum
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.optim
from torch.optim.lr_scheduler import StepLR
import torch.multiproc... | 30,880 | 35.075935 | 137 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/shuffleformat/corgipile/dataset.py | import typing
import numpy as np
import datetime
import random
import time
import math
import torch.utils.data
import torch.distributed as dist
from shuffleformat.corgipile import block_reader_tfrecord
from shuffleformat.corgipile import block_iterator_utils
from shuffleformat.corgipile import seq_reader_tfrecord
... | 18,063 | 36.168724 | 152 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/shuffleformat/corgipile/block_iterator_utils.py | """Iterator utils."""
from __future__ import division
import typing
import warnings
import random
import datetime
import numpy as np
import torch.distributed as dist
def shuffle_iterator(iterator: typing.Iterator,
buffer_size: int) -> typing.Iterable[typing.Any]:
random.seed()
end_fil... | 687 | 18.111111 | 70 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/shuffleformat/tfrecord/__init__.py | from shuffleformat.tfrecord import tools
from shuffleformat.tfrecord import torch
from shuffleformat.tfrecord import example_pb2
from shuffleformat.tfrecord import iterator_utils
from shuffleformat.tfrecord import reader
from shuffleformat.tfrecord import writer
from shuffleformat.tfrecord.iterator_utils import *
fro... | 405 | 32.833333 | 51 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/shuffleformat/tfrecord/torch/dataset.py | """Load tfrecord files into torch datasets."""
import typing
import numpy as np
import torch.utils.data
from shuffleformat.tfrecord import reader
from shuffleformat.tfrecord import iterator_utils
class TFRecordDataset(torch.utils.data.IterableDataset):
"""Parse (generic) TFRecords dataset into `IterableDataset... | 7,917 | 42.505495 | 106 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/shuffleformat/tfrecord/torch/__init__.py | from shuffleformat.tfrecord.torch import dataset
from shuffleformat.tfrecord.torch.dataset import TFRecordDataset
from shuffleformat.tfrecord.torch.dataset import MultiTFRecordDataset
| 185 | 36.2 | 69 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlpformat/in_mem_sliding_window/dataset.py | import numpy as np
import warnings
import random
import time
import os
import torch.utils.data
from nlpformat.loader import nlp_format_dataloader
class InMemSlidingWindowDocDataset(torch.utils.data.IterableDataset):
def __init__(self,
data_folder: str,
split: str,
... | 6,152 | 32.622951 | 159 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlpformat/in_mem_block/block_dataset.py | """Load tfrecord files into torch datasets."""
import typing
import numpy as np
import datetime
import random
import time
import os
import torch.utils.data
from nlpformat.loader import nlp_format_dataloader
from nlpformat.in_mem_block import block_iterator_utils
class InMemBlockDocDataset(torch.utils.data.Iterable... | 7,594 | 33.522727 | 159 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlpformat/in_mem_bismarck/dataset.py | """Load tfrecord files into torch datasets."""
import numpy as np
import os
import pickle
import time
import torch.utils.data
from nlpformat.loader import nlp_format_dataloader
from nlpformat.in_mem_bismarck import iterator_utils
class InMemBismarckDocDataset(torch.utils.data.IterableDataset):
def __init__(sel... | 9,240 | 36.718367 | 159 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlpformat/in_mem_once_fully_shuffle/dataset.py | import numpy as np
import random
import time
import os
import torch.utils.data
from nlpformat.loader import nlp_format_dataloader
class InMemOnceFullyShuffleDocDataset(torch.utils.data.Dataset):
def __init__(self,
data_folder: str, split: str,
use_clustered_data: bool
... | 3,641 | 33.685714 | 157 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlpformat/in_mem_block_only/block_only_dataset.py | """Load tfrecord files into torch datasets."""
import numpy as np
import random
import time
import os
import torch.utils.data
from nlpformat.loader import nlp_format_dataloader
from nlpformat.in_mem_block_only import block_only_iterator_utils
class InMemBlockOnlyDocDataset(torch.utils.data.IterableDataset):
... | 7,336 | 34.965686 | 159 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/nlpformat/in_mem_no_shuffle/dataset.py | import numpy as np
import random
import time
import torch.utils.data
from nlpformat.loader import nlp_format_dataloader
"""
Load data from manually preprocessed data (see ``datasets/prepocess/``).
"""
import os
from typing import Tuple
import torch
from torch.utils.data import Dataset
class InMemNoShuffleDocDat... | 4,597 | 32.562044 | 168 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifarformat/in_mem_sliding_window/dataset.py | import numpy as np
import warnings
import random
import time
import torch.utils.data
from cifarformat.loader import cifar_format_dataloader
class InMemSlidingWindowCifarDataset(torch.utils.data.IterableDataset):
def __init__(self,
base_dir: str,
use_clustered_data: bool,
... | 2,903 | 30.565217 | 126 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifarformat/in_mem_block/block_dataset.py | """Load tfrecord files into torch datasets."""
import typing
import numpy as np
import datetime
import random
import time
import torch.utils.data
from cifarformat.loader import cifar_format_dataloader
from cifarformat.in_mem_block import block_iterator_utils
class InMemBlockCifarDataset(torch.utils.data.IterableDa... | 3,726 | 32.276786 | 126 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifarformat/in_mem_bismarck/dataset.py | """Load tfrecord files into torch datasets."""
import numpy as np
import os
import pickle
import time
import torch.utils.data
from cifarformat.loader import cifar_format_dataloader
from cifarformat.in_mem_bismarck import iterator_utils
class InMemBismarckCifarDataset(torch.utils.data.IterableDataset):
def __in... | 4,460 | 35.867769 | 126 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifarformat/in_mem_once_fully_shuffle/dataset.py | import numpy as np
import random
import time
import torch.utils.data
from cifarformat.loader import cifar_format_dataloader
class InMemOnceFullyShuffleCifarDataset(torch.utils.data.Dataset):
def __init__(self,
base_dir: str,
use_clustered_data: bool,
train... | 2,060 | 29.761194 | 126 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifarformat/in_mem_always_fully_shuffle/dataset.py | import numpy as np
import random
import time
import torch.utils.data
from cifarformat.loader import cifar_format_dataloader
class InMemAlwaysFullyShuffleCifarDataset(torch.utils.data.Dataset):
def __init__(self,
base_dir: str,
use_clustered_data: bool,
tra... | 2,096 | 29.838235 | 126 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifarformat/loader/cifar_format_dataloader.py | """Reader utils"""
import os
import time
import numpy as np
import torchvision
import random
class MY_CIFAR10(torchvision.datasets.CIFAR10):
def __init__(self, root, train=True, use_clustered_data=True):
super(MY_CIFAR10, self).__init__(root, train=train, transform=None,
... | 1,059 | 29.285714 | 96 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifarformat/in_mem_block_only/block_only_dataset.py | """Load tfrecord files into torch datasets."""
import typing
import numpy as np
import datetime
import random
import time
import torch.utils.data
from cifarformat.loader import cifar_format_dataloader
from cifarformat.in_mem_block_only import block_only_iterator_utils
class InMemBlockOnlyCifarDataset(torch.utils.d... | 3,748 | 32.473214 | 126 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifarformat/in_mem_no_shuffle/dataset.py | import numpy as np
import random
import time
import torch.utils.data
from cifarformat.loader import cifar_format_dataloader
class InMemNoShuffleCifarDataset(torch.utils.data.Dataset):
def __init__(self,
base_dir: str,
use_clustered_data: bool,
train=True, transf... | 1,802 | 28.557377 | 126 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/cifar_dl_bench_train.py | '''Train CIFAR10 with PyTorch.'''
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torch.backends.cudnn as cudnn
import torchvision
import torchvision.transforms as transforms
import os
import argparse
import sys
import time
import random
sys.path.append("../cifa... | 14,325 | 30.906459 | 170 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/models/dla.py | '''DLA in PyTorch.
Reference:
Deep Layer Aggregation. https://arxiv.org/abs/1707.06484
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, in_planes, planes, stride=1):
super(BasicBlock, self).__init__()
sel... | 4,425 | 31.544118 | 83 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/models/dla_simple.py | '''Simplified version of DLA in PyTorch.
Note this implementation is not identical to the original paper version.
But it seems works fine.
See dla.py for the original paper version.
Reference:
Deep Layer Aggregation. https://arxiv.org/abs/1707.06484
'''
import torch
import torch.nn as nn
import torch.nn.function... | 4,084 | 30.666667 | 83 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/models/preact_resnet.py | '''Pre-activation ResNet in PyTorch.
Reference:
[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
Identity Mappings in Deep Residual Networks. arXiv:1603.05027
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class PreActBlock(nn.Module):
'''Pre-activation version of the BasicBlock.... | 4,078 | 33.277311 | 102 | py |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
CorgiPile-PyTorch | CorgiPile-PyTorch-main/cifar_dl_bench/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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.