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 |
|---|---|---|---|---|---|---|
CheXbert | CheXbert-master/src/label.py | import os
import argparse
import torch
import torch.nn as nn
import pandas as pd
import numpy as np
import utils
from models.bert_labeler import bert_labeler
from bert_tokenizer import tokenize
from transformers import BertTokenizer
from collections import OrderedDict
from datasets.unlabeled_dataset import UnlabeledDat... | 6,258 | 41.869863 | 100 | py |
CheXbert | CheXbert-master/src/models/bert_labeler.py | import torch
import torch.nn as nn
from transformers import BertModel, AutoModel
class bert_labeler(nn.Module):
def __init__(self, p=0.1, clinical=False, freeze_embeddings=False, pretrain_path=None):
""" Init the labeler module
@param p (float): p to use for dropout in the linear heads, 0.1 by defa... | 2,660 | 50.173077 | 116 | py |
CheXbert | CheXbert-master/src/datasets/impressions_dataset.py | import torch
import pandas as pd
import numpy as np
from bert_tokenizer import load_list
from torch.utils.data import Dataset, DataLoader
class ImpressionsDataset(Dataset):
"""The dataset to contain report impressions and their labels."""
def __init__(self, csv_path, list_path):
... | 2,345 | 47.875 | 104 | py |
CheXbert | CheXbert-master/src/datasets/unlabeled_dataset.py | import torch
import pandas as pd
import numpy as np
from transformers import BertTokenizer
import bert_tokenizer
from torch.utils.data import Dataset, DataLoader
class UnlabeledDataset(Dataset):
"""The dataset to contain report impressions without any labels."""
def __init__(self, csv_path):
... | 1,806 | 43.073171 | 97 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/setup.py | #!/usr/bin/env python3
from setuptools import find_packages, setup
try: # for pip >= 10
from pip._internal.req import parse_requirements
from pip._internal.download import PipSession
except ImportError: # for pip <= 9.0.3
from pip.req import parse_requirements
from pip.download import PipSession
li... | 821 | 31.88 | 76 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/train.py | import copy
import json
import logging
import os
import pickle
import random
import statistics
import sys
import time
import numpy as np
import torch
import yaml
from inclearn.lib import factory
from inclearn.lib import logger as logger_lib
from inclearn.lib import metrics, results_utils, utils
logger = logging.getL... | 11,428 | 33.633333 | 100 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/convnet/ucir_resnet.py | import torch.nn as nn
def conv3x3(in_planes, out_planes, stride=1):
"""3x3 convolution with padding"""
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
padding=1, bias=False)
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, inplanes, planes, st... | 3,464 | 29.394737 | 87 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/convnet/my_resnet2.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from inclearn.lib import pooling
class DownsampleStride(nn.Module):
def __init__(self, n=2):
super(DownsampleStride, self).__init__()
self._n = n
def forward(self, x):
x = x[..., ::2, ::2]
return torch.cat((x... | 6,532 | 28.035556 | 92 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/convnet/my_resnet_mtl.py | """Pytorch port of the resnet used for CIFAR100 by iCaRL.
https://github.com/srebuffi/iCaRL/blob/master/iCaRL-TheanoLasagne/utils_cifar100.py
"""
import logging
import torch
import torch.nn as nn
import torch.nn.functional as F
from inclearn.convnet.tools.conv_mtl import Conv2dMtl
from inclearn.lib import pooling
fro... | 10,928 | 29.190608 | 97 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/convnet/resnet.py | """Taken & slightly modified from:
* https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py
"""
import torch.nn as nn
import torch.utils.model_zoo as model_zoo
from torch.nn import functional as F
__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152']
model_urls = {
... | 8,824 | 30.294326 | 106 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/convnet/vgg.py | import torch
import torch.nn as nn
import torch.utils.model_zoo as model_zoo
__all__ = [
'VGG',
'vgg11',
'vgg11_bn',
'vgg13',
'vgg13_bn',
'vgg16',
'vgg16_bn',
'vgg19_bn',
'vgg19',
]
model_urls = {
'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
'vgg13': '... | 7,286 | 36.953125 | 113 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/convnet/densenet.py | import re
from collections import OrderedDict
import torch
import torch.nn as nn
import torch.nn.functional as F
__all__ = ['DenseNet', 'densenet121', 'densenet169', 'densenet201', 'densenet161']
model_urls = {
'densenet121': 'https://download.pytorch.org/models/densenet121-a639ec97.pth',
'densenet169': 'htt... | 7,713 | 41.384615 | 95 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/convnet/resnet_mtl.py | """Taken & slightly modified from:
* https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py
"""
import logging
import torch.nn as nn
import torch.utils.model_zoo as model_zoo
from inclearn.convnet.tools.conv_mtl import Conv2dMtl
from torch.nn import functional as F
logger = logging.getLogger(__nam... | 9,970 | 30.85623 | 106 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/convnet/my_resnet_brn.py | ''' Incremental-Classifier Learning
Authors : Khurram Javed, Muhammad Talha Paracha
Maintainer : Khurram Javed
Lab : TUKL-SEECS R&D Lab
Email : 14besekjaved@seecs.edu.pk '''
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init
from inclearn.lib import pooling
... | 9,785 | 29.58125 | 97 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/convnet/cifar_resnet.py | ''' Incremental-Classifier Learning
Authors : Khurram Javed, Muhammad Talha Paracha
Maintainer : Khurram Javed
Lab : TUKL-SEECS R&D Lab
Email : 14besekjaved@seecs.edu.pk '''
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init
class DownsampleA(nn.Module):
... | 5,946 | 29.035354 | 102 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/convnet/my_resnet.py | """Pytorch port of the resnet used for CIFAR100 by iCaRL.
https://github.com/srebuffi/iCaRL/blob/master/iCaRL-TheanoLasagne/utils_cifar100.py
"""
import logging
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init
from inclearn.lib import pooling
logger = logging.getLogger(__... | 9,282 | 28.469841 | 97 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/convnet/my_resnet_mcbn.py | """Pytorch port of the resnet used for CIFAR100 by iCaRL.
https://github.com/srebuffi/iCaRL/blob/master/iCaRL-TheanoLasagne/utils_cifar100.py
"""
import logging
import random
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init
from inclearn.lib import pooling
logger = loggin... | 11,898 | 28.972292 | 98 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/convnet/my_resnet_imagenet.py | """Pytorch port of the resnet used for CIFAR100 by iCaRL.
https://github.com/srebuffi/iCaRL/blob/master/iCaRL-TheanoLasagne/utils_cifar100.py
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init
from inclearn.lib import pooling
class DownsampleStride(nn.Module):
def ... | 7,242 | 27.972 | 97 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/convnet/tools/conv_mtl.py | ##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
## Created by: Yaoyao Liu
## Modified from: https://github.com/pytorch/pytorch
## Tianjin University
## liuyaoyao@tju.edu.cn
## Copyright (c) 2019
##
## This source code is licensed under the MIT-style license found in the
## LICENSE file in th... | 4,162 | 33.122951 | 99 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/e2e.py | import numpy as np
import torch
import tqdm
from torch.nn import functional as F
from inclearn.lib import factory, herding, network, utils
from inclearn.models.base import IncrementalLearner
tqdm.monitor_interval = 0
class End2End(IncrementalLearner):
"""Implementation of End-to-End Increment Learning.
:pa... | 12,536 | 33.728532 | 102 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/base.py | import abc
import logging
import os
import torch
LOGGER = logging.Logger("IncLearn", level="INFO")
logger = logging.getLogger(__name__)
class IncrementalLearner(abc.ABC):
"""Base incremental learner.
Methods are called in this order (& repeated for each new task):
1. set_task_info
2. before_task
... | 3,228 | 24.832 | 77 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/medic.py | import numpy as np
import torch
import tqdm
from torch import nn
from torch.nn import functional as F
from inclearn import factory, utils
from inclearn.lib import callbacks, network
from inclearn.models.base import IncrementalLearner
tqdm.monitor_interval = 0
class Medic(IncrementalLearner):
"""Implementation o... | 9,474 | 30.478405 | 89 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/lwm.py | import logging
import pdb
import numpy as np
import torch
from torch.nn import functional as F
from inclearn.lib import factory, loops, losses, network, utils
from inclearn.models import IncrementalLearner
EPSILON = 1e-8
logger = logging.getLogger(__name__)
class LwM(IncrementalLearner):
def __init__(self, a... | 6,593 | 32.815385 | 100 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/zil.py | import collections
import copy
import functools
import logging
import math
import os
import pickle
import numpy as np
import torch
from sklearn import preprocessing as skpreprocessing
from sklearn.svm import SVC
from sklearn.utils.class_weight import compute_class_weight
from torch import nn
from torch.nn import funct... | 89,099 | 41.12766 | 119 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/oracle.py | import logging
import numpy as np
import torch
from torch.nn import functional as F
from inclearn.lib import factory, loops, network, utils
from inclearn.models import IncrementalLearner
logger = logging.getLogger(__name__)
class Oracle(IncrementalLearner):
def __init__(self, args):
self._device = arg... | 3,863 | 30.414634 | 98 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/lwf.py | import logging
import numpy as np
import torch
from torch.nn import functional as F
from inclearn.lib import factory, loops, network, utils
from inclearn.models import IncrementalLearner
logger = logging.getLogger(__name__)
class LwF(IncrementalLearner):
"""Multi-class implementation of:
* Learning withou... | 5,198 | 31.698113 | 100 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/fixedrepresentation.py | import logging
import numpy as np
import torch
from torch.nn import functional as F
from inclearn.lib import factory, loops, network, utils
from inclearn.models import IncrementalLearner
logger = logging.getLogger(__name__)
class FixedRepresentation(IncrementalLearner):
def __init__(self, args):
self.... | 3,713 | 30.474576 | 98 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/ucir.py | import logging
import math
import warnings
import numpy as np
import torch
from torch.nn import functional as F
from inclearn.lib import factory, losses, network, utils
from inclearn.models.icarl import ICarl
logger = logging.getLogger(__name__)
class UCIR(ICarl):
"""Implements Learning a Unified Classifier In... | 8,801 | 35.675 | 143 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/podnet.py | import copy
import logging
import math
import numpy as np
import torch
from torch.nn import functional as F
from inclearn.lib import data, factory, losses, network, utils
from inclearn.lib.data import samplers
from inclearn.models.icarl import ICarl
logger = logging.getLogger(__name__)
class PODNet(ICarl):
"""... | 17,076 | 37.289238 | 100 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/gdumb.py | import logging
import math
import numpy as np
import torch
from torch.nn import functional as F
from inclearn.lib import data, factory, losses, network, utils
from inclearn.models.icarl import ICarl
logger = logging.getLogger(__name__)
class GDumb(ICarl):
"""
# Reference:
* GDumb: A Simple Approac... | 7,608 | 31.241525 | 100 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/ull.py | import copy
import functools
import logging
import math
import numpy as np
import torch
from torch import nn
from torch.nn import functional as F
from inclearn.lib import data, distance, factory, loops, losses, network, utils
from inclearn.lib.data import samplers
from inclearn.lib.network.word import Word2vec
from i... | 8,230 | 32.189516 | 113 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/bic.py | import logging
import os
import pickle
import numpy as np
import torch
from torch.nn import functional as F
from inclearn.lib import calibration, herding, losses, utils
from inclearn.models.icarl import ICarl
EPSILON = 1e-8
logger = logging.getLogger(__name__)
class BiC(ICarl):
"""Implements Large Scale Incre... | 4,503 | 31.171429 | 153 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/models/icarl.py | import collections
import copy
import logging
import os
import pickle
import numpy as np
import torch
from scipy.spatial.distance import cdist
from torch import nn
from torch.nn import functional as F
from tqdm import tqdm
from inclearn.lib import factory, herding, losses, network, schedulers, utils
from inclearn.lib... | 19,231 | 37.007905 | 121 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/pooling.py | import torch
import torch.nn as nn
from torch.autograd import Function
class WeldonPool2d(nn.Module):
def __init__(self, kmax=1, kmin=None, **kwargs):
super(WeldonPool2d, self).__init__()
self.kmax = kmax
self.kmin = kmin
if self.kmin is None:
self.kmin = self.kmax
... | 4,029 | 37.75 | 153 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/callbacks.py | import copy
import torch
class Callback:
def __init__(self):
self._iteration = 0
self._in_training = True
@property
def in_training(self):
return self._in_training
def on_epoch_begin(self):
pass
def on_epoch_end(self, metric=None):
self._iteration += 1
... | 2,331 | 25.5 | 86 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/schedulers.py | import warnings
import numpy as np
from torch.optim.lr_scheduler import ReduceLROnPlateau, _LRScheduler
class GradualWarmupScheduler(_LRScheduler):
""" Gradually warm-up(increasing) learning rate in optimizer.
Proposed in 'Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour'.
From: https://github... | 5,695 | 36.228758 | 98 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/utils.py | import datetime
import logging
import os
import warnings
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import torch
from sklearn import manifold
from sklearn.cluster import KMeans
from sklearn.neighbors import KNeighborsClassifier
logger = logging.getLogger(__name__)
def to_onehot(targ... | 7,556 | 30.098765 | 100 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/calibration.py | import torch
from torch import optim
from torch.nn import functional as F
from inclearn.lib.network import (CalibrationWrapper, LinearModel, TemperatureScaling)
def calibrate(network, loader, device, indexes, calibration_type="linear"):
"""Corrects the bias for new classes.
:param network: The logits extrac... | 2,171 | 33.47619 | 86 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/vizualization.py | import torch
def grad_cam(spatial_features, selected_logits):
batch_size = spatial_features.shape[0]
assert batch_size == len(selected_logits)
formated_logits = [selected_logits[i] for i in range(batch_size)]
import pdb
pdb.set_trace()
grads = torch.autograd.grad(
formated_logits, sp... | 447 | 22.578947 | 79 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/factory.py | import warnings
import torch
from torch import optim
from inclearn import models
from inclearn.convnet import (
densenet, my_resnet, my_resnet2, my_resnet_brn, my_resnet_mcbn, my_resnet_mtl, resnet,
resnet_mtl, ucir_resnet, vgg
)
from inclearn.lib import data, schedulers
def get_optimizer(params, optimizer,... | 6,406 | 33.446237 | 97 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/metrics.py | import collections
import numpy as np
import torch
class MetricLogger:
def __init__(self, nb_tasks, nb_classes, increments):
self.metrics = collections.defaultdict(list)
self.nb_tasks = nb_tasks
self.nb_classes = nb_classes
self.increments = increments
self._accuracy_ma... | 8,079 | 33.382979 | 99 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/distance.py | import torch
from torch.nn import functional as F
def squared_euclidian_distance(a, b):
return torch.cdist(a, b)**2
def cosine_similarity(a, b):
return torch.mm(F.normalize(a, p=2, dim=-1), F.normalize(b, p=2, dim=-1).T)
def stable_cosine_distance(a, b, squared=True):
"""Computes the pairwise distance... | 1,492 | 34.547619 | 99 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/herding.py | import numpy as np
import torch
from sklearn.cluster import KMeans
from torch.nn import functional as F
from inclearn.lib import utils
def closest_to_mean(features, nb_examplars):
features = features / (np.linalg.norm(features, axis=0) + 1e-8)
class_mean = np.mean(features, axis=0)
return _l2_distance(f... | 6,268 | 29.881773 | 98 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/loops/generators.py | import collections
import itertools
import logging
import numpy as np
import torch
from torch import nn
from torch.nn import functional as F
from tqdm import tqdm
from .loops import _print_metrics
logger = logging.getLogger(__name__)
def perclass_loop(
inc_dataset,
class_ids,
devices,
n_epochs,
... | 15,274 | 30.690871 | 99 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/loops/loops.py | import collections
import logging
import torch
from torch import nn
from inclearn.lib.network import hook
from tqdm import tqdm
logger = logging.getLogger(__name__)
def single_loop(
train_loader,
val_loader,
devices,
network,
n_epochs,
optimizer,
train_function,
eval_function,
t... | 3,951 | 29.4 | 95 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/network/postprocessors.py | import torch
from torch import nn
class ConstantScalar(nn.Module):
def __init__(self, constant=1., bias=0., **kwargs):
super().__init__()
self.factor = constant
self.bias = bias
def on_task_end(self):
pass
def on_epoch_end(self):
pass
def forward(self, x):
... | 2,436 | 21.357798 | 98 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/network/hook.py | import torch
import torch.nn as nn
def get_gradcam_hook(model):
if isinstance(model, nn.DataParallel):
gradients = [None for _ in model.device_ids]
activations = [None for _ in model.device_ids]
def backward_hook(module, grad_input, grad_output):
gradients[model.device_ids.ind... | 913 | 29.466667 | 91 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/network/memory.py | import torch
from torch import nn
from torch.nn import functional as F
class MemoryBank:
def __init__(self, device, momentum=0.5):
self.features = None
self.targets = None
self.momentum = momentum
self.device = device
def add(self, features, targets):
if self.featur... | 1,146 | 29.184211 | 87 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/network/calibrators.py | import torch
from torch import nn
class CalibrationWrapper(nn.Module):
"""Wraps several calibration models, each being applied on different targets."""
def __init__(self):
super().__init__()
self.start_indexes = []
self.end_indexes = []
self.models = nn.ModuleList([])
de... | 2,150 | 27.68 | 100 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/network/mlp.py | from torch import nn
class MLP(nn.Module):
def __init__(self, input_dim, hidden_dims, use_bn=True, input_dropout=0., hidden_dropout=0.):
super().__init__()
layers = []
for index, dim in enumerate(hidden_dims[:-1]):
layers.append(nn.Linear(input_dim, dim, bias=True))
... | 1,129 | 32.235294 | 97 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/network/autoencoder.py | import logging
import torch
from torch import nn
from .mlp import MLP
from .word import get_embeddings
logger = logging.getLogger(__name__)
class AdvAutoEncoder(nn.Module):
def __init__(
self,
dataset,
embeddings=None,
encoder_config=None,
decoder_config=None,
d... | 2,431 | 28.658537 | 79 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/network/classifiers.py | import copy
import logging
import numpy as np
import torch
from sklearn.cluster import KMeans
from torch import nn
from torch.nn import functional as F
from inclearn.lib import distance as distance_lib
from inclearn.lib import utils
from .postprocessors import FactorScalar, HeatedUpScalar
logger = logging.getLogger... | 23,762 | 35.671296 | 100 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/network/word.py | import logging
import os
import pickle
import numpy as np
import torch
from scipy.io import loadmat
from torch import nn
from torch.nn import functional as F
import gensim
from inclearn.lib.data import fetch_word_embeddings
from .mlp import MLP
logger = logging.getLogger(__name__)
class Word2vec(nn.Module):
... | 9,761 | 32.662069 | 110 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/network/basenet.py | import copy
import logging
import torch
from torch import nn
from inclearn.lib import factory
from .classifiers import (Classifier, CosineClassifier, DomainClassifier, MCCosineClassifier)
from .postprocessors import FactorScalar, HeatedUpScalar, InvertedFactorScalar
from .word import Word2vec
logger = logging.getLo... | 9,766 | 35.580524 | 99 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/data/datasets.py | import collections
import glob
import logging
import math
import os
import warnings
import numpy as np
from torchvision import datasets, transforms
logger = logging.getLogger(__name__)
class DataHandler:
base_dataset = None
train_transforms = []
test_transforms = []
common_transforms = [transforms.T... | 18,153 | 31.82821 | 100 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/data/incdataset.py | import logging
import random
import numpy as np
import torch
from PIL import Image
from torch.utils.data import DataLoader
from torchvision import transforms
from .datasets import (
APY, CUB200, LAD, AwA2, ImageNet100, ImageNet100UCIR, ImageNet1000, TinyImageNet200, iCIFAR10,
iCIFAR100
)
logger = logging.get... | 17,267 | 36.457701 | 101 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/data/samplers.py | import numpy as np
from torch.utils.data.sampler import BatchSampler
class MemoryOverSampler(BatchSampler):
def __init__(self, y, memory_flags, batch_size=128, **kwargs):
self.indexes = self._oversample(y, memory_flags)
self.batch_size = batch_size
def __len__(self):
return len(self.... | 6,690 | 31.014354 | 97 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/losses/base.py | import numpy as np
import torch
from torch import nn
from torch.nn import functional as F
def binarize_and_smooth_labels(T, nb_classes, smoothing_const=0.1):
import sklearn.preprocessing
T = T.cpu().numpy()
T = sklearn.preprocessing.label_binarize(T, classes=range(0, nb_classes))
T = T * (1 - smoothin... | 4,732 | 33.547445 | 94 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/losses/unsupervised.py | import torch
from torch.nn import functional as F
def unsupervised_rotations(inputs, memory_flags, network, apply_on="all", factor=1.0, **kwargs):
"""Rotates inputs by 90° four times, and predict the angles.
References:
* Spyros Gidaris, Praveer Singh, Nikos Komodakis
Unsupervised Represent... | 1,553 | 34.318182 | 96 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/losses/metrics.py | import itertools
import numpy as np
import torch
from torch.nn import functional as F
def triplet_loss(
features,
targets,
squaredl2=False,
triplet_selection="all",
margin=0.2,
factor=1.,
normalize=False,
aggreg="mean",
harmonic_embeddings=None,
old_features=None,
memory_f... | 13,211 | 34.045093 | 102 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/losses/distillation.py | import functools
import math
import torch
from torch.nn import functional as F
from inclearn.lib import vizualization
def mer_loss(new_logits, old_logits):
"""Distillation loss that is less important if the new model is unconfident.
Reference:
* Kim et al.
Incremental Learning with Maximu... | 12,606 | 31.660622 | 97 | py |
incremental_learning.pytorch | incremental_learning.pytorch-master/inclearn/lib/losses/regularizations.py | import functools
import numpy as np
import torch
from torch.nn import functional as F
from inclearn.lib import utils
def weights_orthogonality(weights, margin=0.):
"""Regularization forcing the weights to be disimilar.
:param weights: Learned parameters of shape (n_classes, n_features).
:param margin: ... | 13,746 | 33.027228 | 99 | py |
BayesianPolicyGradients | BayesianPolicyGradients-master/baselines/common/tf_util.py | import numpy as np
import tensorflow as tf # pylint: ignore-module
import builtins
import functools
import copy
import os
import collections
from tensorflow.python.util import tf_contextlib
from tensorflow.python.framework import tensor_shape
from tensorflow.python.framework.tensor_util import constant_value
import nu... | 31,374 | 33.668508 | 120 | py |
SpfNet | SpfNet-main/SpfNet_torch/spfv.py | import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torch.utils.data as data
import glob
import os
import math
import time
import scipy
import scipy.io as sio
import tensorly as tl
from SpfNet_torch.fusion import FusionNet, check_dir
from SpfNet_torch.utils import AverageMeter, tool... | 21,018 | 42.338144 | 121 | py |
SpfNet | SpfNet-main/SpfNet_torch/utils.py | # Author: JianJun Liu
# Date: 2021/12/27
import numpy as np
import scipy.io as sio
import scipy.sparse as sp
import os
import torch
import torch.nn.functional as fun
import torch.utils.data as data
def to_pair(t):
return t if isinstance(t, tuple) else (t, t)
class AverageMeter(object):
"""Computes and store... | 16,988 | 37.87643 | 118 | py |
gammaALPs | gammaALPs-master/docs/conf.py | # Configuration file for the Sphinx documentation builder.
#
# This file only contains a selection of the most common options. For a full
# list see the documentation:
# https://www.sphinx-doc.org/en/master/usage/configuration.html
# -- Path setup --------------------------------------------------------------
# If ex... | 3,522 | 33.203883 | 79 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/test.py | import torch
import subjectlist as subl
import os
import argparse
import torchsrc
def mkdir(path):
if not os.path.exists(path):
os.makedirs(path)
def print_network(net):
num_params = 0
for param in net.parameters():
num_params += param.numel()
print(net)
print('Total number of parameters: %d' % num_... | 6,003 | 31.808743 | 120 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/trainer.py | import datetime
import math
import os
import os.path as osp
import shutil
#import fcn
import numpy as np
import pytz
import scipy.misc
import scipy.io as sio
import nibabel as nib
from scipy.spatial import distance
import torch
from torch.autograd import Variable
import torch.nn.functional as F
import tqdm
import skim... | 21,628 | 36.879159 | 170 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/imgloaders/__init__.py | from .imgloader_CT_3D import pytorch_loader
from .imgloader_CT_3D_allpiece import pytorch_loader_allpiece | 105 | 52 | 61 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/imgloaders/imgloader_CT_3D.py | import os
import numpy as np
from torch.utils import data
import nibabel as nib
nRows = 172
nCols = 220
nSlices = 156
output_x = 96
output_y = 128
output_z = 88
# labels = [0, 45]
labels = [0, 4,11,23,30,31,32,35,36,37,38,39,40,41,44,45,47,48,49,50,51,52,55,56,57,58,59,60,61,62,71,72,73,75,76,100,101,102,103,104,10... | 2,342 | 35.609375 | 506 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/imgloaders/imgloader_CT_3D_allpiece.py | import os
import numpy as np
from torch.utils import data
import nibabel as nib
nRows = 172
nCols = 220
nSlices = 156
output_x = 96
output_y = 128
output_z = 88
# labels = [0, 45]
labels = [0, 4,11,23,30,31,32,35,36,37,38,39,40,41,44,45,47,48,49,50,51,52,55,56,57,58,59,60,61,62,71,72,73,75,76,100,101,102,103,104,10... | 2,609 | 36.826087 | 506 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/base_model.py | import os
import torch
class BaseModel():
def name(self):
return 'BaseModel'
def initialize(self, opt):
self.opt = opt
self.gpu_ids = opt.gpu_ids
self.isTrain = opt.isTrain
self.Tensor = torch.cuda.FloatTensor if self.gpu_ids else torch.Tensor
self.save_dir = o... | 1,572 | 26.596491 | 78 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/ResNet.py | import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
from torch.nn.parameter import Parameter
import torch.nn.functional as F
#from pairwise import Pairwise
model_urls = {
'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
'resnet34': 'https://download.pytorch.org/m... | 8,805 | 36.956897 | 88 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/DeconvNet.py | import numpy as np
import torch
import torch.nn as nn
#This is based on Zhoubing's simple net
class ConvBlock(nn.Module):
def __init__(self, in_size, out_size, kernel_size=3):
super(ConvBlock, self).__init__()
self.conv = nn.Sequential(
nn.Conv2d(in_size, out_size, kernel_size, paddin... | 3,700 | 36.01 | 69 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/MTL_BN.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py
def get_upsample_filter(size):
"""Make a 2D bilinear kernel suitable for upsampling"""
factor = (size + 1) // 2
if size % 2 == 1:
cente... | 13,976 | 37.188525 | 114 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/Unet3D.py | import torch
import torch.nn as nn
class UNet3D(nn.Module):
def __init__(self, in_channel, n_classes):
self.in_channel = in_channel
self.n_classes = n_classes
super(UNet3D, self).__init__()
self.ec0 = self.encoder(self.in_channel, 32, bias=True, batchnorm=True)
self.ec1 = se... | 4,227 | 38.514019 | 109 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/Unet.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py
def get_upsample_filter(size):
"""Make a 2D bilinear kernel suitable for upsampling"""
factor = (size + 1) // 2
if size % 2 == 1:
center... | 13,781 | 40.637462 | 100 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/fcn32s.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py
def get_upsample_filter(size):
"""Make a 2D bilinear kernel suitable for upsampling"""
factor = (size + 1) // 2
if size % 2 == 1:
center... | 12,345 | 39.346405 | 100 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/fcn32s_BN.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py
def get_upsample_filter(size):
"""Make a 2D bilinear kernel suitable for upsampling"""
factor = (size + 1) // 2
if size % 2 == 1:
center... | 9,797 | 34.759124 | 100 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/Unet_online.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# from https://discuss.pytorch.org/t/unet-implementation/426
class UNetConvBlock(nn.Module):
def __init__(self, in_size, out_size, kernel_size=3, activation=F.relu):
super(UNetConvBlock, self).__init__()
self.conv... | 3,072 | 31.691489 | 97 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/ClssNet_svm.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
# https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py
def get_upsample_filter(size):
"""Make a 2D bilinear kernel suitable for upsampling"""
factor = (size + 1) ... | 10,471 | 34.378378 | 97 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/vgg.py | import torch
import torchvision
def VGG16(pretrained=False):
model = torchvision.models.vgg16(pretrained=False)
if not pretrained:
return model
model_url = 'https://s3-us-west-2.amazonaws.com/jcjohns-models/vgg16-00b39a1b.pth' # NOQA
state_dict = torch.utils.model_zoo.load_url(model_url)
... | 698 | 37.833333 | 94 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/pix2pix_model.py | import numpy as np
import torch
import os
from collections import OrderedDict
from torch.autograd import Variable
import torchsrc.utils as util
from torchsrc.utils.image_pool import ImagePool
from .base_model import BaseModel
from . import networks
class Pix2PixModel(BaseModel):
def name(self):
return 'Pi... | 6,442 | 36.028736 | 100 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/networks.py | import torch
import torch.nn as nn
from torch.nn import init
import functools
from torch.autograd import Variable
import numpy as np
###############################################################################
# Functions
###############################################################################
def weights_i... | 13,139 | 37.87574 | 133 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/fc_densenet.py | import torch
from torch import nn
__all__ = ['FCDenseNet', 'fcdensenet_tiny', 'fcdensenet56_nodrop',
'fcdensenet56', 'fcdensenet67', 'fcdensenet103',
'fcdensenet103_nodrop']
class DenseBlock(nn.Module):
def __init__(self, nIn, growth_rate, depth, drop_rate=0, only_new=False,
... | 6,587 | 36.645714 | 79 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/MTL_ResNet.py | import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
from torch.nn.parameter import Parameter
import torch.nn.functional as F
#from pairwise import Pairwise
model_urls = {
'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
'resnet34': 'https://download.pytorch.org/m... | 15,557 | 40.59893 | 88 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/ResNetClss_svm.py | import torch.nn as nn
import math
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
from torch.nn.parameter import Parameter
__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
'resnet152']
model_urls = {
'resnet18': 'https://download.pytorch.org/models/resnet... | 8,540 | 32.363281 | 79 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/MTL_GCN.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.init as init
import torch.utils.model_zoo as model_zoo
from torchvision import models
import math
class GCN(nn.Module):
def __init__(self, inplanes, planes, ks=7):
super(GCN, self).__init__()
self.conv_l1 = nn.Conv... | 14,816 | 41.577586 | 95 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/ResNetClss.py | import torch.nn as nn
import math
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
from torch.nn.parameter import Parameter
__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
'resnet152']
model_urls = {
'resnet18': 'https://download.pytorch.org/models/resnet... | 8,485 | 32.148438 | 79 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/ResUnet.py | import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
from torch.nn.parameter import Parameter
import torch.nn.functional as F
#from pairwise import Pairwise
model_urls = {
'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
'resnet34': 'https://download.pytorch.org/m... | 8,834 | 37.081897 | 88 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/Unet3D_origin.py | import torch
import torch.nn as nn
class UNet3D(nn.Module):
def __init__(self, in_channel, n_classes):
self.in_channel = in_channel
self.n_classes = n_classes
super(UNet3D, self).__init__()
self.ec0 = self.encoder(self.in_channel, 32, bias=True, batchnorm=True)
self.ec1 = se... | 3,822 | 36.851485 | 109 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/gcn.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.init as init
import torch.utils.model_zoo as model_zoo
from torchvision import models
import math
class GCN(nn.Module):
def __init__(self, inplanes, planes, ks=7):
super(GCN, self).__init__()
self.conv_l1 = nn.Conv... | 4,399 | 30.654676 | 79 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/ClssNet.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py
def get_upsample_filter(size):
"""Make a 2D bilinear kernel suitable for upsampling"""
factor = (size + 1) // 2
if size % 2 == 1:
center... | 11,700 | 39.071918 | 100 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/vnet.py | import torch
import torch.nn as nn
import torch.nn.functional as F
def passthrough(x, **kwargs):
return x
def ELUCons(elu, nchan):
if elu:
return nn.ELU(inplace=True)
else:
return nn.PReLU(nchan)
# normalization between sub-volumes is necessary
# for good performance
class ContBatchNorm3... | 6,297 | 33.79558 | 90 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/Unet_BN.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# from https://discuss.pytorch.org/t/unet-implementation/426
class UNetConvBlock(nn.Module):
def __init__(self, in_size, out_size, kernel_size=3, activation=F.relu):
super(UNetConvBlock, self).__init__()
self.conv... | 3,987 | 33.08547 | 97 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/models/VggResClssNet.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
class VggResClssNet(nn.Module):
def __init__(self, n_class=21):
super(VggResClssNet, self).__init__()
self.resdown = nn.Sequential(
nn.Linear(8192, 1024),
# nn.ReLU(inplace=True),
... | 1,333 | 20.516129 | 45 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/utils/image_pool.py | import random
import numpy as np
import torch
from pdb import set_trace as st
from torch.autograd import Variable
class ImagePool():
def __init__(self, pool_size):
self.pool_size = pool_size
if self.pool_size > 0:
self.num_imgs = 0
self.images = []
def query(self, images... | 1,141 | 32.588235 | 67 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/utils/util.py | from __future__ import print_function
import torch
import numpy as np
from PIL import Image
import inspect, re
import numpy as np
import os
import collections
# Converts a Tensor into a Numpy array
# |imtype|: the desired type of the converted numpy array
def tensor2im(image_tensor, imtype=np.uint8):
image_numpy =... | 2,177 | 29.25 | 97 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/ext/fcn.berkeleyvision.org/score.py | from __future__ import division
import caffe
import numpy as np
import os
import sys
from datetime import datetime
from PIL import Image
def fast_hist(a, b, n):
k = (a >= 0) & (a < n)
return np.bincount(n * a[k].astype(int) + b[k], minlength=n**2).reshape(n, n)
def compute_hist(net, save_dir, dataset, layer='... | 2,198 | 37.578947 | 95 | py |
SLANTbrainSeg | SLANTbrainSeg-master/matlab/torchsrc/ext/fcn.berkeleyvision.org/nyud_layers.py | import caffe
import numpy as np
from PIL import Image
import scipy.io
import random
class NYUDSegDataLayer(caffe.Layer):
"""
Load (input image, label image) pairs from NYUDv2
one-at-a-time while reshaping the net to preserve dimensions.
The labels follow the 40 class task defined by
S. Gupt... | 5,256 | 32.484076 | 122 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.