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 |
|---|---|---|---|---|---|---|
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/distiller_zoo/PKT.py | from __future__ import print_function
import torch
import torch.nn as nn
class PKT(nn.Module):
"""Probabilistic Knowledge Transfer for deep representation learning
Code from author: https://github.com/passalis/probabilistic_kt"""
def __init__(self):
super(PKT, self).__init__()
def forward(se... | 1,675 | 37.976744 | 110 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/distiller_zoo/SP.py | from __future__ import print_function
import torch
import torch.nn as nn
import torch.nn.functional as F
class Similarity(nn.Module):
"""Similarity-Preserving Knowledge Distillation, ICCV2019, verified by original author"""
def __init__(self):
super(Similarity, self).__init__()
def forward(self,... | 908 | 28.322581 | 93 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/distiller_zoo/AT.py | from __future__ import print_function
import torch.nn as nn
import torch.nn.functional as F
class Attention(nn.Module):
"""Paying More Attention to Attention: Improving the Performance of Convolutional Neural Networks
via Attention Transfer
code: https://github.com/szagoruyko/attention-transfer"""
de... | 930 | 30.033333 | 101 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/distiller_zoo/FitNet.py | from __future__ import print_function
import torch.nn as nn
class HintLoss(nn.Module):
"""Fitnets: hints for thin deep nets, ICLR 2015"""
def __init__(self):
super(HintLoss, self).__init__()
self.crit = nn.MSELoss()
def forward(self, f_s, f_t):
loss = self.crit(f_s, f_t)
... | 332 | 21.2 | 54 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/distiller_zoo/KDSVD.py | from __future__ import print_function
import torch
import torch.nn as nn
import torch.nn.functional as F
class KDSVD(nn.Module):
"""
Self-supervised Knowledge Distillation using Singular Value Decomposition
original Tensorflow code: https://github.com/sseung0703/SSKD_SVD
"""
def __init__(self, k=... | 2,275 | 28.947368 | 94 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/distiller_zoo/RKD.py | from __future__ import print_function
import torch
import torch.nn as nn
import torch.nn.functional as F
class RKDLoss(nn.Module):
"""Relational Knowledge Disitllation, CVPR2019"""
def __init__(self, w_d=25, w_a=50):
super(RKDLoss, self).__init__()
self.w_d = w_d
self.w_a = w_a
d... | 1,681 | 27.508475 | 87 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/distiller_zoo/VID.py | from __future__ import print_function
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
class VIDLoss(nn.Module):
"""Variational Information Distillation for Knowledge Transfer (CVPR 2019),
code from author: https://github.com/ssahn0215/variational-information-distillation... | 1,862 | 32.872727 | 90 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/distiller_zoo/CC.py | from __future__ import print_function
import torch
import torch.nn as nn
class Correlation(nn.Module):
"""Correlation Congruence for Knowledge Distillation, ICCV 2019.
The authors nicely shared the code with me. I restructured their code to be
compatible with my running framework. Credits go to the orig... | 1,384 | 31.209302 | 81 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/distiller_zoo/FT.py | from __future__ import print_function
import torch.nn as nn
import torch.nn.functional as F
class FactorTransfer(nn.Module):
"""Paraphrasing Complex Network: Network Compression via Factor Transfer, NeurIPS 2018"""
def __init__(self, p1=2, p2=1):
super(FactorTransfer, self).__init__()
self.p1... | 981 | 29.6875 | 93 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/distiller_zoo/KD.py | from __future__ import print_function
import torch.nn as nn
import torch.nn.functional as F
class DistillKL(nn.Module):
"""Distilling the Knowledge in a Neural Network"""
def __init__(self, T):
super(DistillKL, self).__init__()
self.T = T
def forward(self, y_s, y_t):
p_s = F.log_... | 493 | 26.444444 | 82 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/distiller_zoo/AB.py | from __future__ import print_function
import torch
import torch.nn as nn
class ABLoss(nn.Module):
"""Knowledge Transfer via Distillation of Activation Boundaries Formed by Hidden Neurons
code: https://github.com/bhheo/AB_distillation
"""
def __init__(self, feat_num, margin=1.0):
super(ABLoss,... | 1,100 | 35.7 | 97 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/distiller_zoo/FSP.py | from __future__ import print_function
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
class FSP(nn.Module):
"""A Gift from Knowledge Distillation:
Fast Optimization, Network Minimization and Transfer Learning"""
def __init__(self, s_shapes, t_shapes):
super(FSP, self).__i... | 1,625 | 32.183673 | 76 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/distiller_zoo/NST.py | from __future__ import print_function
import torch.nn as nn
import torch.nn.functional as F
class NSTLoss(nn.Module):
"""like what you like: knowledge distill via neuron selectivity transfer"""
def __init__(self):
super(NSTLoss, self).__init__()
pass
def forward(self, g_s, g_t):
... | 1,366 | 31.547619 | 98 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/helper/pretrain.py | from __future__ import print_function, division
import time
import sys
import torch
import torch.optim as optim
import torch.backends.cudnn as cudnn
from .util import AverageMeter
def init(model_s, model_t, init_modules, criterion, train_loader, opt):
model_t.eval()
model_s.eval()
init_modules.train()
... | 3,305 | 34.170213 | 106 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/helper/loops.py | from __future__ import print_function, division
import sys
import time
import torch
from .util import AverageMeter, accuracy
def train_vanilla(epoch, train_loader, model, criterion, optimizer, opt):
"""vanilla training"""
model.train()
batch_time = AverageMeter()
data_time = AverageMeter()
loss... | 9,306 | 33.343173 | 85 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/helper/util.py | from __future__ import print_function
import torch
import numpy as np
def adjust_learning_rate_new(epoch, optimizer, LUT):
"""
new learning rate schedule according to RotNet
"""
lr = next((lr for (max_epoch, lr) in LUT if max_epoch > epoch), LUT[-1][1])
for param_group in optimizer.param_groups:
... | 1,786 | 26.921875 | 89 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/crd/memory.py | import torch
from torch import nn
import math
class ContrastMemory(nn.Module):
"""
memory buffer that supplies large amount of negative samples.
"""
def __init__(self, inputSize, outputSize, K, T=0.07, momentum=0.5):
super(ContrastMemory, self).__init__()
self.nLem = outputSize
... | 5,126 | 35.884892 | 120 | py |
cGAN-KD | cGAN-KD-main/CIFAR-100/RepDistiller/crd/criterion.py | import torch
from torch import nn
from .memory import ContrastMemory
eps = 1e-7
class CRDLoss(nn.Module):
"""CRD Loss function
includes two symmetric parts:
(a) using teacher as anchor, choose positive and negatives over the student side
(b) using student as anchor, choose positive and negatives over... | 3,309 | 31.135922 | 119 | py |
CodeMixedTreebank | CodeMixedTreebank-master/UDParser/driver/TrainTest.py | import sys
sys.path.extend(["../../","../","./"])
import time
import torch.optim.lr_scheduler
import torch.nn as nn
import random
import argparse
from driver.Config import *
from driver.Model import *
from driver.Parser import *
from data.Dataloader import *
import pickle
def train(data, parser, vocab, config, others)... | 7,271 | 40.318182 | 129 | py |
CodeMixedTreebank | CodeMixedTreebank-master/UDParser/driver/Parser.py | import torch.nn.functional as F
from driver.MST import *
import torch.optim.lr_scheduler
from driver.Layer import *
import numpy as np
def pad_sequence(xs, length=None, padding=-1, dtype=np.float64):
lengths = [len(x) for x in xs]
if length is None:
length = max(lengths)
y = np.array([np.pad(x.asty... | 6,780 | 37.310734 | 92 | py |
CodeMixedTreebank | CodeMixedTreebank-master/UDParser/driver/Layer.py | import torch
import torch.nn as nn
import numpy as np
from torch.nn import functional, init
def get_tensor_np(t):
return t.data.cpu().numpy()
def orthonormal_initializer(output_size, input_size):
"""
adopted from Timothy Dozat https://github.com/tdozat/Parser/blob/master/lib/linalg.py
"""
print(ou... | 11,929 | 41.913669 | 107 | py |
CodeMixedTreebank | CodeMixedTreebank-master/UDParser/driver/Model.py | from driver.Layer import *
from data.Vocab import *
def drop_tri_input_independent(word_embeddings, tag_embeddings, context_embeddings, dropout_emb):
batch_size, seq_length, _ = word_embeddings.size()
word_masks = word_embeddings.new_full((batch_size, seq_length), 1-dropout_emb)
word_masks = torch.bernoul... | 6,687 | 43.586667 | 114 | py |
CodeMixedTreebank | CodeMixedTreebank-master/UDParser/data/Dataloader.py | from data.Vocab import *
import numpy as np
import torch
def read_corpus(file_path, vocab=None):
data = []
with open(file_path, 'r', encoding='UTF-8') as infile:
for sentence in readDepTree(infile, vocab):
data.append(sentence)
return data
def sentences_numberize(sentences, vocab):
... | 2,952 | 29.132653 | 130 | py |
LSMOL | LSMOL-main/evaluation/generate_3d_instance_gt.py | import torch
import pickle
import os
import numpy as np
from PIL import Image
from mmdet3d.core.bbox import CameraInstance3DBoxes,get_box_type
def main():
# change the path to your own path
pickle_data_path = '/data/waymo_root/kitti_format/waymo_infos_val.pkl'
root = '/data/waymo_root/kitti_format'
f... | 2,020 | 30.578125 | 111 | py |
LSMOL | LSMOL-main/evaluation/eval_3d_instance.py | import torch
import pickle
import os
import cv2
import numpy as np
from PIL import Image
from mmdet3d.core.bbox import CameraInstance3DBoxes,get_box_type
from matplotlib import pyplot as plt
import matplotlib.patches as patches
from scipy import stats
def calculate_PR(class_tp, class_fp, class_score, class_gt_num):
... | 7,685 | 31.987124 | 123 | py |
LSMOL | LSMOL-main/third_party/nspf/optimization.py | """optimize over a network structure."""
import argparse
import logging
import os
import copy
import matplotlib.pyplot as plt
import numpy as np
import open3d as o3d
import pandas as pd
import torch
from torch.utils.data import DataLoader
from tqdm import tqdm
from model import Neural_Prior
import config
from data i... | 10,110 | 33.158784 | 122 | py |
LSMOL | LSMOL-main/third_party/nspf/loss.py | # code mostly copied from pytorch3d
from typing import Union
import torch
import torch.nn.functional as F
from pytorch3d.ops.knn import knn_gather, knn_points
from pytorch3d.structures.pointclouds import Pointclouds
def _validate_chamfer_reduction_inputs(
batch_reduction: Union[str, None], point_reduction: str
)... | 8,316 | 36.295964 | 88 | py |
LSMOL | LSMOL-main/third_party/nspf/utils.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import torch
import time
from collections import defaultdict
# ANCHOR: metrics computation, follow FlowNet3D metrics....
def scene_flow_metrics(pred, labels):
l2_no... | 4,540 | 29.273333 | 94 | py |
LSMOL | LSMOL-main/third_party/nspf/model.py | import torch
class Neural_Prior(torch.nn.Module):
def __init__(self, dim_x=3, filter_size=128, act_fn='relu', layer_size=8):
super().__init__()
self.layer_size = layer_size
self.nn_layers = torch.nn.ModuleList([])
# input layer (default: xyz -> 128)
if layer_si... | 1,322 | 36.8 | 101 | py |
LSMOL | LSMOL-main/third_party/nspf/data.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import glob
import numpy as np
from torch.utils.data import Dataset
class FlyingThings3D(Dataset):
def __init__(self, options, partition='test'):
self.options = options
self.partition = partition
if self.partition == 'train':
self.... | 16,165 | 39.720403 | 123 | py |
LSMOL | LSMOL-main/third_party/nspf/config.py | import argparse
import os
import numpy as np
import torch
def str2bool(v):
if v.lower() in ('yes', 'true', 't', 'y', '1'):
return True
elif v.lower() in ('no', 'false', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError('Boolean value expected.')
def init_dirs(o... | 4,058 | 60.5 | 129 | py |
LSMOL | LSMOL-main/third_party/nspf/process/preprocess_sf_nuscenes.py | import os
from dataclasses import dataclass
from pathlib import Path
import numpy as np
import open3d as o3d
from argoverse.utils.cuboid_interior import (filter_point_cloud_to_bbox_3D_vectorized)
from argoverse.utils.se3 import SE3
from argoverse.utils.transform import quat2rotmat
from torch.utils.data import Dataset
... | 22,943 | 38.020408 | 141 | py |
LSMOL | LSMOL-main/third_party/nspf/process/preprocess_sf_argoverse.py | import copy
import glob
from dataclasses import dataclass
from pathlib import Path
from typing import List, Optional
import argoverse.data_loading.object_label_record as object_label
import numpy as np
import open3d as o3d
from argoverse.map_representation.map_api import ArgoverseMap
from argoverse.utils.cuboid_interi... | 11,330 | 40.811808 | 160 | py |
LSMOL | LSMOL-main/model_training/train_det_2d_class.py | import logging
import os
from collections import OrderedDict
import torch
import detectron2.utils.comm as comm
from detectron2.checkpoint import DetectionCheckpointer
from detectron2.config import get_cfg
from detectron2.data import MetadataCatalog
from detectron2.data import DatasetCatalog
from detectron2.data.datase... | 5,795 | 35.917197 | 154 | py |
LSMOL | LSMOL-main/model_training/train_det_2d.py | import logging
import os
from collections import OrderedDict
import torch
import detectron2.utils.comm as comm
from detectron2.checkpoint import DetectionCheckpointer
from detectron2.config import get_cfg
from detectron2.data import MetadataCatalog
from detectron2.data import DatasetCatalog
from detectron2.data.datase... | 5,880 | 35.987421 | 152 | py |
SSKD | SSKD-master/teacher.py | import os
import os.path as osp
import argparse
import time
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.optim.lr_scheduler import MultiStepLR
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
from torchv... | 5,112 | 34.020548 | 110 | py |
SSKD | SSKD-master/student.py | import os
import os.path as osp
import argparse
import time
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.optim.lr_scheduler import MultiStepLR
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
from tensor... | 14,139 | 38.830986 | 123 | py |
SSKD | SSKD-master/wrapper.py | import torch
import torch.nn as nn
import torch.nn.functional as F
class wrapper(nn.Module):
def __init__(self, module):
super(wrapper, self).__init__()
self.backbone = module
feat_dim = list(module.children())[-1].in_features
self.proj_head = nn.Sequential(
nn.Linear... | 702 | 24.107143 | 58 | py |
SSKD | SSKD-master/utils.py | import os
import logging
import numpy as np
import torch
from torch.nn import init
class AverageMeter(object):
"""Computes and stores the average and current value"""
def __init__(self):
self.reset()
def reset(self):
self.count = 0
self.sum = 0.0
self.val = 0.0
sel... | 1,010 | 21.977273 | 69 | py |
SSKD | SSKD-master/cifar.py | from __future__ import print_function
from PIL import Image
import os
import os.path
import numpy as np
import sys
import pickle
import torch
import torch.utils.data as data
from itertools import permutations
class VisionDataset(data.Dataset):
_repr_indent = 4
def __init__(self, root, transforms=None, trans... | 7,139 | 31.752294 | 86 | py |
SSKD | SSKD-master/models/resnet.py | from __future__ import absolute_import
'''Resnet for cifar dataset.
Ported form
https://github.com/facebook/fb.resnet.torch
and
https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py
(c) YANG, Wei
'''
import torch.nn as nn
import torch.nn.functional as F
import math
__all__ = ['resnet']
def con... | 8,021 | 29.044944 | 116 | py |
SSKD | SSKD-master/models/mobilenetv2.py | """
MobileNetV2 implementation used in
<Knowledge Distillation via Route Constrained Optimization>
"""
import torch
import torch.nn as nn
import math
__all__ = ['mobilenetv2_T_w', 'mobile_half']
BN = None
def conv_bn(inp, oup, stride):
return nn.Sequential(
nn.Conv2d(inp, oup, 3, stride, 1, bias=False)... | 5,777 | 27.323529 | 115 | py |
SSKD | SSKD-master/models/vgg.py | '''VGG for CIFAR10. FC layers are removed.
(c) YANG, Wei
'''
import torch.nn as nn
import torch.nn.functional as F
import math
__all__ = [
'VGG', 'vgg11', 'vgg11_bn', 'vgg13', 'vgg13_bn', 'vgg16', 'vgg16_bn',
'vgg19_bn', 'vgg19',
]
model_urls = {
'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30... | 6,971 | 28.417722 | 98 | py |
SSKD | SSKD-master/models/classifier.py | from __future__ import print_function
import torch.nn as nn
#########################################
# ===== Classifiers ===== #
#########################################
class LinearClassifier(nn.Module):
def __init__(self, dim_in, n_label=10):
super(LinearClassifier, self).__init__()
self.n... | 819 | 21.777778 | 51 | py |
SSKD | SSKD-master/models/resnetv2.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):
expansion... | 6,915 | 33.753769 | 106 | py |
SSKD | SSKD-master/models/ShuffleNetv1.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_... | 4,732 | 33.05036 | 126 | py |
SSKD | SSKD-master/models/util.py | from __future__ import print_function
import torch.nn as nn
import math
class Paraphraser(nn.Module):
"""Paraphrasing Complex Network: Network Compression via Factor Transfer"""
def __init__(self, t_shape, k=0.5, use_bn=False):
super(Paraphraser, self).__init__()
in_channel = t_shape[1]
... | 9,622 | 32.068729 | 107 | py |
SSKD | SSKD-master/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__()
... | 7,074 | 32.530806 | 107 | py |
SSKD | SSKD-master/models/wrn.py | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
"""
Original Author: Wei Yang
"""
__all__ = ['wrn']
class BasicBlock(nn.Module):
def __init__(self, in_planes, out_planes, stride, dropRate=0.0):
super(BasicBlock, self).__init__()
self.bn1 = nn.BatchNorm2d(in_planes)... | 5,519 | 31.280702 | 116 | py |
scirepeval | scirepeval-main/scirepeval.py | import argparse
import json
from typing import List, Union
from evaluation.encoders import Model
from evaluation.evaluator import IREvaluator, SupervisedEvaluator, SupervisedTask
from evaluation.few_shot_evaluator import FewShotEvaluator
from evaluation.gpt3_encoder import GPT3Model
from evaluation.instructor import I... | 7,865 | 52.510204 | 121 | py |
scirepeval | scirepeval-main/adapter_fusion.py | from typing import List, Optional, Union, Dict
from transformers.adapters import PfeifferConfig
from transformers.adapters import AutoAdapterModel
from transformers.adapters.composition import Fuse
from abc import ABC, abstractmethod
import torch
import os
class AdapterFactory:
@staticmethod
def get_adapter(c... | 4,905 | 44.850467 | 121 | py |
scirepeval | scirepeval-main/bert_pals.py | # coding=utf-8
# Copyright 2018 The Google AI Language Team Authors and The HugginFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENS... | 40,279 | 45.728538 | 120 | py |
scirepeval | scirepeval-main/evaluation/gpt3_encoder.py | import os
import openai
import torch
from transformers import GPT2TokenizerFast
class GPT3Model:
def __init__(self, embed_model: str):
openai.api_key = os.getenv("OPENAI_API_KEY")
self.embed_model = embed_model
self.tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")
def __call__(se... | 1,019 | 31.903226 | 66 | py |
scirepeval | scirepeval-main/evaluation/encoders.py | from typing import Dict, Union, List
from transformers import AutoModel, AutoTokenizer
import os
from bert_pals import BertPalsEncoder, BertPalConfig, BertModel
from adapter_fusion import AdapterEncoder, AdapterFusion
import torch
import logging
logger = logging.getLogger(__name__)
class EncoderFactory:
def __i... | 6,499 | 48.618321 | 119 | py |
scirepeval | scirepeval-main/training/pl_training.py | import json
import sys
# setting path
sys.path.append('../')
import argparse
from typing import Dict, Optional, Any
import datasets
import pytorch_lightning as pl
import torch
import torch.nn
from pytorch_lightning.callbacks import ModelCheckpoint
from pytorch_lightning.loggers import TensorBoardLogger
from pytorch_l... | 16,448 | 49.612308 | 141 | py |
scirepeval | scirepeval-main/training/strategies.py | import enum
from abc import ABC, abstractmethod
from typing import Iterable
from torch.utils.data import Dataset
import random
class BatchWrapper(ABC):
@abstractmethod
def get_batch_iter(self, datasets: Iterable[Dataset], batch_size: int):
pass
class SequentialBatching(BatchWrapper):
def get_b... | 2,200 | 26.860759 | 75 | py |
scirepeval | scirepeval-main/training/mtl_datasets.py | import decimal
from typing import Iterator, Tuple, List, Dict, Union, Any, Iterable
import torch
from torch.utils.data import IterableDataset, DataLoader, ChainDataset, get_worker_info
from torch.utils.data.dataset import T_co, Dataset
from transformers import PreTrainedTokenizer, BatchEncoding, AutoTokenizer
import da... | 15,001 | 47.083333 | 145 | py |
scirepeval | scirepeval-main/training/schedulers.py | from dataclasses import dataclass, field
import torch.optim.optimizer
from fairseq.dataclass import FairseqDataclass
from omegaconf import II
from torch.optim.optimizer import Optimizer
"""Code picked up from fairseq implementation and adapted to suit pytorch lightning"""
@dataclass
class InverseSquareRootScheduleC... | 2,683 | 36.802817 | 87 | py |
scirepeval | scirepeval-main/training/tasks.py | from typing import Dict
from torch import nn
import torch
import torch.nn.functional as F
import json
class TaskFamily:
def __init__(self, name, loss, type, dataset=None, data_files=None, multi_label=False, input_fields=None,
labels_field=None, labels=None, ctrl_token=None, head=None, contrastiv... | 6,393 | 41.065789 | 152 | py |
vqg-unknown | vqg-unknown-master/test.py | from __future__ import division
from __future__ import print_function
from __future__ import absolute_import
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from utils.region_extract import *
from utils.utils import *
from src.net import ResNet
from src.net import ImageCaption
import chainer
... | 4,368 | 33.952 | 115 | py |
vqg-unknown | vqg-unknown-master/src/feature_extract.py | import pickle
from skimage import io
from scipy.misc import imresize
import chainer
from chainer import Variable, cuda
from chainer.links.model.vision import resnet
import numpy as np
import argparse
from net import ResNet
xp = cuda.cupy
def region_resize(image, region):
x, y, w, h = region
aspect_list = np.... | 3,779 | 33.363636 | 110 | py |
pip | pip-main/src/pip/_vendor/rich/_export_format.py | CONSOLE_HTML_FORMAT = """\
<!DOCTYPE html>
<head>
<meta charset="UTF-8">
<style>
{stylesheet}
body {{
color: {foreground};
background-color: {background};
}}
</style>
</head>
<html>
<body>
<pre style="font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace"><code>{code}</code></pre>
</body>
</... | 2,100 | 26.285714 | 122 | py |
pip | pip-main/tests/unit/test_req_install.py | import os
import tempfile
from pathlib import Path
import pytest
from pip._vendor.packaging.requirements import Requirement
from pip._internal.exceptions import InstallationError
from pip._internal.req.constructors import (
install_req_from_line,
install_req_from_req_string,
)
from pip._internal.req.req_insta... | 4,326 | 37.292035 | 86 | py |
pyrebox | pyrebox-master/volatility/volatility/plugins/registry/shimcache.py | # Volatility
# Copyright (C) 2008-2013 Volatility Foundation
# Copyright (C) 2011 Jamie Levy (Gleeda) <jamie@memoryanalysis.net>
#
# This file is part of Volatility.
#
# Volatility is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free S... | 11,646 | 36.938111 | 121 | py |
pyrebox | pyrebox-master/volatility/volatility/plugins/malware/svcscan.py | # Volatility
# Copyright (C) 2007-2013 Volatility Foundation
# Copyright (c) 2010, 2011, 2012 Michael Ligh <michael.ligh@mnin.org>
#
# This file is part of Volatility.
#
# Volatility is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free... | 28,929 | 44.344828 | 130 | py |
pyrebox | pyrebox-master/volatility/volatility/plugins/overlays/windows/vista.py | # Volatility
# Copyright (c) 2008-2013 Volatility Foundation
# Copyright (c) 2008 Brendan Dolan-Gavitt <bdolangavitt@wesleyan.edu>
#
# This file is part of Volatility.
#
# Volatility is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free... | 11,726 | 37.198697 | 100 | py |
pytorch_convNd | pytorch_convNd-master/main.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from convNd import convNd
import time
import matplotlib.pyplot as plt
import sys
torch.backends.cudnn.deterministic = True
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f'Python version: {sys.version}')
print(f'Pytorch ... | 3,193 | 27.265487 | 85 | py |
pytorch_convNd | pytorch_convNd-master/convNd.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import Tuple, Callable
import math
class convNd(nn.Module):
"""Some Information about convNd"""
def __init__(self,in_channels: int,
out_channels: int,
num_dims: int,
kernel_size: Tu... | 10,228 | 45.076577 | 157 | py |
pytorch_convNd | pytorch_convNd-master/mainNd.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from convNd import convNd
import time
import matplotlib.pyplot as plt
torch.backends.cudnn.deterministic = True
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Define 4D tensor to test on
inChans = 1
outChans = 1
x = torch.ones... | 1,553 | 26.263158 | 72 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/setup.py | from setuptools import setup
setup(
name="improved-diffusion",
py_modules=["improved_diffusion"],
install_requires=["blobfile>=1.0.5", "torch", "tqdm"],
)
| 168 | 20.125 | 58 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/rpe.py | import numpy as np
import torch.nn as nn
import torch.nn.functional as F
import torch as th
from .nn import zero_module, normalization, checkpoint
class RPENet(nn.Module):
def __init__(self, channels, num_heads, time_embed_dim):
super().__init__()
self.embed_distances = nn.Linear(3, channels)
... | 7,700 | 43.258621 | 145 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/frechet_video_distance.py | # Copyright 2022 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agree... | 11,237 | 36.211921 | 142 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/resample.py | from abc import ABC, abstractmethod
import numpy as np
import torch as th
import torch.distributed as dist
def create_named_schedule_sampler(name, diffusion):
"""
Create a ScheduleSampler from a library of pre-defined samplers.
:param name: the name of the sampler.
:param diffusion: the diffusion ob... | 5,689 | 35.709677 | 87 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/carla_regressor.py | from email.mime import base
import os
from pathlib import Path
import argparse
import numpy as np
import torch as th
from torchvision import transforms
import torchvision
import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
import copy
import wandb
from improved_diffusion.script_util ... | 11,511 | 35.546032 | 132 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/losses.py | """
Helpers for various likelihood-based losses. These are ported from the original
Ho et al. diffusion models codebase:
https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/utils.py
"""
import numpy as np
import torch as th
def normal_kl(mean1, logvar1, mean2, logvar... | 2,534 | 31.5 | 109 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/rng_util.py | import random
import torch as th
import numpy as np
def set_random_seed(seed):
random.seed(seed)
th.manual_seed(seed+1)
th.cuda.manual_seed_all(seed+2)
np.random.seed(seed+3)
def get_random_state():
return {
"python": random.getstate(),
"torch": th.get_rng_state(),
"cuda"... | 1,449 | 20.969697 | 48 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/test_util.py | import os
from filelock import FileLock
from pathlib import Path
import torch as th
import numpy as np
from PIL import Image
import imageio
class Protect(FileLock):
""" Given a file path, this class will create a lock file and prevent race conditions
using a FileLock. The FileLock path is automatically in... | 4,757 | 41.864865 | 162 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/video_datasets.py | import os
import numpy as np
import torch as th
from torch.utils.data import DataLoader, Dataset
from torchvision.transforms import ToTensor
from pathlib import Path
import shutil
from mpi4py import MPI
from .test_util import Protect
video_data_paths_dict = {
"minerl": "datasets/minerl_navigate-torch",
... | 9,109 | 38.267241 | 150 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/sampling_schemes.py | import numpy as np
import torch as th
try:
import lpips
class LpipsEmbedder(lpips.LPIPS):
""" Similar to lpips.LPIPS, but takes a single batch of images and returns an embedding
such that the LPIPS distance between two images is the squared distance between these embeddings.
... | 18,909 | 46.393484 | 224 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/nn.py | """
Various utilities for neural networks.
"""
import math
import torch as th
import torch.nn as nn
# PyTorch 1.7 has SiLU, but we support PyTorch 1.5.
class SiLU(nn.Module):
def forward(self, x):
return x * th.sigmoid(x)
class GroupNorm32(nn.GroupNorm):
def forward(self, x):
return super(... | 5,087 | 28.410405 | 88 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/fp16_util.py | """
Helpers to train with 16-bit precision.
"""
import torch.nn as nn
from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors
def convert_module_to_f16(l):
"""
Convert primitive modules to float16.
"""
if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Conv3d)):
l.weight.data = l.we... | 2,282 | 28.649351 | 114 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/unet.py | from abc import abstractmethod
import math
import numpy as np
import torch as th
import torch.nn as nn
import torch.nn.functional as F
from .fp16_util import convert_module_to_f16, convert_module_to_f32
from .nn import (
SiLU,
conv_nd,
linear,
avg_pool_nd,
zero_module,
normalization,
time... | 18,242 | 36.004057 | 149 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/gaussian_diffusion.py | """
This code started out as a PyTorch port of Ho et al's diffusion models:
https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/diffusion_utils_2.py
Docstrings have been added, as well as DDIM sampling and a new collection of beta schedules.
"""
import enum
import math... | 35,019 | 38.304153 | 129 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/train_util.py | import copy
import functools
import os
import wandb
import blobfile as bf
import glob
from pathlib import Path
from time import time
import numpy as np
import torch as th
import torch.distributed as dist
from torch.nn.parallel.distributed import DistributedDataParallel as DDP
from torch.optim import AdamW
from . impo... | 20,596 | 38.685934 | 129 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/respace.py | import numpy as np
import torch as th
from .gaussian_diffusion import GaussianDiffusion
def space_timesteps(num_timesteps, section_counts):
"""
Create a list of timesteps to use from an original diffusion process,
given the number of timesteps we want to take from equally-sized portions
of the origin... | 4,953 | 38.951613 | 85 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/improved_diffusion/dist_util.py | """
Helpers for distributed training.
"""
import io
import os
import socket
import blobfile as bf
from mpi4py import MPI
import torch as th
import torch.distributed as dist
# Change this to reflect your cluster layout.
# The GPU for a given rank is (rank % GPUS_PER_NODE).
GPUS_PER_NODE = 8
SETUP_RETRY_COUNT = 3
d... | 1,956 | 22.578313 | 77 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/scripts/video_make_mp4.py | import torch as th
import numpy as np
from argparse import ArgumentParser
from pathlib import Path
import uuid
import argparse
import json
from improved_diffusion.video_datasets import get_test_dataset
from improved_diffusion.test_util import mark_as_observed, tensor2gif, tensor2mp4
from improved_diffusion.script_util... | 2,986 | 40.486111 | 137 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/scripts/video_fvd.py | import torch as th
import numpy as np
import argparse
import os
from pathlib import Path
import json
from collections import defaultdict
import tensorflow.compat.v1 as tf
# Metrics
from improved_diffusion.video_datasets import get_test_dataset
import improved_diffusion.frechet_video_distance as fvd
from improved_diffu... | 5,468 | 44.198347 | 134 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/scripts/video_train.py | """
Train a diffusion model on images.
"""
import os
import sys
import argparse
import wandb
import torch.distributed as dist
from improved_diffusion import dist_util
from improved_diffusion.video_datasets import load_data, default_T_dict, default_image_size_dict
from improved_diffusion.resample import create_named_s... | 4,890 | 31.177632 | 122 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/scripts/video_to_world_coords.py | import argparse
from pathlib import Path
import random
import numpy as np
import torch as th
from improved_diffusion.carla_regressor import load_classifier_regressor_like_paper, predict_coords, base_data_transform
from improved_diffusion.test_util import Protect, get_model_results_path, get_eval_run_identifier
if __... | 2,552 | 46.277778 | 134 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/scripts/video_sample.py | """
Generate a large batch of image samples from a model and save them as a large
numpy array. This can be used to produce samples for FID evaluation.
"""
import argparse
from operator import is_
import os
import json
from pathlib import Path
from PIL import Image
import numpy as np
import torch as th
from improved_... | 12,061 | 48.03252 | 230 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/datasets/minerl.py | import tensorflow as tf
import tensorflow_datasets as tfds
import minerl_navigate
import os
import numpy as np
from pathlib import Path
if __name__ == "__main__":
data_dir = Path(os.path.dirname(os.path.abspath(__file__)))
orig_dataset = 'minerl_navigate'
torch_dataset_path = data_dir / f'{orig_dataset}-t... | 804 | 31.2 | 93 | py |
flexible-video-diffusion-modeling | flexible-video-diffusion-modeling-main/datasets/mazes.py | """gqn_mazes dataset."""
"""This implementation is based on https://github.com/saeidnp/cwvae/blob/master/datasets/gqn_mazes/gqn_mazes.py and
https://github.com/iShohei220/torch-gqn/blob/c0156c72f4e63ca6523ab8d9a6f6b3ce9e0e391d/dataset/convert2torch.py"""
import tensorflow as tf
import tensorflow_datasets as tfds
i... | 3,718 | 32.504505 | 450 | py |
dbcsr | dbcsr-master/src/acc/libsmm_acc/predict/predict_train.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
####################################################################################################
# Copyright (C) by the DBCSR developers group - All rights reserved #
# This file is part of the DBCSR library. ... | 60,672 | 34.986358 | 123 | py |
TREMBA | TREMBA-master/DataLoader.py | import torch
import torch.nn as nn
import torchvision.datasets as dset
import torch.utils.data
import torchvision.transforms as transforms
import os
import json
import numpy as np
from torch.utils.data import Dataset, DataLoader
def imagenet(state):
if 'defense' in state and state['defense']:
mean = n... | 1,142 | 29.891892 | 67 | py |
TREMBA | TREMBA-master/attack.py | import argparse
import torchvision.models as models
import os
import json
import DataLoader
from utils import *
from FCN import *
from Normalize import Normalize, Permute
from imagenet_model.Resnet import resnet152_denoise, resnet101_denoise
def EmbedBA(function, encoder, decoder, image, label, config, latent=None):
... | 7,438 | 36.570707 | 185 | py |
TREMBA | TREMBA-master/utils.py | import torch.nn as nn
import torch
import numpy as np
class MarginLoss(nn.Module):
def __init__(self, margin=1.0, target=False):
super(MarginLoss, self).__init__()
self.margin = margin
self.target = target
def forward(self, logits, label):
if not self.target:
one... | 3,786 | 35.413462 | 117 | py |
TREMBA | TREMBA-master/Normalize.py | import torch
import torch.nn as nn
class Normalize(nn.Module):
def __init__(self, mean, std):
super(Normalize, self).__init__()
self.mean = mean
self.std = std
def forward(self, input):
size = input.size()
x = input.clone()
for i in range(size[1]):
... | 606 | 20.678571 | 56 | py |
TREMBA | TREMBA-master/FCN.py | # -*- coding: utf-8 -*-
import torch
import torch.nn as nn
class Imagenet_Encoder(nn.Module):
def __init__(self):
super().__init__()
self.conv1_1 = nn.Sequential(
nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1),
nn.ReLU(inplace=True),
... | 4,477 | 32.924242 | 107 | py |
TREMBA | TREMBA-master/train_generator.py | import argparse
import os
import json
import torch
import torch.nn as nn
import torch.nn.functional as F
from Normalize import Normalize, Permute
import DataLoader
import numpy as np
from FCN import *
from utils import *
import torchvision.models as models
import copy
from imagenet_model.Resnet import *
if __name__ ==... | 5,548 | 36.748299 | 136 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.