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 |
|---|---|---|---|---|---|---|
multitask_impute | multitask_impute-master/OmiEmbed/models/basic_model.py | import os
import torch
import numpy as np
from abc import ABC, abstractmethod
from . import networks
from collections import OrderedDict
class BasicModel(ABC):
"""
This class is an abstract base class for models.
To create a subclass, you need to implement the following five functions:
-- <__init_... | 13,669 | 38.508671 | 166 | py |
multitask_impute | multitask_impute-master/OmiEmbed/models/vae_classifier_model.py | import torch
from .vae_basic_model import VaeBasicModel
from . import networks
from . import losses
from torch.nn import functional as F
class VaeClassifierModel(VaeBasicModel):
"""
This class implements the VAE classifier model, using the VAE framework with the classification downstream task.
"""
@s... | 3,463 | 35.851064 | 151 | py |
multitask_impute | multitask_impute-master/OmiEmbed/models/vae_multitask_model.py | import torch
from .vae_basic_model import VaeBasicModel
from . import networks
from . import losses
from torch.nn import functional as F
from sklearn import metrics
class VaeMultitaskModel(VaeBasicModel):
"""
This class implements the VAE multitasking model, using the VAE framework with the multiple downstrea... | 8,142 | 44.238889 | 269 | py |
multitask_impute | multitask_impute-master/OmiEmbed/models/vae_basic_model.py | import torch
from .basic_model import BasicModel
from . import networks
from . import losses
class VaeBasicModel(BasicModel):
"""
This is the basic VAE model class, called by all other VAE son classes.
"""
def __init__(self, param):
"""
Initialize the VAE basic class.
"""
... | 6,461 | 42.959184 | 153 | py |
multitask_impute | multitask_impute-master/OmiEmbed/models/vae_multitask_gn_model.py | import torch
import torch.nn as nn
from .basic_model import BasicModel
from . import networks
from . import losses
from torch.nn import functional as F
from sklearn import metrics
class VaeMultitaskGNModel(BasicModel):
"""
This class implements the VAE multitasking model with GradNorm, using the VAE framework... | 15,071 | 45.091743 | 269 | py |
multitask_impute | multitask_impute-master/OmiEmbed/util/visualizer.py | import os
import time
import numpy as np
import pandas as pd
import sklearn as sk
from sklearn.preprocessing import label_binarize
from util import util
from util import metrics
from torch.utils.tensorboard import SummaryWriter
class Visualizer:
"""
This class print/save logging information
"""
def _... | 27,478 | 49.981447 | 370 | py |
multitask_impute | multitask_impute-master/OmiEmbed/util/util.py | """
Contain some simple helper functions
"""
import os
import shutil
import torch
import random
import numpy as np
def mkdir(path):
"""
Create a empty directory in the disk if it didn't exist
Parameters:
path(str) -- a directory path we would like to create
"""
if not os.path.exists(path)... | 1,204 | 20.517857 | 82 | py |
multitask_impute | multitask_impute-master/OmiEmbed/params/basic_params.py | import time
import argparse
import torch
import os
import models
from util import util
class BasicParams:
"""
This class define the console parameters
"""
def __init__(self):
"""
Reset the class. Indicates the class hasn't been initialized
"""
self.initialized = False
... | 11,224 | 52.452381 | 224 | py |
multitask_impute | multitask_impute-master/OmiEmbed/datasets/a_dataset.py | import os.path
from datasets import load_file
from datasets import get_survival_y_true
from datasets.basic_dataset import BasicDataset
import numpy as np
import pandas as pd
import torch
class ADataset(BasicDataset):
"""
A dataset class for gene expression dataset.
File should be prepared as '/path/to/dat... | 10,137 | 50.461929 | 184 | py |
multitask_impute | multitask_impute-master/OmiEmbed/datasets/abc_dataset.py | import os.path
from datasets import load_file
from datasets import get_survival_y_true
from datasets.basic_dataset import BasicDataset
from util import preprocess
import numpy as np
import pandas as pd
import torch
class ABCDataset(BasicDataset):
"""
A dataset class for multi-omics dataset.
For gene expre... | 13,033 | 48.748092 | 152 | py |
multitask_impute | multitask_impute-master/OmiEmbed/datasets/basic_dataset.py | """
This module implements an abstract base class for datasets. Other datasets can be created from this base class.
"""
import torch.utils.data as data
from abc import ABC, abstractmethod
class BasicDataset(data.Dataset, ABC):
"""
This class is an abstract base class for datasets.
To create a subclass, yo... | 1,272 | 31.641026 | 116 | py |
multitask_impute | multitask_impute-master/OmiEmbed/datasets/ab_dataset.py | import os.path
from datasets import load_file
from datasets import get_survival_y_true
from datasets.basic_dataset import BasicDataset
from util import preprocess
import numpy as np
import pandas as pd
import torch
class ABDataset(BasicDataset):
"""
A dataset class for multi-omics dataset.
For gene expres... | 12,076 | 49.112033 | 152 | py |
multitask_impute | multitask_impute-master/OmiEmbed/datasets/c_dataset.py | import os.path
from datasets import load_file
from datasets import get_survival_y_true
from datasets.basic_dataset import BasicDataset
import numpy as np
import pandas as pd
import torch
class CDataset(BasicDataset):
"""
A dataset class for miRNA expression dataset.
File should be prepared as '/path/to/da... | 10,372 | 50.098522 | 152 | py |
multitask_impute | multitask_impute-master/OmiEmbed/datasets/__init__.py | """
This package about data loading and data preprocessing
"""
import os
import torch
import importlib
import numpy as np
import pandas as pd
from util import util
from datasets.basic_dataset import BasicDataset
from datasets.dataloader_prefetch import DataLoaderPrefetch
from torch.utils.data import Subset
from sklearn... | 11,372 | 37.292929 | 177 | py |
multitask_impute | multitask_impute-master/OmiEmbed/datasets/dataloader_prefetch.py | from torch.utils.data import DataLoader
from prefetch_generator import BackgroundGenerator
class DataLoaderPrefetch(DataLoader):
def __iter__(self):
return BackgroundGenerator(super().__iter__())
| 210 | 25.375 | 54 | py |
multitask_impute | multitask_impute-master/OmiEmbed/datasets/b_dataset.py | import os.path
from datasets import load_file
from datasets import get_survival_y_true
from datasets.basic_dataset import BasicDataset
from util import preprocess
import numpy as np
import pandas as pd
import torch
class BDataset(BasicDataset):
"""
A dataset class for methylation dataset.
DNA methylation ... | 11,172 | 49.556561 | 152 | py |
CoSyn | CoSyn-main/main.py | from collections import namedtuple
import argparse
from tqdm import tqdm
from sklearn.metrics import classification_report, confusion_matrix
import time
import os
from datetime import datetime
import pickle
import gc
import copy
import torch as th
import dgl
import numpy as np
from torch.utils.data import DataLoader
i... | 12,417 | 31.087855 | 136 | py |
CoSyn | CoSyn-main/loss.py | import torch
import torch.nn.functional as F
from torch import nn
import numpy as np
def focal_loss(labels, logits, alpha, gamma):
"""Compute the focal loss between `logits` and the ground truth `labels`.
Focal loss = -alpha_t * (1-pt)^gamma * log(pt)
where pt is the probability of being classified to the ... | 3,245 | 39.575 | 105 | py |
CoSyn | CoSyn-main/dataset.py | import dgl
import pickle
import numpy as np
import os
import torch
import networkx as nx
from collections import namedtuple
TreeBatch = namedtuple('TreeBatch', ['graph', 'feats', 'label', 'del_t', 'train_mask', 'val_mask', 'test_mask', 'ids','tweet_id'])
def batcher(device):
def batcher_dev(batch):
bat... | 2,849 | 29.978261 | 147 | py |
CoSyn | CoSyn-main/initializer.py | from models.plain_model import COSYN
import torch
from geoopt.optim.radam import RiemannianAdam
def initialize_model(num_classes, device, args, socialgraph, params=None):
if not args:
data_dir = params["data-dir"]
x_size = params["x-size"]
g_size = params["g-size"]
u_size = params["... | 1,561 | 29.627451 | 108 | py |
CoSyn | CoSyn-main/models/base_model.py | import torch.nn as nn
import numpy as np
from sklearn.metrics import classification_report, confusion_matrix
class BaseModel(nn.Module):
def __init__(self):
super(BaseModel, self).__init__()
def forward(self, batch, h, c):
raise NotImplementedError
def init_metric_dict(self):
retu... | 818 | 30.5 | 105 | py |
CoSyn | CoSyn-main/models/plain_model.py | import torch
import torch.nn as nn
import dgl
import numpy as np
from sklearn.metrics import classification_report, confusion_matrix
import copy
import pickle
from dgl.nn import HGConv
import math
from models.base_model import BaseModel
from models.chst import CHST
from .hfan import HFAN
class COSYN(BaseModel):
... | 3,286 | 26.855932 | 158 | py |
CoSyn | CoSyn-main/models/chst.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl
import numpy as np
from sklearn.metrics import classification_report, confusion_matrix
import copy
import math
import itertools
from geoopt.manifolds.poincare import PoincareBall
from models.attn_layers import HyperAttn, Attention
class CHS... | 4,860 | 56.188235 | 241 | py |
CoSyn | CoSyn-main/models/hfan.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from .mobiusgru import MobiusGRU, MobiusLinear
def lorentz_activation(input_tensor):
rr = torch.norm(input_tensor, p=2, dim=2)
dd = input_tensor.permute(2,0,1) / rr
cosh_r = torch.cosh(rr)
sinh_r = torch.sinh(rr)
output_tensor = ... | 4,281 | 30.028986 | 112 | py |
CoSyn | CoSyn-main/models/mobiusgru.py | import itertools
import torch.nn
import torch.nn.functional
import math
import geoopt.manifolds.poincare.math as pmath
import geoopt
from mobius_utils import one_rnn_transform, mobius_gru_cell, mobius_gru_loop
class MobiusLinear(torch.nn.Linear):
def __init__(self, *args, hyperbolic_input=True, nonlin=None ,c=1.... | 4,438 | 30.48227 | 136 | py |
CoSyn | CoSyn-main/models/mobius_utils.py | import itertools
import torch.nn
import torch.nn.functional
import math
import geoopt.manifolds.poincare.math as pmath
import geoopt
def one_rnn_transform(W, h, U, x, b, c):
W_otimes_h = pmath.mobius_matvec(W, h, c=c)
U_otimes_x = pmath.mobius_matvec(U, x, c=c)
Wh_plus_Ux = pmath.mobius_add(W_otimes_h, U_o... | 2,905 | 28.958763 | 88 | py |
CoSyn | CoSyn-main/models/hgconv.py | """Torch modules for graph attention networks(GAT)."""
# pylint: disable= no-member, arguments-differ, invalid-name
import torch as th
from torch import nn
from .... import function as fn
from ...functional import edge_softmax
from ....base import DGLError
from ..utils import Identity
from ....utils import expand_as_p... | 14,857 | 41.942197 | 99 | py |
CoSyn | CoSyn-main/utils/node.py | import dgl
from dgl.data import DGLDataset
import torch
import os
import pandas as pd
class Node(DGLDataset):
def __init__(self,id,type):
self.id = id
self.type = type
super().__init__(name='node')
def process(self):
nodes_data = pd.read_csv('./members/'+self.type+"/"+self.id+... | 2,668 | 33.217949 | 90 | py |
CoSyn | CoSyn-main/utils/socialnode.py | import dgl
from dgl.data import DGLDataset
import torch
import os
import pandas as pd
import numpy as np
import pickle
def generateEdges(type, number, df):
path = "./"+type+"_matrix/file"+str(number)
try:
with open(path, 'rb') as f:
sub = pickle.load(f)
for user in sub:... | 3,991 | 27.514286 | 161 | py |
LDEQ_RwR | LDEQ_RwR-main/test_LDEQ_WFLW.py | import time
import argparse
import numpy as np
import torchvision.transforms as transforms
from utils.helpers import *
from utils.loss_function import *
from utils.normalize import Normalize, HeatmapsToKeypoints
from datasets.WFLW_V.helpers import *
from models.ldeq import LDEQ, weights_init
heatmaps_to_keypoints = H... | 3,960 | 37.833333 | 142 | py |
LDEQ_RwR | LDEQ_RwR-main/test_LDEQ_WFLW_V.py | import os
import time
import argparse
import numpy as np
import concurrent.futures
import cv2
import torch
import torchvision.transforms as transforms
from utils.helpers import *
from utils.loss_function import video_NME_NMJ
from utils.normalize import HeatmapsToKeypoints
from datasets.WFLW_V.helpers import *
from mo... | 17,646 | 49.70977 | 245 | py |
LDEQ_RwR | LDEQ_RwR-main/models/ldeq.py | import copy
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchinfo
from utils.solvers import root_solver
from utils.normalize import *
def make_cell(args):
return eval(args.cell_name)(args)
def weights_init(m):
if isinstance(m, nn.Conv2d):
torch.nn.init.xavier_normal(m.w... | 14,971 | 44.369697 | 272 | py |
LDEQ_RwR | LDEQ_RwR-main/datasets/WFLW_V/helpers.py |
import cv2
import numpy as np
import torch
import math
import itertools
def get_dir(src_point, rot_rad):
sn, cs = np.sin(rot_rad), np.cos(rot_rad)
src_result = [0, 0]
src_result[0] = src_point[0] * cs - src_point[1] * sn
src_result[1] = src_point[0] * sn + src_point[1] * cs
return src_result
de... | 6,951 | 31.947867 | 159 | py |
LDEQ_RwR | LDEQ_RwR-main/datasets/WFLW/dataset.py | """code adapted from https://github.com/starhiking/HeatmapInHeatmap"""
import torch.utils.data as data
import torch
import torchvision.transforms as transforms
import numpy as np
import sys
sys.path.append('.')
import os
from PIL import Image
import math
def flip_points(data_type="WFLW"):
data_type = data_type.up... | 5,922 | 38.225166 | 307 | py |
LDEQ_RwR | LDEQ_RwR-main/utils/loss_function.py | import torch
import numpy as np
from scipy.integrate import simps
def compute_fr_and_auc(nmes, thres=0.10, step=0.0001):
num_data = len(nmes)
xs = np.arange(0, thres + step, step)
ys = np.array([np.count_nonzero(nmes <= x) for x in xs]) / float(num_data)
fr = 1.0 - ys[-1]
auc = simps(ys, x=xs) / th... | 2,552 | 33.5 | 198 | py |
LDEQ_RwR | LDEQ_RwR-main/utils/solvers.py |
"""
Modified based on the DEQ repo.
Note that the convergence error isn't based on ||x_prev - x_curr|| but on || f(x_curr) - x_curr ||.
These 2 are only equivalent for the fpi solver
"""
import torch
from torch import nn
import torch.nn.functional as F
from torch.autograd import Function
import numpy as np
import... | 18,786 | 42.387991 | 249 | py |
LDEQ_RwR | LDEQ_RwR-main/utils/helpers.py | import torch
import numpy as np
import argparse
def set_torch_seeds(seed):
import random
import numpy as np
import torch
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
def format_time(seconds):
if seconds<1e-6:
return "%dns" % (secon... | 1,078 | 24.093023 | 100 | py |
LDEQ_RwR | LDEQ_RwR-main/utils/normalize.py | import torch
import torch.nn as nn
import pdb
import torch
class Normalize(nn.Module):
"""normalize to [0,1]"""
def __init__(self, n_channels, mode, beta=1.0, learn_beta=False):
super().__init__()
self.mode=mode
assert mode in ['softargmax', 'linear'], f"norm {mode} not recognized"
... | 5,470 | 47.415929 | 187 | py |
Adversarial-Policy-Gradient-Augmentation | Adversarial-Policy-Gradient-Augmentation-master/apga_mura.py |
import fire
def mura_experiment(seed, body_part, n_runs, gpu_id, n_shot=None, train_cutout=False, train_apga=False, train_gradcam=False, train_end2end=False):
import warnings
warnings.filterwarnings('ignore')
import os
os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"... | 65,810 | 38.384201 | 154 | py |
Adversarial-Policy-Gradient-Augmentation | Adversarial-Policy-Gradient-Augmentation-master/grad_cam.py |
#!/usr/bin/env python
# coding: utf-8
#
# Author: Kazuto Nakashima
# URL: http://kazuto1011.github.io
# Created: 2017-05-26
from collections import OrderedDict, Sequence
import numpy as np
import torch
import torch.nn as nn
from torch.nn import functional as F
from tqdm import tqdm
class _BaseWrapper(objec... | 7,460 | 30.348739 | 88 | py |
Adversarial-Policy-Gradient-Augmentation | Adversarial-Policy-Gradient-Augmentation-master/TernausNet/unet_models.py | from torch import nn
from torch.nn import functional as F
import torch
from torchvision import models
import torchvision
def conv3x3(in_, out):
return nn.Conv2d(in_, out, 3, padding=1)
class ConvRelu(nn.Module):
def __init__(self, in_, out):
super().__init__()
self.conv = conv3x3(in_, out)
... | 11,190 | 35.216828 | 116 | py |
iEBE-MUSIC-ldu_dev | iEBE-MUSIC-ldu_dev/docs/SphinxDoc/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... | 2,383 | 33.057143 | 79 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/simple-scripts/resnet34_corn.py | import argparse
from functools import partial
import os
import time
import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
from torchvision.datasets import MNIST
from torchvision import transforms
# Import from local helper file
from helpe... | 8,014 | 26.354949 | 83 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/simple-scripts/resnet34_niu.py | import argparse
from functools import partial
import os
import time
import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
from torchvision.datasets import MNIST
from torchvision import transforms
# Import from local helper file
from helpe... | 10,152 | 27.84375 | 83 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/simple-scripts/helper.py | import random
import pandas as pd
import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
import torchvision
def parse_cmdline_args(parser):
parser.add_argument(
'--cuda',
type=int,
default=-1,
help='Which GPU device to use. Uses cpu if `-1`.'
... | 10,656 | 31.099398 | 109 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/simple-scripts/mlp_classifier.py | import argparse
import os
import shutil
import time
import torch
# Import from local helper file
from helper import parse_cmdline_args
from helper import compute_mae_and_rmse
from helper import get_dataloaders_fireman
# Argparse helper
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsH... | 6,146 | 26.32 | 83 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/simple-scripts/resnet34_classifier.py | import argparse
import os
from functools import partial
import time
import torch
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
from torchvision.datasets import MNIST
from torchvision import transforms
# Import from local helper file
from helper import parse_cmdline_args
from... | 7,023 | 26.015385 | 83 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/simple-scripts/mlp_corn.py | import argparse
import os
import shutil
import time
import torch
import torch.nn.functional as F
# Import from local helper file
from helper import parse_cmdline_args
from helper import compute_mae_and_rmse
from helper import get_dataloaders_fireman
# Argparse helper
parser = argparse.ArgumentParser(
formatter_... | 7,128 | 26.631783 | 83 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/simple-scripts/mlp_coral.py | import argparse
import os
import shutil
import time
import torch
import torch.nn.functional as F
# Import from local helper file
from helper import parse_cmdline_args
from helper import compute_mae_and_rmse
from helper import get_dataloaders_fireman
# Argparse helper
parser = argparse.ArgumentParser(
formatter_... | 9,495 | 28.490683 | 83 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/simple-scripts/mlp_niu.py | import argparse
import os
import shutil
import time
import torch
import torch.nn.functional as F
# Import from local helper file
from helper import parse_cmdline_args
from helper import compute_mae_and_rmse
from helper import get_dataloaders_fireman
# Argparse helper
parser = argparse.ArgumentParser(
formatter_... | 9,266 | 28.233438 | 83 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/simple-scripts/resnet34_coral.py | import argparse
from functools import partial
import os
import time
import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
from torchvision.datasets import MNIST
from torchvision import transforms
# Import from local helper file
from helpe... | 10,335 | 28.033708 | 83 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/rnn-text/rnn_niu.py | # coding: utf-8
# Imports
import os
import json
import pandas as pd
import time
import torch
import torch.nn as nn
import argparse
import sys
import numpy as np
import torchtext
import random
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
# ### from local .py files
if __... | 12,167 | 33.765714 | 94 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/rnn-text/rnn_coral.py | # coding: utf-8
# Imports
import os
import json
import pandas as pd
import time
import torch
import torch.nn as nn
import argparse
import sys
import numpy as np
import torchtext
import random
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
# ### from local .py files
if __... | 12,155 | 33.731429 | 94 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/rnn-text/rnn_corn.py | # coding: utf-8
# Like v2, and in contrast to v1, this version removes the cumprod from the forward pass
# In addition, it uses a different conditional loss function compared to v2.
# Here, the loss is computed as the average loss of the total samples,
# instead of firstly averaging the cross entropy inside each tas... | 12,546 | 34.343662 | 105 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/rnn-text/rnn_xentr.py | # coding: utf-8
# Imports
import os
import json
import pandas as pd
import time
import torch
import torch.nn as nn
import argparse
import sys
import numpy as np
import torchtext
import random
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
# ### from local .py files
if __... | 11,978 | 33.621387 | 94 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/rnn-text/helper_files/parser.py | # Sebastian Raschka 2020
# coral_pytorch
# Author: Sebastian Raschka <sebastianraschka.com>
#
# License: MIT
import argparse
def parse_cmdline_args(parser=None):
if parser is None:
parser = argparse.ArgumentParser()
parser.add_argument('--outpath',
type=str,
... | 2,462 | 26.674157 | 59 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/rnn-text/helper_files/losses.py | import torch.nn.functional as F
import torch
def coral_loss(logits, levels, importance_weights=None, reduction='mean'):
"""Computes the CORAL loss described in
Cao, Mirjalili, and Raschka (2020)
*Rank Consistent Ordinal Regression for Neural Networks
with Application to Age Estimation*
Pattern... | 4,424 | 31.777778 | 82 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/rnn-text/helper_files/constants.py | # Sebastian Raschka 2020
# coral_pytorch
# Author: Sebastian Raschka <sebastianraschka.com>
#
# License: MIT
TRIPADVISOR_BALANCED_INFO = {
'DATA_PATH': '/workspace/xshi242/tripadvisor_balanced.csv'}
COURSERA_BALANCED_INFO = {
'DATA_PATH': '/workspace/xshi242/coursera_balanced.csv'}
# TRIPADVISOR_BALANCED_INF... | 1,920 | 35.942308 | 72 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/rnn-text/helper_files/helper.py | import torch
import random
import os
import numpy as np
def set_all_seeds(seed):
os.environ["PL_GLOBAL_SEED"] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
def set_deterministic():
if torch.cuda.is_available():
torch.backe... | 432 | 20.65 | 49 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/rnn-text/helper_files/dataset.py | # Sebastian Raschka 2020
# coral_pytorch
# Author: Sebastian Raschka <sebastianraschka.com>
#
# License: MIT
import torch
from torch.utils.data import Dataset
from torchvision import transforms
from PIL import Image
import pandas as pd
import os
def label_to_levels(label, num_classes, dtype=torch.float32):
"""Co... | 9,491 | 29.918567 | 82 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/rnn-text/helper_files/layers.py | # Sebastian Raschka 2020
# coral_pytorch
# Author: Sebastian Raschka <sebastianraschka.com>
#
# License: MIT
import torch
class CoralLayer(torch.nn.Module):
""" Implements CORAL layer described in
Cao, Mirjalili, and Raschka (2020)
*Rank Consistent Ordinal Regression for Neural Networks
with Appl... | 1,354 | 25.568627 | 77 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/rnn-text/helper_files/resnet34.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... | 1,031 | 24.8 | 73 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/rnn-text/helper_files/trainingeval.py | import os
import time
import torch
import numpy as np
from dataset import proba_to_label, proba_to_label_wenzhi
def compute_mae_and_mse(model, data_loader, device, which_model):
with torch.no_grad():
mae, mse, num_examples = 0., 0., 0
for i, batch_data in enumerate(data_loader):
fea... | 16,774 | 39.519324 | 87 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/resnet34_conditional-v2.py | # coding: utf-8
# In contrast to v1, this version removes the cumprod from the forward pass
# Imports
import os
import json
import pandas as pd
import time
import torch
import torch.nn as nn
import argparse
import sys
import numpy as np
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRand... | 14,906 | 33.268966 | 88 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/resnet34_conditional-v3.py | # coding: utf-8
# Like v2, and in contrast to v1, this version removes the cumprod from the forward pass
# In addition, it uses a different conditional loss function compared to v2.
# Here, the loss is computed as the average loss of the total samples,
# instead of firstly averaging the cross entropy inside each tas... | 16,555 | 34.604301 | 105 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/vgg16_niu.py | # coding: utf-8
# Imports
import os
import json
import pandas as pd
import time
import torch
import torch.nn as nn
import types
import argparse
import sys
import numpy as np
from torchvision import transforms
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
# ### from local ... | 13,481 | 26.855372 | 88 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/resnet34_xentr.py | # coding: utf-8
# Imports
import os
import json
import pandas as pd
import time
import torch
import torch.nn as nn
import argparse
import sys
import numpy as np
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
# ### from local .py files
from helper_files.trainingeval import... | 15,806 | 34.04878 | 88 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/resnet34_niu.py | # coding: utf-8
# Imports
import os
import json
import pandas as pd
import time
import torch
import torch.nn as nn
import argparse
import sys
import numpy as np
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
# ### from local .py files
from helper_files.trainingeval import... | 16,628 | 34.532051 | 88 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/vgg16_xentr.py | # coding: utf-8
# Imports
import os
import json
import pandas as pd
import time
import torch
import torch.nn as nn
import types
import argparse
import sys
import numpy as np
from torchvision import transforms
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
# ### from local ... | 12,833 | 26.540773 | 88 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/resnet34_conditional-v2-argmax.py | # coding: utf-8
# In contrast to v1, this version removes the cumprod from the forward pass
# Imports
import os
import json
import pandas as pd
import time
import torch
import torch.nn as nn
import argparse
import sys
import numpy as np
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRand... | 14,934 | 33.333333 | 88 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/vgg16_coral.py | # coding: utf-8
# Imports
import os
import json
import pandas as pd
import time
import torch
import torch.nn as nn
import types
import argparse
import sys
import numpy as np
from torchvision import transforms
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
# ### from local ... | 13,221 | 26.835789 | 88 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/resnet34_conditional-v3-ablation.py | # coding: utf-8
# Like v2, and in contrast to v1, this version removes the cumprod from the forward pass
# In addition, it uses a different conditional loss function compared to v2.
# Here, the loss is computed as the average loss of the total samples,
# instead of firstly averaging the cross entropy inside each tas... | 16,573 | 34.643011 | 105 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/resnet34_conditional-v3-argmax.py | # coding: utf-8
# Like v2, and in contrast to v1, this version removes the cumprod from the forward pass
# In addition, it uses a different conditional loss function compared to v2.
# Here, the loss is computed as the average loss of the total samples,
# instead of firstly averaging the cross entropy inside each tas... | 15,350 | 33.809524 | 105 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/resnet34_regr.py | # coding: utf-8
# Imports
import os
import json
import pandas as pd
import time
import torch
import torch.nn as nn
import argparse
import sys
import numpy as np
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
# ### from local .py files
from helper_files.trainingeval import... | 14,965 | 33.325688 | 88 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/resnet34_coral.py | # coding: utf-8
# Imports
import os
import json
import pandas as pd
import time
import torch
import torch.nn as nn
import argparse
import sys
import numpy as np
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
# ### from local .py files
from helper_files.trainingeval import... | 16,499 | 34.407725 | 88 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/vgg16_conditional-v3.py | # coding: utf-8
# Like v2, and in contrast to v1, this version removes the cumprod from the forward pass
# In addition, it uses a different conditional loss function compared to v2.
# Here, the loss is computed as the average loss of the total samples,
# instead of firstly averaging the cross entropy inside each task... | 13,563 | 27.317328 | 104 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/helper_files/parser.py | # Sebastian Raschka 2020
# coral_pytorch
# Author: Sebastian Raschka <sebastianraschka.com>
#
# License: MIT
import argparse
def parse_cmdline_args(parser=None):
if parser is None:
parser = argparse.ArgumentParser()
parser.add_argument('--outpath',
type=str,
... | 2,773 | 27.895833 | 89 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/helper_files/losses.py | import torch.nn.functional as F
import torch
def coral_loss(logits, levels, importance_weights=None, reduction='mean'):
"""Computes the CORAL loss described in
Cao, Mirjalili, and Raschka (2020)
*Rank Consistent Ordinal Regression for Neural Networks
with Application to Age Estimation*
Pattern... | 5,204 | 31.53125 | 82 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/helper_files/constants.py | # Sebastian Raschka 2020
# coral_pytorch
# Author: Sebastian Raschka <sebastianraschka.com>
#
# License: MIT
MORPH2_INFO = {
'TRAIN_CSV_PATH': '/home/raschka/code/github/ordinal-conditional/data/processed/morph2/morph2_train.csv',
'TEST_CSV_PATH': '/home/raschka/code/github/ordinal-conditional/data/processed/m... | 2,103 | 59.114286 | 118 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/helper_files/helper.py | import torch
import random
import os
import numpy as np
def set_all_seeds(seed):
os.environ["PL_GLOBAL_SEED"] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
def set_deterministic():
if torch.cuda.is_available():
torch.backe... | 432 | 20.65 | 49 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/helper_files/dataset.py | # Sebastian Raschka 2020
# coral_pytorch
# Author: Sebastian Raschka <sebastianraschka.com>
#
# License: MIT
import torch
from torch.utils.data import Dataset
from torchvision import transforms
from PIL import Image
import pandas as pd
import os
def label_to_levels(label, num_classes, dtype=torch.float32):
"""Co... | 11,085 | 29.96648 | 82 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/helper_files/layers.py | # Sebastian Raschka 2020
# coral_pytorch
# Author: Sebastian Raschka <sebastianraschka.com>
#
# License: MIT
import torch
class CoralLayer(torch.nn.Module):
""" Implements CORAL layer described in
Cao, Mirjalili, and Raschka (2020)
*Rank Consistent Ordinal Regression for Neural Networks
with Appl... | 1,354 | 25.568627 | 77 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/helper_files/resnet34.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... | 1,031 | 24.8 | 73 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/cnn-image/helper_files/trainingeval.py | import os
import time
import torch
import numpy as np
from helper_files.dataset import proba_to_label
def compute_mae_and_mse(model, data_loader, device, which_model):
with torch.no_grad():
mae, mse, num_examples = 0., 0., 0
for i, (features, targets) in enumerate(data_loader):
fea... | 15,393 | 39.832891 | 87 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/mlp-tabular/mlp-conditional-ablation.py | #!/usr/bin/env python
# coding: utf-8
# In[1]:
# get_ipython().run_line_magic('load_ext', 'watermark')
# get_ipython().run_line_magic('watermark', "-a 'Sebastian Raschka' -v -p torch")
# # MLP
# ## Imports
# In[2]:
import os
import json
import torch
import numpy as np
import matplotlib.pyplot as plt
import argp... | 4,884 | 23.547739 | 98 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/mlp-tabular/mlp-conditional.py | #!/usr/bin/env python
# coding: utf-8
# In[1]:
# get_ipython().run_line_magic('load_ext', 'watermark')
# get_ipython().run_line_magic('watermark', "-a 'Sebastian Raschka' -v -p torch")
# # MLP
# ## Imports
# In[2]:
import os
import json
import torch
import numpy as np
import matplotlib.pyplot as plt
import argp... | 4,875 | 23.502513 | 98 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/mlp-tabular/mlp-cross-entropy.py | #!/usr/bin/env python
# coding: utf-8
# In[1]:
# get_ipython().run_line_magic('load_ext', 'watermark')
# get_ipython().run_line_magic('watermark', "-a 'Sebastian Raschka' -v -p torch")
# # MLP
# ## Imports
# In[2]:
import os
import json
import torch
import numpy as np
import matplotlib.pyplot as plt
import argp... | 6,662 | 24.825581 | 115 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/mlp-tabular/mlp-coral.py | #!/usr/bin/env python
# coding: utf-8
# In[1]:
# get_ipython().run_line_magic('load_ext', 'watermark')
# get_ipython().run_line_magic('watermark', "-a 'Sebastian Raschka' -v -p torch")
# # MLP
# ## Imports
# In[2]:
import os
import json
import torch
import numpy as np
import matplotlib.pyplot as plt
import argp... | 6,672 | 24.764479 | 98 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/mlp-tabular/mlp-niu.py | #!/usr/bin/env python
# coding: utf-8
# In[1]:
# get_ipython().run_line_magic('load_ext', 'watermark')
# get_ipython().run_line_magic('watermark', "-a 'Sebastian Raschka' -v -p torch")
# # MLP
# ## Imports
# In[2]:
import os
import json
import torch
import numpy as np
import matplotlib.pyplot as plt
import argp... | 6,510 | 24.433594 | 98 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/mlp-tabular/helper_files/helper_parser.py | # Sebastian Raschka 2020
# coral_pytorch
# Author: Sebastian Raschka <sebastianraschka.com>
#
# License: MIT
import argparse
def parse_cmdline_args(parser=None):
if parser is None:
parser = argparse.ArgumentParser()
parser.add_argument('--outpath',
type=str,
... | 2,139 | 26.435897 | 89 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/mlp-tabular/helper_files/helper_train.py | import os
from helper_evaluate import compute_accuracy, compute_mae_and_mse
from helper_losses import niu_loss, coral_loss, conditional_loss, conditional_loss_ablation
from helper_data import levels_from_labelbatch
import time
import torch
import torch.nn.functional as F
from collections import OrderedDict
import jso... | 19,705 | 43.283146 | 117 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/mlp-tabular/helper_files/helper_plotting.py | # imports from installed libraries
import os
import matplotlib.pyplot as plt
import numpy as np
import torch
def plot_training_loss(minibatch_loss_list, num_epochs, iter_per_epoch,
results_dir=None, averaging_iterations=100):
plt.figure()
ax1 = plt.subplot(1, 1, 1)
ax1.plot(range(l... | 6,141 | 31.326316 | 79 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/mlp-tabular/helper_files/helper_layers.py | import torch
class CoralLayer(torch.nn.Module):
""" Implements CORAL layer described in
Cao, Mirjalili, and Raschka (2020)
*Rank Consistent Ordinal Regression for Neural Networks
with Application to Age Estimation*
Pattern Recognition Letters, https://doi.org/10.1016/j.patrec.2020.11.008
... | 1,243 | 27.272727 | 77 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/mlp-tabular/helper_files/helper_evaluate.py | import torch
import torch.nn.functional as F
import numpy as np
from itertools import product
# from local helper files
from helper_data import label_to_levels, levels_from_labelbatch, proba_to_label
from helper_losses import niu_loss
from helper_losses import coral_loss
def get_labels_and_predictions(model, data_lo... | 7,026 | 36.983784 | 108 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/mlp-tabular/helper_files/helper_data.py | import random
import pandas as pd
import torch
from torch.utils.data import sampler
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
from torch.utils.data import SubsetRandomSampler
from torchvision import transforms
from torchvision import datasets
def label_to_levels(label, num_classes,... | 27,916 | 35.302991 | 134 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/mlp-tabular/helper_files/helper_losses.py | import torch.nn.functional as F
import torch
def coral_loss(logits, levels, importance_weights=None, reduction='mean'):
"""Computes the CORAL loss described in
Cao, Mirjalili, and Raschka (2020)
*Rank Consistent Ordinal Regression for Neural Networks
with Application to Age Estimation*
Pattern... | 4,118 | 32.217742 | 82 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/model-code/refactored-version/mlp-tabular/helper_files/helper_utils.py | import os
import random
import numpy as np
import torch
def set_all_seeds(seed):
os.environ["PL_GLOBAL_SEED"] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
def set_deterministic():
if torch.cuda.is_available():
torch.backe... | 443 | 21.2 | 49 | py |
corn-ordinal-neuralnet | corn-ordinal-neuralnet-main/datasets/tripadvisor/rnn_clean.py | import torch
import torch.nn.functional as F
import torchtext
import time
import random
import pandas as pd
random.seed(123)
df = pd.read_csv("tripadvisor_hotel_reviews.csv")
df.columns = ['TEXT_COLUMN_NAME', 'LABEL_COLUMN_NAME']
# df = df.drop(columns=['id'])
print(df.columns)
def sampling_k_elements(group, k=1400):
... | 540 | 27.473684 | 92 | py |
duckietown_imitation_learning | duckietown_imitation_learning-main/models/model_unit_controller.py | import torch
import torch.nn as nn
import numpy as np
import os
import glob
class UnitControllerTrainer:
def __init__(self, learning_rate=0.0001):
self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
self.model = UnitControllerModel(output_size=2).to(self.device... | 3,518 | 34.545455 | 108 | py |
duckietown_imitation_learning | duckietown_imitation_learning-main/models/model_unit_network.py | """
Copyright Notice:
The implementation of our UNIT network was created based on the following public repository:
https://github.com/eriklindernoren/PyTorch-GAN#unit
"""
import torch.nn as nn
import torch.nn.functional as F
import torch
from torch.autograd import Variable
import numpy as np
def weights_init... | 4,915 | 29.534161 | 116 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.