version stringclasses 21
values | code stringlengths 225 174k | apis list | full_version stringlengths 1 6 | repo_name stringlengths 10 107 | hexsha stringlengths 40 40 |
|---|---|---|---|---|---|
1.4 | import torch
import numpy as np
from torch import nn
import torch.nn.functional as F
from typing import Any, Dict, List, Type, Union, Optional
from tianshou.policy import PGPolicy
from tianshou.data import Batch, ReplayBuffer, to_torch_as, to_numpy
class A2CPolicy(PGPolicy):
"""Implementation of Synchronous Adva... | [
"torch.no_grad",
"torch.nn.functional.mse_loss"
] | 1.4.0 | Lanxiaozhi/tianshou | 0fa3f4b7a256780448b7dcdbdbeb9daf7944f1d5 |
1.6 | import torch
from dexpression_pytorch.cnn_model.dexpression import Dexpression
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
def initialize():
"""
Loads model parameters into cuda.
Returns
-------
model : object
The convolutional neural network to be trained.
... | [
"torch.cuda.is_available"
] | 1.6.0 | rdgozum/dexpression-pytorch | 6aac1fffee31062afda5fb1403f328d9c2502137 |
1.2 |
# Adopted from
# https://github.com/pytorch/fairseq/blob/master/fairseq/distributed_utils.py
import pickle
import torch
MAX_SIZE_LIMIT = 65533
BYTE_SIZE = 256
def enc_obj2bytes(obj, max_size=4094):
"""
Encode Python objects to PyTorch byte tensors
"""
assert max_size <= MAX_SIZE_LIMIT
byte_tens... | [
"torch.zeros"
] | 1.2 | caodoanh2001/uit-mmf | 60359f6083b89b442c383dc7eee888e7fbf0c65f |
1.0 | # Copyright 2019 The Texar Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable ... | [
"torch.no_grad",
"torch.cuda.is_available",
"torch.tensor",
"torch.load"
] | 1.0.0 | ZhitingHu/texar-pytorch | 72ea115013ced8a5a2b004eacf6271184d3572a8 |
1.5 | # -*- coding: utf-8 -*-
import unittest
from nose.tools import raises
import torch
from kraken.lib import layers
class TestLayers(unittest.TestCase):
"""
Testing custom layer implementations.
"""
def setUp(self):
torch.set_grad_enabled(False)
def test_maxpool(self):
"""
... | [
"torch.randn",
"torch.set_grad_enabled"
] | 1.5.0 | eighttails/kraken | 6e3b7d6e86d673acf5633e6e23292cb82f1a114e |
1.0 | import torch
from os.path import join as oj
import os
def train_epoch(model, device, train_loader, optimizer, epoch, criterion):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
outputs = mode... | [
"torch.no_grad"
] | 1.0 | Yu-Group/adaptive-wavelets | e67f726e741d83c94c3aee3ed97a772db4ce0bb3 |
1.1 | import copy
import pickle
import numpy as np
from skimage import io
from . import kitti_utils
from ...ops.roiaware_pool3d import roiaware_pool3d_utils
from ...utils import box_utils, calibration_kitti, common_utils, object3d_kitti
from ..dataset import DatasetTemplate
import struct
class KittiDataset(DatasetTemplat... | [
"torch.from_numpy"
] | 1.1 | SH-Tan/voxel-rangenet | f2050cd30a8684fd09e561aba004adea978d3d35 |
1.0 | # standard libraries
import numpy as np
import random
import time
from collections import namedtuple, Counter
import operator
import os
from copy import deepcopy
import heapq
# pytorch
import torch
import torch.nn as nn
import torch.optim as optim
# import from other files
from .toric_model import Toric_code
from .tori... | [
"torch.nn.MSELoss",
"torch.save",
"torch.no_grad",
"torch.load",
"torch.Tensor"
] | 1.0.0 | KarlHammar/High-threshold-QEC-toric-RL | 22b14010321ea0e4298aa2640ad7816a7d89f747 |
1.3 | """
Copyright (c) Facebook, Inc. and its affiliates.
This source code is licensed under the MIT license found in the
LICENSE file in the root directory of this source tree.
https://github.com/facebookresearch/fastMRI/blob/master/data/transforms.py
"""
import numpy as np
import torch
def to_tensor(data):
"""
... | [
"torch.rfft",
"torch.cat",
"torch.irfft",
"torch.from_numpy",
"torch.ifft",
"torch.Tensor",
"torch.fft"
] | 1.3 | jnjaby/DISCNet | 63b1859519091f8790afcc47e8c726cbefdcd0fe |
1.7 | import pyforest
import os
import logging
from dataclasses import dataclass, field
from typing import Dict, List, Optional
import sys
import torch
import nlp
from transformers import T5Tokenizer, BartTokenizer, HfArgumentParser
from datasets import list_datasets, load_dataset, list_metrics, load_metric, Dataset
import ... | [
"torch.save"
] | 1.7.1 | Zino-chata/question_gen_v2 | 440fbb4eaccb86232a54287d0890c79a4935e418 |
1.7 | #!/usr/bin/env python3
#PYTHON_ARGCOMPLETE_OK
import enum
import logging
from dataclasses import dataclass, replace
from simple_parsing import Serializable
from typing import Dict, Any
from tqdm.auto import tqdm
import torch as th
from torchvision.transforms import Compose
from torch.utils.tensorboard import SummaryW... | [
"torch.device",
"torch.no_grad",
"torch.autograd.profiler.profile",
"torch.utils.tensorboard.SummaryWriter",
"torch.clip"
] | 1.7.1 | yycho0108/ai604-video-object-pose | 7067f36281038272b0e39166d8f9718076bb6e75 |
1.7 | #!/usr/bin/env python3
import torch as th
import torch.nn as nn
import torch.nn.functional as F
from typing import Dict
from top.data.schema import Schema
from top.model.loss_util import FocalLoss
class ObjectHeatmapLoss(nn.Module):
def __init__(self, key: Schema = Schema.HEATMAP):
super().__init__()
... | [
"torch.round",
"torch.square",
"torch.isfinite",
"torch.nn.L1Loss",
"torch.abs",
"torch.logical_and",
"torch.ones_like",
"torch.as_tensor",
"torch.nn.CrossEntropyLoss",
"torch.sum"
] | 1.7.1 | yycho0108/ai604-video-object-pose | 7067f36281038272b0e39166d8f9718076bb6e75 |
1.8 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import pytorch_lightning as pl
from transformers import pipeline
from torchvision import models
from fairseq.optim.adafactor import Adafactor
class PositionalEncoding(nn.Module):
def __init__(self, d_model, dropout=0.1, max_... | [
"torch.nn.Linear",
"torch.cat",
"torch.stack",
"torch.ones",
"torch.nn.MultiheadAttention",
"torch.nn.LayerNorm",
"torch.FloatTensor",
"torch.zeros",
"torch.cos",
"torch.nn.Sequential",
"torch.nn.functional.l1_loss",
"torch.nn.ReLU",
"torch.nn.TransformerDecoder",
"torch.nn.TransformerEnco... | 1.8.2 | HumaticsLAB/GTM-Transformer | 94124d3246c7c22d8b952beeda53639a9ad170e3 |
1.10 | from typing import Callable, Optional, Tuple, Union
import numpy as np
import torch
import torch.nn as nn
from sklearn.cluster import KMeans
from torch.utils.data.dataloader import DataLoader, default_collate
from tqdm import tqdm
from ptdec.utils import cluster_accuracy, target_distribution
def train(
dataset:... | [
"torch.cat",
"torch.utils.data.dataloader.DataLoader",
"torch.no_grad",
"torch.tensor",
"torch.nn.KLDivLoss"
] | 1.10.1 | wingkitlee0/pt-dec | 087b6231ea52422d827bf446b2ecf755ae9a6679 |
1.0 | import argparse
import itertools
import os
from abc import ABCMeta, abstractmethod
import torch
import torch.nn as nn
from six import add_metaclass
from torch.nn import functional
from torchvision.utils import save_image
import pyro
from pyro.contrib.examples import util
from pyro.distributions import Bernoulli, Norm... | [
"torch.nn.Linear",
"torch.no_grad",
"torch.optim.Adam",
"torch.nn.ReLU"
] | 1.0.0 | hesenp/pyro | 0c49858ab8c5f263d1ece7f212180c8ccd8da370 |
1.4 | #!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
__version__ = "0.1.0"
import copy
import warnings
import crypten.common
import crypten.communicator as comm
import c... | [
"torch.device",
"torch.is_tensor",
"torch.Generator",
"torch.cuda.is_available",
"torch.LongTensor"
] | 1.4.0 | marksibrahim/CrypTen | 4e5b13487d7f6ceaa4f06e86f0b260e0761960fd |
1.4 | #!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import sys
import unittest
import crypten
import torch
from crypten.common.util import chebyshev_series
from crypten.... | [
"torch.zeros",
"torch.tensor",
"torch.LongTensor",
"torch.Size"
] | 1.4.0 | marksibrahim/CrypTen | 4e5b13487d7f6ceaa4f06e86f0b260e0761960fd |
1.2 | from typing import Tuple, Dict, Optional
from overrides import overrides
import torch
from torch.nn import LSTMCell
from allennlp.modules import Attention
from allennlp.modules.seq2seq_decoders.decoder_net import DecoderNet
from allennlp.nn import util
@DecoderNet.register("lstm_cell")
class LstmCellDecoderNet(Deco... | [
"torch.cat",
"torch.nn.LSTMCell"
] | 1.2.0 | nadgeri14/allennlp | 2eefffaf71612263a1c20e8ce4107849cfd5efe3 |
1.2 | from typing import Dict, Optional, List, Any
import torch
from allennlp.common.checks import check_dimensions_match
from allennlp.data import TextFieldTensors, Vocabulary
from allennlp.models.model import Model
from allennlp.modules import FeedForward
from allennlp.modules import Seq2SeqEncoder, SimilarityFunction, T... | [
"torch.cat",
"torch.nn.CrossEntropyLoss",
"torch.nn.functional.softmax"
] | 1.2.0 | nadgeri14/allennlp | 2eefffaf71612263a1c20e8ce4107849cfd5efe3 |
1.2 | import os
import sys
import argparse
import torch
sys.path.insert(0, os.path.dirname(os.path.abspath(os.path.join(__file__, os.pardir))))
from allennlp.common.tqdm import Tqdm
from allennlp.common import Params
from allennlp.models.archival import load_archive
from allennlp.data.iterators import BasicIterator
from ... | [
"torch.autograd.no_grad"
] | 1.2.0 | nadgeri14/allennlp | 2eefffaf71612263a1c20e8ce4107849cfd5efe3 |
1.2 | from typing import Dict, Optional, List, Set, Tuple, Union
import pytest
import torch
from allennlp.common import Params
from allennlp.common.from_params import FromParams, takes_arg, remove_optional, create_kwargs
from allennlp.common.testing import AllenNlpTestCase
from allennlp.data import DatasetReader, Tokenizer... | [
"torch.all"
] | 1.2.0 | nadgeri14/allennlp | 2eefffaf71612263a1c20e8ce4107849cfd5efe3 |
1.4 | from typing import Any, Dict, Optional, Sequence, Tuple, Union
import numpy as np
import torch
import torch.nn.functional as F
from torch import nn
from tianshou.data import Batch, to_torch
from tianshou.utils.net.common import MLP
class Actor(nn.Module):
"""Simple actor network.
Will create an actor opera... | [
"torch.nn.Linear",
"torch.rand",
"torch.cat",
"torch.nn.functional.one_hot",
"torch.arange",
"torch.nn.init.constant_",
"torch.FloatTensor",
"torch.no_grad",
"torch.nn.init.xavier_uniform_",
"torch.nn.ReLU",
"torch.nn.functional.mse_loss",
"torch.nn.functional.linear",
"torch.nn.functional.s... | 1.4.0 | dumpmemory/tianshou | bc53ead273f6f9d3788a78ecc739249eeb96b8c6 |
1.2 | import pytest
import torch
from capreolus.reranker.POSITDRMM import POSITDRMM
from capreolus.reranker.KNRM import KNRM
def test_validate_params_for_knrm():
with pytest.raises(ValueError):
KNRM.validate_params({"foo": "bar"})
with pytest.raises(ValueError):
KNRM.validate_params({"pad_token": ... | [
"torch.tensor",
"torch.eq"
] | 1.2.0 | bpiwowar/capreolus-xpm | 5374eb48df96b54d51365fc32441ae50a3e634c2 |
1.0 |
import json
from overrides import overrides
import torch
import random
from claf.config.factory.data_loader import make_data_loader
from claf.data.dataset.base import DatasetBase
class MultiTaskBertDataset(DatasetBase):
"""
Dataset for Multi-Task GLUE using BERT
* Args:
batch: Batch DTO (claf.d... | [
"torch.cuda.is_available"
] | 1.0.1 | GMDennis/claf | d1e064e593127e5d654f000f5506c5ae1caab5ce |
3 | # Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
import random
import unittest
import numpy as np
import torch
from common_testing import TestCaseMixin
from pytorch3d.structures.meshes import Meshes
class TestMeshes(TestCaseMixin, unittest.TestCase):
def setUp(self) -> None:
np.ra... | [
"torch.cat",
"torch.stack",
"torch.eye",
"torch.allclose",
"torch.is_tensor",
"torch.manual_seed",
"torch.randint",
"torch.tensor",
"torch.zeros",
"torch.device",
"torch.min",
"torch.max",
"torch.full",
"torch.cumsum",
"torch.rand",
"torch.cuda.synchronize"
] | 3 | rahulvenkk/pytorch3d | 68bfac3394f9a87fb268165d1c9dd264e1d9316b |
3 | # Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
import math
import warnings
from typing import List, Optional, Union
import torch
from .rotation_conversions import _axis_angle_rotation
class Transform3d:
"""
A Transform3d object encapsulates a batch of N 3D transformations, and know... | [
"torch.diag_embed",
"torch.device",
"torch.cat",
"torch.stack",
"torch.is_tensor",
"torch.inverse",
"torch.ones",
"torch.det",
"torch.eye",
"torch.tensor",
"torch.ones_like"
] | 3 | rahulvenkk/pytorch3d | 68bfac3394f9a87fb268165d1c9dd264e1d9316b |
1.8 | import torch
import torch.nn as nn
model_urls = {
'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
'resnet101': 'https://download.pyt... | [
"torch.nn.Linear",
"torch.nn.init.constant_",
"torch.nn.Sequential",
"torch.nn.MaxPool3d",
"torch.nn.init.kaiming_normal_",
"torch.nn.ReLU",
"torch.nn.Conv3d",
"torch.flatten",
"torch.nn.AdaptiveAvgPool3d"
] | 1.8.0 | FredrikM97/Medical-ROI | 54246341460c04caeced2ef6dcab984f6c260c9d |
1.3 | from datetime import datetime as dt, timedelta
import numpy as np
import os
import torch
from torch.nn import MSELoss
from torch.optim import LBFGS, Adam
from adabelief_pytorch import AdaBelief
from torch_cpo_utils import *
# from cpo_torch import CPO
from buffer_torch import *
from models_torch import MLP_DiagGaussi... | [
"torch.zeros",
"torch.cat",
"torch.sqrt",
"torch.nn.MSELoss",
"torch.arange",
"torch.save",
"torch.no_grad",
"torch.unsqueeze",
"torch.sum",
"torch.pow",
"torch.tensor",
"torch.load",
"torch.matmul",
"torch.mean",
"torch.cumsum"
] | 1.3.0 | feloundou/research-project | fe7f5414901f02ae24ef33af31e65782d8511da1 |
1.0 | # The code here is based on the code at
# https://github.com/gpleiss/temperature_scaling/blob/master/temperature_scaling.py
import torch
from torch import nn, optim
from torch.nn import functional as F
from torch.autograd import Variable
import numpy as np
def logits_from_probs(prob_arr):
return np.log(prob_arr)
... | [
"torch.ones",
"torch.from_numpy",
"torch.nn.functional.softmax",
"torch.log",
"torch.optim.LBFGS",
"torch.nn.CrossEntropyLoss"
] | 1.0.0 | probabilisticdeeplearning/swa_gaussian | 033f2b956e98f7050793a0d8a4155feb98931a3d |
1.5 | import argparse
from collections import Counter
import os
from loguru import logger
import torch
from torch import nn
from torch.utils.data import DataLoader, DistributedSampler
from torch.utils.tensorboard import SummaryWriter
from virtex.config import Config
from virtex.factories import (
DownstreamDatasetFacto... | [
"torch.nn.Linear",
"torch.device",
"torch.utils.tensorboard.SummaryWriter",
"torch.nn.init.constant_",
"torch.nn.parallel.DistributedDataParallel",
"torch.set_grad_enabled",
"torch.cuda.current_device",
"torch.nn.init.normal_",
"torch.tensor",
"torch.load",
"torch.nn.CrossEntropyLoss"
] | 1.5.0 | tongyao-zhu/virtex | 43b33289ffc963b41b6b98affc5e94dfe25e29c8 |
0.4 | import torch
import torch.nn as nn
import torch.nn.utils.rnn as rnn_utils
from utils import to_var
class SentenceVAE(nn.Module):
def __init__(self, vocab_size, embedding_size, rnn_type, hidden_size, word_dropout, embedding_dropout, latent_size,
sos_idx, eos_idx, pad_idx, unk_idx, max_sequence_le... | [
"torch.nn.Linear",
"torch.nn.Embedding",
"torch.nn.Dropout",
"torch.randn",
"torch.cuda.is_available",
"torch.nn.utils.rnn.pad_packed_sequence",
"torch.Tensor",
"torch.exp",
"torch.sort",
"torch.topk"
] | 0.4.1 | oscarvik/Language-Modelling-CSE291-AS2 | 18af16de61cbe8d820b1445207107b4ea4771680 |
1.7 | from typing import Tuple
import torch
from torch import nn
from torch.nn import functional as F
from utils import Tensor, assert_shape, build_grid, conv_transpose_out_shape
class SlotAttention(nn.Module):
"""Slot attention module that iteratively performs cross-attention.
Args:
slot_agnostic (bool)... | [
"torch.nn.Linear",
"torch.nn.LeakyReLU",
"torch.sum",
"torch.nn.LayerNorm",
"torch.nn.ConvTranspose2d",
"torch.manual_seed",
"torch.nn.init.calculate_gain",
"torch.zeros",
"torch.cuda.manual_seed_all",
"torch.nn.Sequential",
"torch.nn.ReLU",
"torch.cuda.empty_cache",
"torch.nn.Conv2d",
"to... | 1.7.1 | jiaqi-xi/slot_attention | 8420414eb261501e5b056e4d409c338d909397ef |
1.4 | import torch
import numpy as np
from copy import deepcopy
from typing import Any, Dict, Tuple, Optional
from tianshou.policy import DDPGPolicy
from tianshou.data import Batch, ReplayBuffer
from tianshou.exploration import BaseNoise, GaussianNoise
class TD3Policy(DDPGPolicy):
"""Implementation of TD3, arXiv:1802.... | [
"torch.randn"
] | 1.4.0 | cm107/tianshou | 0febf4bc1dc1366d837bab4574664f8116b66819 |
1.8 | # Copyright (c) Facebook, Inc. and its affiliates.
# All rights reserved.
#
# This source code is licensed under the license found in the
# LICENSE file in the root directory of this source tree.
"""Represents a model repository, including pre-trained models and bags of models.
A repo can either be the main remote repo... | [
"torch.hub.load_state_dict_from_url"
] | 1.8.1 | sparshpriyadarshi/demucs | 7c7f65401db654d750df2b6f4d5b82a0101500b1 |
1.4 | import torch
import torch.nn.functional as F
from torch import nn
from torch_geometric.nn import GCNConv
from . import graph_embed
class Net(torch.nn.Module):
"""docstring for Net"""
def __init__(self, cfg, config=None, PRINT_DEBUG=False):
super(Net, self).__init__()
input_size = cfg.SCENE_GRA... | [
"torch.zeros",
"torch.nn.functional.dropout",
"torch.cat"
] | 1.4.0 | roy860328/VSGM | 3ec19f9cf1401cecf45527687936b8fe4167f672 |
1.4 | import matplotlib
matplotlib.use('Agg')
import os
import sys
sys.path.append(os.path.join(os.environ['ALFRED_ROOT']))
sys.path.append(os.path.join(os.environ['ALFRED_ROOT'], 'gen'))
sys.path.append(os.path.join(os.environ['ALFRED_ROOT'], 'models'))
sys.path.append(os.path.join(os.environ['ALFWORLD_ROOT'], 'agents'))
im... | [
"torch.multiprocessing.Manager",
"torch.multiprocessing.set_start_method"
] | 1.4.0 | roy860328/VSGM | 3ec19f9cf1401cecf45527687936b8fe4167f672 |
1.10 | from typing import *
import torch.nn as nn
import torch.optim as optim
from models.LitBase import LitBase
from .models import AlexNet
class LitAlexNet(LitBase):
def __init__(self, args: Dict[str, Any]):
super().__init__()
self.save_hyperparameters(args)
self.model = AlexNet(
... | [
"torch.optim.lr_scheduler.ReduceLROnPlateau",
"torch.nn.CrossEntropyLoss"
] | 1.10.1 | zkdlfrlwl2/Classification-For-Everyone | a99428080ef470a3270d3f4a6048df197216a050 |
0.4 | import os
import numpy as np
import mgplvm
import torch
from mgplvm import kernels, rdist
from mgplvm.manifolds import Torus, Euclid, So3
from mgplvm.models import Core
from mgplvm.training import train
import matplotlib.pyplot as plt
import pickle
from scipy.stats import ttest_1samp
torch.set_default_dtype(torch.float... | [
"torch.get_default_dtype",
"torch.nn.Parameter",
"torch.cuda.empty_cache",
"torch.load",
"torch.set_default_dtype"
] | 0.4.1 | rkj26/mgplvm-pytorch | 7d082d92be4d82ae8ab978e774ce83429444c14b |
1.7 | import torch
import torch.nn as nn
from torch.nn import init
from torch.nn import utils
import torch.nn.functional as F
import functools
from torch.optim import lr_scheduler
###############################################################################
# Helper Functions
#############################################... | [
"torch.nn.Linear",
"torch.cat",
"torch.optim.lr_scheduler.StepLR",
"torch.optim.lr_scheduler.CosineAnnealingLR",
"torch.nn.LeakyReLU",
"torch.nn.init.kaiming_normal_",
"torch.cuda.is_available",
"torch.exp",
"torch.nn.DataParallel",
"torch.sum",
"torch.nn.init.constant_",
"torch.nn.ConvTranspo... | 1.7.1 | zhoufengfan/MMT-plus | e95db1452d3480518a851dd7ffa07208522f2614 |
1.1 | import logging
import os
import random
import subprocess
import numpy as np
import torch
import torch.distributed as dist
import torch.multiprocessing as mp
from mmcv.runner import get_dist_info
def init_dist(launcher, backend='nccl', **kwargs):
if mp.get_start_method(allow_none=True) is None:
mp.set_sta... | [
"torch.cuda.manual_seed_all",
"torch.distributed.init_process_group",
"torch.multiprocessing.set_start_method",
"torch.multiprocessing.get_start_method",
"torch.cuda.device_count",
"torch.manual_seed",
"torch.cuda.set_device"
] | 1.1 | dingmyu/mmdetection | 705dc91ca43ea62f4f69355a81271d5bd81268ca |
1.8 | from copy import deepcopy
import torch
from torch import nn
from onnx2torch.node_converters.registry import add_converter
from onnx2torch.onnx_graph import OnnxGraph
from onnx2torch.onnx_node import OnnxNode
from onnx2torch.utils.common import OnnxToTorchModule
from onnx2torch.utils.common import OperationConverterRe... | [
"torch.reshape",
"torch.arange",
"torch.scatter",
"torch.zeros_like",
"torch.flip",
"torch.cumsum"
] | 1.8.0 | ENOT-AutoDL/onnx2torch | 2391987b3349bed1670ac3c1bc9062a37323abe3 |
1.10 | # pylint: disable-all
import argparse
from animus import EarlyStoppingCallback, IExperiment
from animus.torch.callbacks import TorchCheckpointerCallback
from apto.utils.report import get_classification_report
from catalyst import utils
import numpy as np
import optuna
from sklearn.model_selection import train_test_spl... | [
"torch.nn.Linear",
"torch.nn.Dropout",
"torch.nn.LayerNorm",
"torch.nn.Sequential",
"torch.set_grad_enabled",
"torch.softmax",
"torch.nn.ReLU",
"torch.tensor",
"torch.utils.data.DataLoader",
"torch.nn.CrossEntropyLoss"
] | 1.10.0 | paavalipopov/introspection | ee486a9e8c8b6ddb7ab257eae9e14aac5d637527 |
1.3 | """GaussianMLPModule."""
import abc
import torch
from torch import nn
from torch.distributions import Normal
from torch.distributions.independent import Independent
from garage.torch.distributions import TanhNormal
from garage.torch.modules.mlp_module import MLPModule
from garage.torch.modules.multi_headed_mlp_module... | [
"torch.zeros",
"torch.distributions.independent.Independent",
"torch.Tensor",
"torch.nn.Parameter"
] | 1.3.0 | igor-krawczuk/garage | aa86ce710c6d01380477d6feddc0e38427b1e3b4 |
0.4 | """
A ``TextField`` represents a string of text, the kind that you might want to represent with
standard word vectors, or pass through an LSTM.
"""
import IPython as ipy
from typing import Dict, List, Optional, Iterator
import textwrap
from overrides import overrides
from spacy.tokens import Token as SpacyToken
impor... | [
"torch.LongTensor"
] | 0.4.1 | pmulcaire/rosita | fffe45fb450d79cf36e0a3e2625300dc95249367 |
1.7 | """
BSD 3-Clause License
Copyright (c) 2018, NVIDIA Corporation
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of c... | [
"torch.arange",
"torch.max",
"torch.autograd.Variable",
"torch.cuda.is_available",
"torch.tensor",
"torch.empty"
] | 1.7.1 | NoVarlok/sova-tts-engine | 1b7c0b3591bb7f823be648093de279881e194d05 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.