Dragon - C++ API
A Computation Graph Virtual Machine Based Deep Learning Framework
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
dragon Namespace Reference

Namespaces

 cast
 
 kernel
 
 math
 
 onnx
 
 python
 
 rcnn
 
 str
 
 utils
 

Classes

struct  __attribute__
 
class  AccumulateOp
 
class  AccuracyOp
 
class  AdamUpdateOp
 
class  AffineGradientOp
 
class  AffineOp
 
class  ArangeOp
 
class  ArgReduceOp
 
class  AssignOp
 
class  BaseThread
 
class  BatchNormGradientOp
 
class  BatchNormOp
 
class  BiasAddGradientOp
 
class  BiasAddOp
 
class  BilinearResizeGradientOp
 
class  BilinearResizeOp
 
class  CastGradientOp
 
class  CastOp
 
class  ChannelShuffleGradientOp
 
class  ChannelShuffleOp
 
class  ClipGradientOp
 
class  ClipOp
 
class  CNMLContext
 
class  CollectiveUpdateOp
 
class  CompareOp
 
class  ConcatGradientOp
 
class  ConcatOp
 
class  ConstantFiller
 
class  Conv2dGradientOp
 
class  Conv2dOp
 
class  ConvOpBase
 
class  ConvTranspose2dGradientOp
 
class  ConvTranspose2dOp
 
class  CopyOp
 
class  CPUContext
 
class  CropGradientOp
 
class  CropOp
 
class  CTCLossGradientOp
 
class  CTCLossOp
 
class  CUDAContext
 
class  CUDADeviceGuard
 
struct  CUDADeviceProps
 
class  CUDAObject
 
class  CuDNNBiasAddGradientOp
 
class  CuDNNBiasAddOp
 
class  CuDNNConv2dGradientOp
 
class  CuDNNConv2dOp
 
class  CuDNNConvTranspose2dGradientOp
 
class  CuDNNConvTranspose2dOp
 
class  CuDNNDepthwiseConv2dGradientOp
 
class  CuDNNDepthwiseConv2dOp
 
class  CuDNNLRNGradientOp
 
class  CuDNNLRNOp
 
class  CuDNNPool2dGradientOp
 
class  CuDNNPool2dOp
 
class  CuDNNReluGradientOp
 
class  CuDNNReluOp
 
class  CuDNNSigmoidGradientOp
 
class  CuDNNSigmoidOp
 
class  CuDNNSoftmaxGradientOp
 
class  CuDNNSoftmaxOp
 
class  CuDNNTanhGradientOp
 
class  CuDNNTanhOp
 
class  CuDNNType
 
class  CuDNNType< double >
 
class  CuDNNType< float >
 
class  CuDNNType< float16 >
 
class  DepthwiseConv2dGradientOp
 
class  DepthwiseConv2dOp
 
class  Device
 
class  DimGradientOpBase
 
class  DimOpBase
 
struct  DispatchHelper
 
class  DotGradientOp
 
class  DotOp
 
class  DropBlock2dGradientOp
 
class  DropBlock2dOp
 
class  DropoutGradientOp
 
class  DropoutOp
 
class  DropPathGradientOp
 
class  DropPathOp
 
class  EltwiseGradientOp
 
class  EltwiseOp
 
class  EluGradientOp
 
class  EluOp
 
class  ExpandDimsOp
 
class  ExpGradientOp
 
class  ExpOp
 
class  Filler
 
class  FillOp
 
class  FlattenOp
 
class  FullyConnectedGradientOp
 
class  FullyConnectedOp
 
class  GivenTensorFillOp
 
class  GlorotNormalOp
 
class  GlorotUniformOp
 
struct  Gradient
 
class  GradientAddOp
 
class  GradientGatherOp
 
class  GradientGenerateOp
 
class  GradientMakerBase
 
class  GramMatrixGradientOp
 
class  GramMatrixOp
 
class  Graph
 
class  GraphBase
 
class  GraphGradientMaker
 
class  GraphOptimizer
 
class  GroupNormGradientOp
 
class  GroupNormOp
 
class  ImageDataOp
 
class  IndexSelectGradientOp
 
class  IndexSelectOp
 
class  InitializeOp
 
class  InterruptionPoint
 
class  L1LossGradientOp
 
class  L1LossOp
 
class  L2LossGradientOp
 
class  L2LossOp
 
class  L2NormGradientOp
 
class  L2NormOp
 
class  LogGradientOp
 
class  LogOp
 
class  LRNGradientOp
 
class  LRNOp
 
class  LSTMCellGradientOp
 
class  LSTMCellOp
 
class  MaskedAssignOp
 
class  MaskedSelectGradientOp
 
class  MaskedSelectOp
 
class  MatmulGradientOp
 
class  MatmulOp
 
class  MaximumGradientOp
 
class  MaximumOp
 
class  MessageLogger
 
class  MinimumGradientOp
 
class  MinimumOp
 
class  MixedMemory
 
class  MomentsOp
 
class  MPIBroadcastGradientOp
 
class  MPIBroadcastOp
 
class  MPIGatherGradientOp
 
class  MPIGatherOp
 
class  MPIOpBase
 
class  MSRAFiller
 
class  MultinomialOp
 
class  NesterovUpdateOp
 
class  NLLLossGradientOp
 
class  NLLLossOp
 
class  NNResizeGradientOp
 
class  NNResizeOp
 
class  NoGradient
 
class  NonZeroOp
 
class  NormalFiller
 
class  OneHotOp
 
class  Operator
 
class  OperatorBase
 
class  OpSchema
 
class  OpSchemaRegistry
 
class  PadGradientOp
 
class  PadOp
 
class  Pool2dGradientOp
 
class  Pool2dOp
 
class  PowGradientOp
 
class  PowOp
 
class  PReluGradientOp
 
class  PReluOp
 
class  ProposalOp
 
class  RandomNormalOp
 
class  RandomUniformOp
 
class  RecurrentGradientOp
 
class  RecurrentOp
 
class  ReduceGradientOp
 
class  ReduceOp
 
class  Registerer
 
class  Registry
 
class  ReluGradientOp
 
class  ReluOp
 
class  RepeatGradientOp
 
class  RepeatOp
 
class  ReshapeOp
 
class  RMSPropUpdateOp
 
class  RNNParamSetOp
 
class  ROIAlignGradientOp
 
class  ROIAlignOp
 
class  ROIPoolGradientOp
 
class  ROIPoolOp
 
class  SEluGradientOp
 
class  SEluOp
 
class  SGDUpdateOp
 
class  ShapeOp
 
class  SigmoidCrossEntropyGradientOp
 
class  SigmoidCrossEntropyOp
 
class  SigmoidFocalLossGradientOp
 
class  SigmoidFocalLossOp
 
class  SigmoidGradientOp
 
class  SigmoidOp
 
class  SliceGradientOp
 
class  SliceOp
 
class  SmoothL1LossGradientOp
 
class  SmoothL1LossOp
 
class  SoftmaxCrossEntropyGradientOp
 
class  SoftmaxCrossEntropyOp
 
class  SoftmaxFocalLossGradientOp
 
class  SoftmaxFocalLossOp
 
class  SoftmaxGradientOp
 
class  SoftmaxOp
 
class  SparseSoftmaxCrossEntropyGradientOp
 
class  SparseSoftmaxCrossEntropyOp
 
class  SqrtGradientOp
 
class  SqrtOp
 
class  SquareGradientOp
 
class  SquareOp
 
class  SqueezeOp
 
class  StackGradientOp
 
class  StackOp
 
class  StopGradientOp
 
class  TanhGradientOp
 
class  TanhOp
 
class  Tensor
 
struct  TensorTypes
 
struct  thread_interrupted
 
class  TileGradientOp
 
class  TileOp
 
class  TransposeGradientOp
 
class  TransposeOp
 
class  TruncatedNormalFiller
 
class  TruncatedNormalOp
 
class  TypeMeta
 
class  UniformFiller
 
class  UpdateOpBase
 
class  WhereGradientOp
 
class  WhereOp
 
class  Workspace
 
class  XavierFiller
 

Typedefs

template<typename Key , typename Value >
using Map = std::unordered_map< Key, Value >
 
template<typename Value >
using Set = std::unordered_set< Value >
 
typedef intptr_t TypeId
 
typedef std::vector< int > vec32_t
 
typedef std::vector< int64_t > vec64_t
 
template<typename T >
using BlockReduce = cub::BlockReduce< T, CUDA_THREADS >
 
template<typename T >
using EigenVectorMap = Eigen::Map< Eigen::Matrix< T, Eigen::Dynamic, 1 > >
 
template<typename T >
using ConstEigenVectorMap = Eigen::Map< const Eigen::Matrix< T, Eigen::Dynamic, 1 > >
 
template<typename T >
using EigenMatrixMap = Eigen::Map< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > >
 
template<typename T >
using ConstEigenMatrixMap = Eigen::Map< const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > >
 
template<typename T >
using EigenVectorArrayMap = Eigen::Map< Eigen::Array< T, Eigen::Dynamic, 1 > >
 
template<typename T >
using ConstEigenVectorArrayMap = Eigen::Map< const Eigen::Array< T, Eigen::Dynamic, 1 > >
 
template<typename T >
using EigenArrayMap = Eigen::Map< Eigen::Array< T, Eigen::Dynamic, Eigen::Dynamic > >
 
template<typename T >
using ConstEigenArrayMap = Eigen::Map< const Eigen::Array< T, Eigen::Dynamic, Eigen::Dynamic > >
 
typedef enum dragon::CBLAS_TRANSPOSE CBLAS_TRANSPOSE
 
typedef struct float16 * float16_t
 
typedef struct GraphDef * GraphDef_t
 
typedef struct WorkspaceWorkspace_t
 

Enumerations

enum  StorageOrder { NCHW, NHWC }
 
enum  LRNMode { ACROSS_CHANNELS, WITHIN_CHANNEL }
 
enum  LogSeverity {
  DEBUG, INFO, WARNING, ERROR,
  FATAL
}
 
enum  CBLAS_TRANSPOSE { CblasNoTrans, CblasTrans }
 

Functions

GraphBaseNewGraph (const GraphDef &def, Workspace *ws)
 Create a graph from the raw def. More...
 
 DECLARE_REGISTRY (GraphRegistry, GraphBase, const GraphDef &, Workspace *)
 
OperatorBaseNewOperator (const OperatorDef &def, Workspace *ws)
 New a operator from the raw def. More...
 
 DECLARE_REGISTRY (CPUOperatorRegistry, OperatorBase, const OperatorDef &, Workspace *)
 
 DECLARE_REGISTRY (CUDAOperatorRegistry, OperatorBase, const OperatorDef &, Workspace *)
 
 DECLARE_REGISTRY (CUDNNOperatorRegistry, OperatorBase, const OperatorDef &, Workspace *)
 
 DECLARE_REGISTRY (CNMLOperatorRegistry, OperatorBase, const OperatorDef &, Workspace *)
 
 DEFINE_TENSOR_TYPES_DISPATCHER (TensorTypes, RunImpl)
 
Gradient MakeGradientForOp (const OperatorDef &op_def, const vector< string > &g_outputs)
 
 DECLARE_REGISTRY (GradientRegistry, GradientMakerBase, const OperatorDef &, const vector< string > &)
 
 DECLARE_REGISTRY (NoGradientRegistry, GradientMakerBase, const OperatorDef &, const vector< string > &)
 
const TypeMetaTypeStringToMeta (const std::string &str_type)
 
const std::string TypeMetaToString (const TypeMeta &meta)
 
template<typename T >
const std::string TypeToString ()
 
 DEFINE_ARG_WITH_DESC (float, DropoutOp, prob)
 
 DEFINE_ARG_WITH_DESC (float, DropoutGradientOp, prob)
 
 DEFINE_ARG_WITH_DESC (float, DropPathOp, prob)
 
 DECLARE_FUNDAMENTAL_OP (Add)
 
 DECLARE_FUNDAMENTAL_OP (Sub)
 
 DECLARE_FUNDAMENTAL_OP (Mul)
 
 DECLARE_FUNDAMENTAL_OP (Div)
 
 DECLARE_FUNDAMENTAL_OP (RAdd)
 
 DECLARE_FUNDAMENTAL_OP (RSub)
 
 DECLARE_FUNDAMENTAL_OP (RMul)
 
 DECLARE_FUNDAMENTAL_OP (RDiv)
 
 DECLARE_FUNDAMENTAL_OP (AddGradient)
 
 DECLARE_FUNDAMENTAL_OP (SubGradient)
 
 DECLARE_FUNDAMENTAL_OP (MulGradient)
 
 DECLARE_FUNDAMENTAL_OP (DivGradient)
 
 DECLARE_FUNDAMENTAL_OP (RAddGradient)
 
 DECLARE_FUNDAMENTAL_OP (RSubGradient)
 
 DECLARE_FUNDAMENTAL_OP (RMulGradient)
 
 DECLARE_FUNDAMENTAL_OP (RDivGradient)
 
 DEFINE_ARG_WITH_DESC (int64_t, ArangeOp, start)
 
 DEFINE_ARG_WITH_DESC (int64_t, ArangeOp, stop)
 
 DEFINE_ARG_WITH_DESC (int64_t, ArangeOp, step)
 
 DEFINE_ARGS_WITH_DESC (int64_t, CropOp, starts)
 
 DEFINE_ARGS_WITH_DESC (int64_t, CropOp, sizes)
 
 DEFINE_DIMENSION_GRADIENT_OP (Reshape)
 
 DEFINE_ARGS_WITH_DESC (int64_t, ReshapeOp, dims)
 
 DEFINE_DIMENSION_GRADIENT_OP (Flatten)
 
 DEFINE_DIMENSION_GRADIENT_OP (ExpandDims)
 
 DEFINE_DIMENSION_GRADIENT_OP (Squeeze)
 
 DEFINE_ARG_WITH_DESC (int64_t, RepeatOp, repeats)
 
 DEFINE_ARG_WITH_DESC (int64_t, RepeatGradientOp, repeats)
 
 DEFINE_ARGS_WITH_DESC (int64_t, TileOp, multiples)
 
 DEFINE_ARGS_WITH_DESC (int64_t, TileGradientOp, multiples)
 
 DEFINE_ARGS_WITH_DESC (int64_t, TransposeOp, perm)
 
 DEFINE_ARGS_WITH_DESC (int64_t, TransposeGradientOp, perm)
 
 DEFINE_ARGS_WITH_DESC (int64_t, AssignOp, starts)
 
 DEFINE_ARGS_WITH_DESC (int64_t, AssignOp, sizes)
 
 DEFINE_ARGS_WITH_DESC (int64_t, InitializeOp, dims)
 
 DEFINE_ARGS_WITH_DESC (int64_t, FillOp, dims)
 
 DEFINE_ARGS_WITH_DESC (int64_t, GivenTensorFillOp, dims)
 
 DEFINE_ARGS_WITH_DESC (int64_t, BilinearResizeOp, dsize)
 
 DEFINE_ARGS_WITH_DESC (int64_t, ConvOpBase, output_shape)
 
 DEFINE_ARGS_WITH_DESC (int64_t, ConvOpBase, output_padding)
 
 DEFINE_ARG_WITH_DESC (float, DropBlock2dOp, keep_prob)
 
 DEFINE_ARGS_WITH_DESC (int64_t, NNResizeOp, dsize)
 
void LoadCaffeModel (string file, Workspace *ws)
 
void SavaCaffeModel (string file, const vector< Tensor * > &tensors)
 
int CUDA_BLOCKS (const int N)
 
int CUDA_2D_BLOCKS (const int N)
 
int CUDA_NUM_DEVICES ()
 
int CUDA_GET_DEVICE ()
 
const cudaDeviceProp & GetCUDADeviceProp (int device_id)
 
bool CUDA_TRUE_FP16_AVAILABLE ()
 
bool TENSOR_CORE_AVAILABLE ()
 
void CuDNNCreateTensorDesc (cudnnTensorDescriptor_t *desc)
 
void CuDNNDestroyTensorDesc (cudnnTensorDescriptor_t *desc)
 
template<typename T >
void CuDNNSetTensorDesc (cudnnTensorDescriptor_t *desc, Tensor *tensor)
 
template<typename T >
void CuDNNSetTensor4dDesc (cudnnTensorDescriptor_t *desc, const string &data_format, Tensor *tensor)
 
template<typename T >
void CuDNNSetTensor5dDesc (cudnnTensorDescriptor_t *desc, const string &data_format, Tensor *tensor)
 
template<typename T >
void CuDNNSetTensor3dDesc (cudnnTensorDescriptor_t *desc, const string &data_format, Tensor *tensor)
 
template<typename T >
void CuDNNSetTensorDesc (cudnnTensorDescriptor_t *desc, const vec64_t &dims)
 
template<typename T >
void CuDNNSetTensor4dDesc (cudnnTensorDescriptor_t *desc, const string &data_format, const vec64_t &dims)
 
template<typename T >
void CuDNNSetTensor4dDescWithGroup (cudnnTensorDescriptor_t *desc, const string &data_format, const vec64_t &dims, const int64_t group)
 
template<typename T >
void CuDNNSetTensor5dDesc (cudnnTensorDescriptor_t *desc, const string &data_format, const vec64_t &dims)
 
template<typename T >
void CuDNNSetTensor3dDesc (cudnnTensorDescriptor_t *desc, const string &data_format, const vec64_t &dims)
 
template<typename T >
void CuDNNSetTensorDesc (cudnnTensorDescriptor_t *desc, const vec64_t &dims, const vec64_t &strides)
 
template<typename T , class Context >
Filler< T, Context > * CreateFiller (const TensorFillerProto &proto)
 
LogSeverity StrToLogSeverity (std::string level)
 
std::string SeverityToStr (LogSeverity severity)
 
void SetLogDestination (LogSeverity type)
 
int EveryNRegister (const char *file, int line, int severity, int n)
 
template<class Map , typename Key = typename Map::key_type, typename Value = typename Map::mapped_type>
Map::mapped_type get_default (const Map &map, const Key &key, Value &&dflt)
 
template<class IterableInputs , class IterableOutputs , class IterableArgs >
OperatorDef MakeOperatorDef (const string &type, const string &name, const IterableInputs &inputs, const IterableOutputs &outputs, const IterableArgs &args, const DeviceOption &device_option)
 
template<class IterableInputs , class IterableOutputs , class IterableArgs >
OperatorDef MakeOperatorDef (const string &type, const string &name, const IterableInputs &inputs, const IterableOutputs &outputs, const IterableArgs &args)
 
template<class IterableInputs , class IterableOutputs >
OperatorDef MakeOperatorDef (const string &type, const string &name, const IterableInputs &inputs, const IterableOutputs &outputs)
 
bool ParseProtoFromText (string text, google::protobuf::Message *proto)
 
bool ParseProtoFromLargeString (const string &str, google::protobuf::Message *proto)
 
bool ReadProtoFromBinaryFile (const char *filename, google::protobuf::Message *proto)
 
void WriteProtoToBinaryFile (const google::protobuf::Message &proto, const char *filename)
 
 DEPLOY_CPU (Proposal)
 
 DEPLOY_CUDA (Proposal)
 
 NumInputs (3, INT_MAX) .NumOutputs(1
 
 DEFINE_REGISTRY (GraphRegistry, GraphBase, const GraphDef &, Workspace *)
 
OperatorBaseTryCreateOperator (const string &key, const OperatorDef &def, Workspace *ws)
 
 DEFINE_REGISTRY (CPUOperatorRegistry, OperatorBase, const OperatorDef &, Workspace *)
 
 DEFINE_REGISTRY (CUDAOperatorRegistry, OperatorBase, const OperatorDef &, Workspace *)
 
 DEFINE_REGISTRY (CUDNNOperatorRegistry, OperatorBase, const OperatorDef &, Workspace *)
 
 DEFINE_REGISTRY (CNMLOperatorRegistry, OperatorBase, const OperatorDef &, Workspace *)
 
 DEFINE_REGISTRY (GradientRegistry, GradientMakerBase, const OperatorDef &, const vector< string > &)
 
 DEFINE_REGISTRY (NoGradientRegistry, GradientMakerBase, const OperatorDef &, const vector< string > &)
 
 DEPLOY_CUDNN (Relu)
 
 DEPLOY_CUDNN (ReluGradient)
 
 DEPLOY_CUDNN (Sigmoid)
 
 DEPLOY_CUDNN (SigmoidGradient)
 
 DEPLOY_CUDNN (Softmax)
 
 DEPLOY_CUDNN (SoftmaxGradient)
 
 DEPLOY_CUDNN (Tanh)
 
 DEPLOY_CUDNN (TanhGradient)
 
 DEPLOY_CPU (Dropout)
 
 DEPLOY_CUDA (Dropout)
 
 DEPLOY_CPU (DropoutGradient)
 
 DEPLOY_CUDA (DropoutGradient)
 
 NumInputs (1) .NumOutputs(1) .Inplace(
 
 NumInputs (2) .NumOutputs(1) .Inplace(
 
 REGISTER_GRADIENT (Dropout, InplaceGradientMaker)
 
 DEPLOY_CPU (DropPath)
 
 DEPLOY_CUDA (DropPath)
 
 DEPLOY_CPU (DropPathGradient)
 
 DEPLOY_CUDA (DropPathGradient)
 
 REGISTER_GRADIENT (DropPath, InplaceGradientMaker)
 
 DEPLOY_CPU (Elu)
 
 DEPLOY_CUDA (Elu)
 
 DEPLOY_CPU (EluGradient)
 
 DEPLOY_CUDA (EluGradient)
 
 REGISTER_GRADIENT (Elu, InplaceGradientMaker)
 
 DEPLOY_CPU (PRelu)
 
 DEPLOY_CUDA (PRelu)
 
 DEPLOY_CPU (PReluGradient)
 
 DEPLOY_CUDA (PReluGradient)
 
 NumInputs (3) .NumOutputs(2)
 
 REGISTER_GRADIENT (PRelu, GradientMaker)
 
 DEPLOY_CPU (Relu)
 
 DEPLOY_CUDA (Relu)
 
 DEPLOY_CPU (ReluGradient)
 
 DEPLOY_CUDA (ReluGradient)
 
 REGISTER_GRADIENT (Relu, InplaceGradientMaker)
 
 DEPLOY_CPU (SElu)
 
 DEPLOY_CUDA (SElu)
 
 DEPLOY_CPU (SEluGradient)
 
 DEPLOY_CUDA (SEluGradient)
 
 REGISTER_GRADIENT (SElu, InplaceGradientMaker)
 
 DEPLOY_CPU (Sigmoid)
 
 DEPLOY_CUDA (Sigmoid)
 
 DEPLOY_CPU (SigmoidGradient)
 
 DEPLOY_CUDA (SigmoidGradient)
 
 REGISTER_GRADIENT (Sigmoid, InplaceGradientMaker)
 
 DEPLOY_CPU (Softmax)
 
 DEPLOY_CUDA (Softmax)
 
 DEPLOY_CPU (SoftmaxGradient)
 
 DEPLOY_CUDA (SoftmaxGradient)
 
 REGISTER_GRADIENT (Softmax, InplaceGradientMaker)
 
 DEPLOY_CPU (Tanh)
 
 DEPLOY_CUDA (Tanh)
 
 DEPLOY_CPU (TanhGradient)
 
 DEPLOY_CUDA (TanhGradient)
 
 REGISTER_GRADIENT (Tanh, InplaceGradientMaker)
 
 DEPLOY_CPU (Accumulate)
 
 DEPLOY_CUDA (Accumulate)
 
 NumInputs (1, INT_MAX) .NumOutputs(1
 
 NO_GRADIENT (Accumulate)
 
 DEPLOY_CPU (Add)
 
 DEPLOY_CUDA (Add)
 
 DEPLOY_CPU (AddGradient)
 
 DEPLOY_CUDA (AddGradient)
 
 REGISTER_GRADIENT (Add, GradientMaker)
 
 DEPLOY_CPU (Affine)
 
 DEPLOY_CUDA (Affine)
 
 DEPLOY_CPU (AffineGradient)
 
 DEPLOY_CUDA (AffineGradient)
 
 NumInputs (2, 3) .NumOutputs(1) .Inplace(
 
 REGISTER_GRADIENT (Affine, GradientMaker)
 
 DEPLOY_CPU (Clip)
 
 DEPLOY_CUDA (Clip)
 
 DEPLOY_CPU (ClipGradient)
 
 DEPLOY_CUDA (ClipGradient)
 
 REGISTER_GRADIENT (Clip, SimpleGradientMaker)
 
 DEPLOY_CPU (Div)
 
 DEPLOY_CUDA (Div)
 
 DEPLOY_CPU (DivGradient)
 
 DEPLOY_CUDA (DivGradient)
 
 REGISTER_GRADIENT (Div, GradientMaker)
 
 DEPLOY_CPU (Dot)
 
 DEPLOY_CUDA (Dot)
 
 DEPLOY_CPU (DotGradient)
 
 DEPLOY_CUDA (DotGradient)
 
 REGISTER_GRADIENT (Dot, SimpleGradientMaker)
 
 DEPLOY_CPU (Eltwise)
 
 DEPLOY_CUDA (Eltwise)
 
 DEPLOY_CPU (EltwiseGradient)
 
 DEPLOY_CUDA (EltwiseGradient)
 
 NumInputs (2, INT_MAX) .NumOutputs(1)
 
 REGISTER_GRADIENT (Eltwise, SimpleGradientMaker)
 
 DEPLOY_CPU (Exp)
 
 DEPLOY_CUDA (Exp)
 
 DEPLOY_CPU (ExpGradient)
 
 DEPLOY_CUDA (ExpGradient)
 
 REGISTER_GRADIENT (Exp, InplaceGradientMaker)
 
 DEPLOY_CPU (FullyConnected)
 
 DEPLOY_CUDA (FullyConnected)
 
 DEPLOY_CPU (FullyConnectedGradient)
 
 DEPLOY_CUDA (FullyConnectedGradient)
 
 REGISTER_GRADIENT (FullyConnected, GradientMaker)
 
 DEPLOY_CPU (GramMatrix)
 
 DEPLOY_CUDA (GramMatrix)
 
 DEPLOY_CPU (GramMatrixGradient)
 
 DEPLOY_CUDA (GramMatrixGradient)
 
 REGISTER_GRADIENT (GramMatrix, SimpleGradientMaker)
 
 DEPLOY_CPU (Log)
 
 DEPLOY_CUDA (Log)
 
 DEPLOY_CPU (LogGradient)
 
 DEPLOY_CUDA (LogGradient)
 
 REGISTER_GRADIENT (Log, SimpleGradientMaker)
 
 DEPLOY_CPU (Matmul)
 
 DEPLOY_CUDA (Matmul)
 
 DEPLOY_CPU (MatmulGradient)
 
 DEPLOY_CUDA (MatmulGradient)
 
 REGISTER_GRADIENT (Matmul, SimpleGradientMaker)
 
 DEPLOY_CPU (Maximum)
 
 DEPLOY_CUDA (Maximum)
 
 DEPLOY_CPU (MaximumGradient)
 
 DEPLOY_CUDA (MaximumGradient)
 
 REGISTER_GRADIENT (Maximum, SimpleGradientMaker)
 
 DEPLOY_CPU (Minimum)
 
 DEPLOY_CUDA (Minimum)
 
 DEPLOY_CPU (MinimumGradient)
 
 DEPLOY_CUDA (MinimumGradient)
 
 REGISTER_GRADIENT (Minimum, SimpleGradientMaker)
 
 DEPLOY_CPU (Moments)
 
 DEPLOY_CUDA (Moments)
 
 NO_GRADIENT (Moments)
 
 DEPLOY_CPU (Mul)
 
 DEPLOY_CUDA (Mul)
 
 DEPLOY_CPU (MulGradient)
 
 DEPLOY_CUDA (MulGradient)
 
 REGISTER_GRADIENT (Mul, GradientMaker)
 
 DEPLOY_CPU (Pow)
 
 DEPLOY_CUDA (Pow)
 
 DEPLOY_CPU (PowGradient)
 
 DEPLOY_CUDA (PowGradient)
 
 REGISTER_GRADIENT (Pow, GradientMaker)
 
 DEPLOY_CPU (RAdd)
 
 DEPLOY_CUDA (RAdd)
 
 DEPLOY_CPU (RAddGradient)
 
 DEPLOY_CUDA (RAddGradient)
 
 REGISTER_GRADIENT (RAdd, GradientMaker)
 
 DEPLOY_CPU (RDiv)
 
 DEPLOY_CUDA (RDiv)
 
 DEPLOY_CPU (RDivGradient)
 
 DEPLOY_CUDA (RDivGradient)
 
 REGISTER_GRADIENT (RDiv, GradientMaker)
 
 DEPLOY_CPU (RMul)
 
 DEPLOY_CUDA (RMul)
 
 DEPLOY_CPU (RMulGradient)
 
 DEPLOY_CUDA (RMulGradient)
 
 REGISTER_GRADIENT (RMul, GradientMaker)
 
 DEPLOY_CPU (RSub)
 
 DEPLOY_CUDA (RSub)
 
 DEPLOY_CPU (RSubGradient)
 
 DEPLOY_CUDA (RSubGradient)
 
 REGISTER_GRADIENT (RSub, GradientMaker)
 
 DEPLOY_CPU (Sqrt)
 
 DEPLOY_CUDA (Sqrt)
 
 DEPLOY_CPU (SqrtGradient)
 
 DEPLOY_CUDA (SqrtGradient)
 
 REGISTER_GRADIENT (Sqrt, InplaceGradientMaker)
 
 DEPLOY_CPU (Square)
 
 DEPLOY_CUDA (Square)
 
 DEPLOY_CPU (SquareGradient)
 
 DEPLOY_CUDA (SquareGradient)
 
 REGISTER_GRADIENT (Square, SimpleGradientMaker)
 
 DEPLOY_CPU (Sub)
 
 DEPLOY_CUDA (Sub)
 
 DEPLOY_CPU (SubGradient)
 
 DEPLOY_CUDA (SubGradient)
 
 REGISTER_GRADIENT (Sub, GradientMaker)
 
 DEPLOY_CPU (Arange)
 
 DEPLOY_CUDA (Arange)
 
 NumInputs (0) .NumOutputs(1)
 
 NO_GRADIENT (Arange)
 
 DEPLOY_CPU (ArgReduce)
 
 DEPLOY_CUDA (ArgReduce)
 
 NO_GRADIENT (ArgReduce)
 
 DEPLOY_CPU (ChannelShuffle)
 
 DEPLOY_CUDA (ChannelShuffle)
 
 DEPLOY_CPU (ChannelShuffleGradient)
 
 DEPLOY_CUDA (ChannelShuffleGradient)
 
 REGISTER_GRADIENT (ChannelShuffle, SimpleGradientMaker)
 
 DEPLOY_CPU (Concat)
 
 DEPLOY_CUDA (Concat)
 
 DEPLOY_CPU (ConcatGradient)
 
 DEPLOY_CUDA (ConcatGradient)
 
 REGISTER_GRADIENT (Concat, SimpleGradientMaker)
 
 DEPLOY_CPU (Crop)
 
 DEPLOY_CUDA (Crop)
 
 DEPLOY_CPU (CropGradient)
 
 DEPLOY_CUDA (CropGradient)
 
 REGISTER_GRADIENT (Crop, SimpleGradientMaker)
 
 DEPLOY_CPU (ExpandDims)
 
 DEPLOY_CUDA (ExpandDims)
 
 DEPLOY_CPU (ExpandDimsGradient)
 
 DEPLOY_CUDA (ExpandDimsGradient)
 
 REGISTER_GRADIENT (ExpandDims, SimpleGradientMaker)
 
 DEPLOY_CPU (Flatten)
 
 DEPLOY_CUDA (Flatten)
 
 DEPLOY_CPU (FlattenGradient)
 
 DEPLOY_CUDA (FlattenGradient)
 
 REGISTER_GRADIENT (Flatten, SimpleGradientMaker)
 
 DEPLOY_CPU (IndexSelect)
 
 DEPLOY_CUDA (IndexSelect)
 
 DEPLOY_CPU (IndexSelectGradient)
 
 DEPLOY_CUDA (IndexSelectGradient)
 
 REGISTER_GRADIENT (IndexSelect, GradientMaker)
 
 DEPLOY_CPU (MaskedSelect)
 
 DEPLOY_CUDA (MaskedSelect)
 
 DEPLOY_CPU (MaskedSelectGradient)
 
 DEPLOY_CUDA (MaskedSelectGradient)
 
 REGISTER_GRADIENT (MaskedSelect, GradientMaker)
 
 DEPLOY_CPU (Multinomial)
 
 DEPLOY_CUDA (Multinomial)
 
 NO_GRADIENT (Multinomial)
 
 DEPLOY_CPU (NonZero)
 
 DEPLOY_CUDA (NonZero)
 
 NO_GRADIENT (NonZero)
 
 DEPLOY_CPU (OneHot)
 
 DEPLOY_CUDA (OneHot)
 
 NO_GRADIENT (OneHot)
 
 DEPLOY_CPU (Pad)
 
 DEPLOY_CUDA (Pad)
 
 DEPLOY_CPU (PadGradient)
 
 DEPLOY_CUDA (PadGradient)
 
 REGISTER_GRADIENT (Pad, GradientMaker)
 
 DEPLOY_CPU (Reduce)
 
 DEPLOY_CUDA (Reduce)
 
 DEPLOY_CPU (ReduceGradient)
 
 DEPLOY_CUDA (ReduceGradient)
 
 REGISTER_GRADIENT (Reduce, SimpleGradientMaker)
 
 DEPLOY_CPU (Repeat)
 
 DEPLOY_CUDA (Repeat)
 
 DEPLOY_CPU (RepeatGradient)
 
 DEPLOY_CUDA (RepeatGradient)
 
 REGISTER_GRADIENT (Repeat, SimpleGradientMaker)
 
 DEPLOY_CPU (Reshape)
 
 DEPLOY_CUDA (Reshape)
 
 DEPLOY_CPU (ReshapeGradient)
 
 DEPLOY_CUDA (ReshapeGradient)
 
 REGISTER_GRADIENT (Reshape, SimpleGradientMaker)
 
 DEPLOY_CPU (Shape)
 
 DEPLOY_CUDA (Shape)
 
 NO_GRADIENT (Shape)
 
 DEPLOY_CPU (Slice)
 
 DEPLOY_CUDA (Slice)
 
 DEPLOY_CPU (SliceGradient)
 
 DEPLOY_CUDA (SliceGradient)
 
 REGISTER_GRADIENT (Slice, GradientMaker)
 
 DEPLOY_CPU (Squeeze)
 
 DEPLOY_CUDA (Squeeze)
 
 DEPLOY_CPU (SqueezeGradient)
 
 DEPLOY_CUDA (SqueezeGradient)
 
 REGISTER_GRADIENT (Squeeze, SimpleGradientMaker)
 
 DEPLOY_CPU (Stack)
 
 DEPLOY_CUDA (Stack)
 
 DEPLOY_CPU (StackGradient)
 
 DEPLOY_CUDA (StackGradient)
 
 REGISTER_GRADIENT (Stack, SimpleGradientMaker)
 
 DEPLOY_CPU (Tile)
 
 DEPLOY_CUDA (Tile)
 
 DEPLOY_CPU (TileGradient)
 
 DEPLOY_CUDA (TileGradient)
 
 REGISTER_GRADIENT (Tile, GradientMaker)
 
 DEPLOY_CPU (Transpose)
 
 DEPLOY_CUDA (Transpose)
 
 DEPLOY_CPU (TransposeGradient)
 
 DEPLOY_CUDA (TransposeGradient)
 
 REGISTER_GRADIENT (Transpose, SimpleGradientMaker)
 
 DEPLOY_CPU (Where)
 
 DEPLOY_CUDA (Where)
 
 DEPLOY_CPU (WhereGradient)
 
 DEPLOY_CUDA (WhereGradient)
 
 NumInputs (4) .NumOutputs(2)
 
 REGISTER_GRADIENT (Where, GradientMaker)
 
 DEPLOY_CPU (Assign)
 
 DEPLOY_CUDA (Assign)
 
 NO_GRADIENT (Assign)
 
 DEPLOY_CPU (Compare)
 
 DEPLOY_CUDA (Compare)
 
 NO_GRADIENT (Compare)
 
 DEPLOY_CPU (Copy)
 
 DEPLOY_CUDA (Copy)
 
 NO_GRADIENT (Copy)
 
 DEPLOY_CPU (MaskedAssign)
 
 DEPLOY_CUDA (MaskedAssign)
 
 NO_GRADIENT (MaskedAssign)
 
 DEPLOY_CPU (CTCLoss)
 
 DEPLOY_CUDA (CTCLoss)
 
 DEPLOY_CPU (CTCLossGradient)
 
 DEPLOY_CUDA (CTCLossGradient)
 
 REGISTER_GRADIENT (CTCLoss, GradientMaker)
 
 DEPLOY_CPU (L1Loss)
 
 DEPLOY_CUDA (L1Loss)
 
 DEPLOY_CPU (L1LossGradient)
 
 DEPLOY_CUDA (L1LossGradient)
 
 NumInputs (1, 3) .NumOutputs(1)
 
 REGISTER_GRADIENT (L1Loss, GradientMaker)
 
 DEPLOY_CPU (L2Loss)
 
 DEPLOY_CUDA (L2Loss)
 
 DEPLOY_CPU (L2LossGradient)
 
 DEPLOY_CUDA (L2LossGradient)
 
 REGISTER_GRADIENT (L2Loss, GradientMaker)
 
 DEPLOY_CPU (NLLLoss)
 
 DEPLOY_CUDA (NLLLoss)
 
 DEPLOY_CPU (NLLLossGradient)
 
 DEPLOY_CUDA (NLLLossGradient)
 
 REGISTER_GRADIENT (NLLLoss, GradientMaker)
 
 DEPLOY_CPU (SigmoidCrossEntropy)
 
 DEPLOY_CUDA (SigmoidCrossEntropy)
 
 DEPLOY_CPU (SigmoidCrossEntropyGradient)
 
 DEPLOY_CUDA (SigmoidCrossEntropyGradient)
 
 REGISTER_GRADIENT (SigmoidCrossEntropy, GradientMaker)
 
 DEPLOY_CPU (SigmoidFocalLoss)
 
 DEPLOY_CUDA (SigmoidFocalLoss)
 
 DEPLOY_CPU (SigmoidFocalLossGradient)
 
 DEPLOY_CUDA (SigmoidFocalLossGradient)
 
 REGISTER_GRADIENT (SigmoidFocalLoss, GradientMaker)
 
 DEPLOY_CPU (SmoothL1Loss)
 
 DEPLOY_CUDA (SmoothL1Loss)
 
 DEPLOY_CPU (SmoothL1LossGradient)
 
 DEPLOY_CUDA (SmoothL1LossGradient)
 
 NumInputs (2, 4) .NumOutputs(1)
 
 NumInputs (3, 5) .NumOutputs(2)
 
 REGISTER_GRADIENT (SmoothL1Loss, GradientMaker)
 
 DEPLOY_CPU (SoftmaxCrossEntropy)
 
 DEPLOY_CUDA (SoftmaxCrossEntropy)
 
 DEPLOY_CPU (SoftmaxCrossEntropyGradient)
 
 DEPLOY_CUDA (SoftmaxCrossEntropyGradient)
 
 REGISTER_GRADIENT (SoftmaxCrossEntropy, GradientMaker)
 
 DEPLOY_CPU (SoftmaxFocalLoss)
 
 DEPLOY_CUDA (SoftmaxFocalLoss)
 
 DEPLOY_CPU (SoftmaxFocalLossGradient)
 
 DEPLOY_CUDA (SoftmaxFocalLossGradient)
 
 REGISTER_GRADIENT (SoftmaxFocalLoss, GradientMaker)
 
 DEPLOY_CPU (SparseSoftmaxCrossEntropy)
 
 DEPLOY_CUDA (SparseSoftmaxCrossEntropy)
 
 DEPLOY_CPU (SparseSoftmaxCrossEntropyGradient)
 
 DEPLOY_CUDA (SparseSoftmaxCrossEntropyGradient)
 
 REGISTER_GRADIENT (SparseSoftmaxCrossEntropy, GradientMaker)
 
 DEPLOY_CPU (Accuracy)
 
 DEPLOY_CUDA (Accuracy)
 
 NO_GRADIENT (Accuracy)
 
 DEPLOY_CPU (Cast)
 
 DEPLOY_CUDA (Cast)
 
 DEPLOY_CPU (CastGradient)
 
 DEPLOY_CUDA (CastGradient)
 
 NumInputs (0, 1) .NumOutputs(1)
 
 REGISTER_GRADIENT (Cast, GradientMaker)
 
 DEPLOY_CPU (GradientGenerate)
 
 DEPLOY_CUDA (GradientGenerate)
 
 DEPLOY_CPU (GradientGather)
 
 DEPLOY_CUDA (GradientGather)
 
 DEPLOY_CPU (GradientAdd)
 
 DEPLOY_CUDA (GradientAdd)
 
 DEPLOY_CPU (StopGradient)
 
 DEPLOY_CUDA (StopGradient)
 
 NO_GRADIENT (StopGradient)
 
 DEPLOY_CPU (ImageData)
 
 DEPLOY_CUDA (ImageData)
 
 NO_GRADIENT (ImageData)
 
 DEPLOY_CPU (Fill)
 
 DEPLOY_CUDA (Fill)
 
 DEPLOY_CPU (GivenTensorFill)
 
 DEPLOY_CUDA (GivenTensorFill)
 
 DEPLOY_CPU (RandomUniform)
 
 DEPLOY_CUDA (RandomUniform)
 
 DEPLOY_CPU (RandomNormal)
 
 DEPLOY_CUDA (RandomNormal)
 
 DEPLOY_CPU_CUDA (TruncatedNormal)
 
 DEPLOY_CPU (GlorotUniform)
 
 DEPLOY_CUDA (GlorotUniform)
 
 DEPLOY_CPU (GlorotNormal)
 
 DEPLOY_CUDA (GlorotNormal)
 
 NO_GRADIENT (Fill)
 
 NO_GRADIENT (GivenTensorFill)
 
 NO_GRADIENT (RandomUniform)
 
 NO_GRADIENT (RandomNormal)
 
 NO_GRADIENT (TruncatedNormal)
 
 NO_GRADIENT (GlorotUniform)
 
 NO_GRADIENT (GlorotNormal)
 
 DEPLOY_CPU (MPIBroadcast)
 
 DEPLOY_CUDA (MPIBroadcast)
 
 DEPLOY_CPU (MPIBroadcastGradient)
 
 DEPLOY_CUDA (MPIBroadcastGradient)
 
 REGISTER_GRADIENT (MPIBroadcast, GradientMaker)
 
 DEPLOY_CPU (MPIGather)
 
 DEPLOY_CUDA (MPIGather)
 
 DEPLOY_CPU (MPIGatherGradient)
 
 DEPLOY_CUDA (MPIGatherGradient)
 
 REGISTER_GRADIENT (MPIGather, GradientMaker)
 
 DEPLOY_CPU (BatchNorm)
 
 DEPLOY_CUDA (BatchNorm)
 
 DEPLOY_CPU (BatchNormGradient)
 
 DEPLOY_CUDA (BatchNormGradient)
 
 NumInputs (5) .NumOutputs(1)
 
 REGISTER_GRADIENT (BatchNorm, GradientMaker)
 
 DEPLOY_CPU (GroupNorm)
 
 DEPLOY_CUDA (GroupNorm)
 
 DEPLOY_CPU (GroupNormGradient)
 
 DEPLOY_CUDA (GroupNormGradient)
 
 REGISTER_GRADIENT (GroupNorm, GradientMaker)
 
 DEPLOY_CPU (L2Norm)
 
 DEPLOY_CUDA (L2Norm)
 
 DEPLOY_CPU (L2NormGradient)
 
 DEPLOY_CUDA (L2NormGradient)
 
 REGISTER_GRADIENT (L2Norm, SimpleGradientMaker)
 
 DEPLOY_CPU (LSTMCell)
 
 DEPLOY_CUDA (LSTMCell)
 
 DEPLOY_CPU (LSTMCellGradient)
 
 DEPLOY_CUDA (LSTMCellGradient)
 
 REGISTER_GRADIENT (LSTMCell, GradientMaker)
 
 DEPLOY_CPU (Recurrent)
 
 DEPLOY_CUDA (Recurrent)
 
 DEPLOY_CPU (RecurrentGradient)
 
 DEPLOY_CUDA (RecurrentGradient)
 
 NumInputs (6, 8) .NumOutputs(4)
 
 REGISTER_GRADIENT (Recurrent, GradientMaker)
 
 DEPLOY_CPU (RNNParamSet)
 
 DEPLOY_CUDA (RNNParamSet)
 
 NO_GRADIENT (RNNParamSet)
 
 DEPLOY_CPU (AdamUpdate)
 
 DEPLOY_CUDA (AdamUpdate)
 
 NO_GRADIENT (AdamUpdate)
 
 DEPLOY_CPU (CollectiveUpdate)
 
 DEPLOY_CUDA (CollectiveUpdate)
 
 OPERATOR_SCHEMA (CollectiveUpdate).IgnoreVerify()
 
 DEPLOY_CPU (NesterovUpdate)
 
 DEPLOY_CUDA (NesterovUpdate)
 
 NO_GRADIENT (NesterovUpdate)
 
 DEPLOY_CPU (RMSPropUpdate)
 
 DEPLOY_CUDA (RMSPropUpdate)
 
 NO_GRADIENT (RMSPropUpdate)
 
 DEPLOY_CPU (SGDUpdate)
 
 DEPLOY_CUDA (SGDUpdate)
 
 NO_GRADIENT (SGDUpdate)
 
 DEPLOY_CPU (BiasAdd)
 
 DEPLOY_CUDA (BiasAdd)
 
 DEPLOY_CPU (BiasAddGradient)
 
 DEPLOY_CUDA (BiasAddGradient)
 
 REGISTER_GRADIENT (BiasAdd, GradientMaker)
 
 DEPLOY_CPU (BilinearResize)
 
 DEPLOY_CUDA (BilinearResize)
 
 DEPLOY_CPU (BilinearResizeGradient)
 
 DEPLOY_CUDA (BilinearResizeGradient)
 
 REGISTER_GRADIENT (BilinearResize, SimpleGradientMaker)
 
 DEPLOY_CPU (Conv2d)
 
 DEPLOY_CUDA (Conv2d)
 
 DEPLOY_CPU (Conv2dGradient)
 
 DEPLOY_CUDA (Conv2dGradient)
 
 REGISTER_GRADIENT (Conv2d, GradientMaker)
 
 DEPLOY_CPU (ConvTranspose2d)
 
 DEPLOY_CUDA (ConvTranspose2d)
 
 DEPLOY_CPU (ConvTranspose2dGradient)
 
 DEPLOY_CUDA (ConvTranspose2dGradient)
 
 REGISTER_GRADIENT (ConvTranspose2d, GradientMaker)
 
 DEPLOY_CUDNN (BiasAdd)
 
 DEPLOY_CUDNN (BiasAddGradient)
 
 DEPLOY_CUDNN (Conv2d)
 
 DEPLOY_CUDNN (Conv2dGradient)
 
 DEPLOY_CUDNN (ConvTranspose2d)
 
 DEPLOY_CUDNN (ConvTranspose2dGradient)
 
 DEPLOY_CUDNN (DepthwiseConv2d)
 
 DEPLOY_CUDNN (DepthwiseConv2dGradient)
 
 DEPLOY_CUDNN (LRN)
 
 DEPLOY_CUDNN (LRNGradient)
 
 DEPLOY_CUDNN (Pool2d)
 
 DEPLOY_CUDNN (Pool2dGradient)
 
 DEPLOY_CPU (DepthwiseConv2d)
 
 DEPLOY_CUDA (DepthwiseConv2d)
 
 DEPLOY_CPU (DepthwiseConv2dGradient)
 
 DEPLOY_CUDA (DepthwiseConv2dGradient)
 
 REGISTER_GRADIENT (DepthwiseConv2d, GradientMaker)
 
 DEPLOY_CPU (DropBlock2d)
 
 DEPLOY_CUDA (DropBlock2d)
 
 DEPLOY_CPU (DropBlock2dGradient)
 
 DEPLOY_CUDA (DropBlock2dGradient)
 
 REGISTER_GRADIENT (DropBlock2d, InplaceGradientMaker)
 
 DEPLOY_CPU (LRN)
 
 DEPLOY_CUDA (LRN)
 
 DEPLOY_CPU (LRNGradient)
 
 DEPLOY_CUDA (LRNGradient)
 
 REGISTER_GRADIENT (LRN, GradientMaker)
 
 DEPLOY_CPU (NNResize)
 
 DEPLOY_CUDA (NNResize)
 
 DEPLOY_CPU (NNResizeGradient)
 
 DEPLOY_CUDA (NNResizeGradient)
 
 REGISTER_GRADIENT (NNResize, SimpleGradientMaker)
 
 DEPLOY_CPU (Pool2d)
 
 DEPLOY_CUDA (Pool2d)
 
 DEPLOY_CPU (Pool2dGradient)
 
 DEPLOY_CUDA (Pool2dGradient)
 
 REGISTER_GRADIENT (Pool2d, GradientMaker)
 
 DEPLOY_CPU (ROIAlign)
 
 DEPLOY_CUDA (ROIAlign)
 
 DEPLOY_CPU (ROIAlignGradient)
 
 DEPLOY_CUDA (ROIAlignGradient)
 
 REGISTER_GRADIENT (ROIAlign, GradientMaker)
 
 DEPLOY_CPU (ROIPool)
 
 DEPLOY_CUDA (ROIPool)
 
 DEPLOY_CPU (ROIPoolGradient)
 
 DEPLOY_CUDA (ROIPoolGradient)
 
 REGISTER_GRADIENT (ROIPool, GradientMaker)
 
template void CuDNNSetTensorDesc< float > (cudnnTensorDescriptor_t *, Tensor *)
 
template void CuDNNSetTensor4dDesc< float > (cudnnTensorDescriptor_t *, const string &, Tensor *)
 
template void CuDNNSetTensor5dDesc< float > (cudnnTensorDescriptor_t *, const string &, Tensor *)
 
template void CuDNNSetTensor3dDesc< float > (cudnnTensorDescriptor_t *, const string &, Tensor *)
 
template void CuDNNSetTensorDesc< float > (cudnnTensorDescriptor_t *, const vec64_t &)
 
template void CuDNNSetTensor4dDesc< float > (cudnnTensorDescriptor_t *, const string &, const vec64_t &)
 
template void CuDNNSetTensor5dDesc< float > (cudnnTensorDescriptor_t *, const string &, const vec64_t &)
 
template void CuDNNSetTensor3dDesc< float > (cudnnTensorDescriptor_t *, const string &, const vec64_t &)
 
template void CuDNNSetTensor4dDescWithGroup< float > (cudnnTensorDescriptor_t *, const string &, const vec64_t &, const int64_t)
 
template void CuDNNSetTensorDesc< float > (cudnnTensorDescriptor_t *, const vec64_t &, const vec64_t &)
 
template void CuDNNSetTensorDesc< double > (cudnnTensorDescriptor_t *, Tensor *)
 
template void CuDNNSetTensor4dDesc< double > (cudnnTensorDescriptor_t *, const string &, Tensor *)
 
template void CuDNNSetTensor5dDesc< double > (cudnnTensorDescriptor_t *, const string &, Tensor *)
 
template void CuDNNSetTensor3dDesc< double > (cudnnTensorDescriptor_t *, const string &, Tensor *)
 
template void CuDNNSetTensorDesc< double > (cudnnTensorDescriptor_t *, const vec64_t &)
 
template void CuDNNSetTensor4dDesc< double > (cudnnTensorDescriptor_t *, const string &, const vec64_t &)
 
template void CuDNNSetTensor5dDesc< double > (cudnnTensorDescriptor_t *, const string &, const vec64_t &)
 
template void CuDNNSetTensor3dDesc< double > (cudnnTensorDescriptor_t *, const string &, const vec64_t &)
 
template void CuDNNSetTensor4dDescWithGroup< double > (cudnnTensorDescriptor_t *, const string &, const vec64_t &, const int64_t)
 
template void CuDNNSetTensorDesc< double > (cudnnTensorDescriptor_t *, const vec64_t &, const vec64_t &)
 
template void CuDNNSetTensorDesc< float16 > (cudnnTensorDescriptor_t *, Tensor *)
 
template void CuDNNSetTensor4dDesc< float16 > (cudnnTensorDescriptor_t *, const string &, Tensor *)
 
template void CuDNNSetTensor5dDesc< float16 > (cudnnTensorDescriptor_t *, const string &, Tensor *)
 
template void CuDNNSetTensor3dDesc< float16 > (cudnnTensorDescriptor_t *, const string &, Tensor *)
 
template void CuDNNSetTensorDesc< float16 > (cudnnTensorDescriptor_t *, const vec64_t &)
 
template void CuDNNSetTensor4dDesc< float16 > (cudnnTensorDescriptor_t *, const string &, const vec64_t &)
 
template void CuDNNSetTensor5dDesc< float16 > (cudnnTensorDescriptor_t *, const string &, const vec64_t &)
 
template void CuDNNSetTensor3dDesc< float16 > (cudnnTensorDescriptor_t *, const string &, const vec64_t &)
 
template void CuDNNSetTensor4dDescWithGroup< float16 > (cudnnTensorDescriptor_t *, const string &, const vec64_t &, const int64_t)
 
template void CuDNNSetTensorDesc< float16 > (cudnnTensorDescriptor_t *, const vec64_t &, const vec64_t &)
 
std::string GenLogHashKey (const char *file, int line)
 
bool ParseProtoFromText (string text, Message *proto)
 
bool ParseProtoFromLargeString (const string &str, Message *proto)
 
bool ReadProtoFromBinaryFile (const char *filename, Message *proto)
 
void WriteProtoToBinaryFile (const Message &proto, const char *filename)
 
int type_from_string (std::string type)
 
WorkspaceCreateWorkspace (const std::string &name)
 
WorkspaceResetWorkspace (const std::string &name)
 
WorkspaceResetWorkspace (Workspace_t ws)
 
void MoveWorkspace (Workspace_t dst, Workspace_t src)
 
void DestroyWorkspace (const std::string &name)
 
void DestroyWorkspace (Workspace_t ws)
 
std::string CreateGraph (const GraphDef_t graph_def, const Device &device, Workspace_t ws)
 
std::string CreateGraph (const std::string &graph_file, const Device &device, Workspace_t ws)
 
void RunGraph (const std::string &graph_name, Workspace_t ws, const int stream_id)
 
void CreateTensor (const std::string &name, Workspace_t ws)
 
template<typename T >
T * FetchTensor (const std::string &name, vector< int64_t > &shape, Workspace_t ws, const bool copy)
 
template<typename T >
void FeedTensor (const std::string &name, const vector< int64_t > &shape, const T *data, const Device &device, Workspace_t ws)
 
DRAGON_API void CreateGraphDef (GraphDef_t *graph_def)
 
DRAGON_API void DestroyGraphDef (GraphDef_t graph_def)
 
void LoadCaffeModel (const std::string &model_file, Workspace_t ws)
 
void LoadONNXModel (const std::string &model_file, GraphDef_t init_graph, GraphDef_t pred_graph, std::vector< std::string > &inputs, std::vector< std::string > &outputs)
 
void SetLoggingLevel (const std::string &level)
 
template DRAGON_API float16 * FetchTensor< float16 > (const std::string &, std::vector< int64_t > &, Workspace_t, const bool)
 
template DRAGON_API float * FetchTensor< float > (const std::string &, std::vector< int64_t > &, Workspace_t, const bool)
 
template DRAGON_API uint8_t * FetchTensor< uint8_t > (const std::string &, std::vector< int64_t > &, Workspace_t, const bool)
 
template DRAGON_API int * FetchTensor< int > (const std::string &, std::vector< int64_t > &, Workspace_t, const bool)
 
template DRAGON_API int64_t * FetchTensor< int64_t > (const std::string &, std::vector< int64_t > &, Workspace_t, const bool)
 
template DRAGON_API void FeedTensor< float16 > (const std::string &, const std::vector< int64_t > &, const float16 *, const Device &, Workspace_t)
 
template DRAGON_API void FeedTensor< float > (const std::string &, const std::vector< int64_t > &, const float *, const Device &, Workspace_t)
 
template DRAGON_API void FeedTensor< uint8_t > (const std::string &, const std::vector< int64_t > &, const uint8_t *, const Device &, Workspace_t)
 
template DRAGON_API void FeedTensor< int > (const std::string &, const std::vector< int64_t > &, const int *, const Device &, Workspace_t)
 
template DRAGON_API void FeedTensor< int64_t > (const std::string &, const std::vector< int64_t > &, const int64_t *, const Device &, Workspace_t)
 
template<typename T >
DRAGON_API T * FetchTensor (const std::string &name, std::vector< int64_t > &shape, Workspace_t ws, const bool copy=false)
 
template<typename T >
DRAGON_API void FeedTensor (const std::string &name, const std::vector< int64_t > &shape, const T *data, const Device &device, Workspace_t ws)
 

Variables

const int CUDA_THREADS = 1024
 
const int CUDA_MAX_BLOCKS = 65535
 
 INT_MAX
 
LogSeverity g_log_destination = INFO
 
std::string LOG_SEVERITIES []
 
std::map< std::string, LogSeverityLOG_LEVELS
 
std::map< std::string, int > g_log_count
 
std::map< std::string, int > g_log_every
 
Map< string, unique_ptr< Workspace > > g_workspaces
 
Map< string, vector< string > > sub_workspaces
 
std::mutex g_mutex
 

Detailed Description

Copyright (c) 2017-present, SeetaTech, Co.,Ltd.

Licensed under the BSD 2-Clause License. You should have received a copy of the BSD 2-Clause License along with the software. If not, See,

 <https://opensource.org/licenses/BSD-2-Clause>

Copyright (c) 2017-present, SeetaTech, Co.,Ltd.

Licensed under the BSD 2-Clause License. You should have received a copy of the BSD 2-Clause License along with the software. If not, See,

 <https://opensource.org/licenses/BSD-2-Clause>

NVIDIA's CUDA Environment

Copyright (c) 2017-present, SeetaTech, Co.,Ltd.

Licensed under the BSD 2-Clause License. You should have received a copy of the BSD 2-Clause License along with the software. If not, See,

 <https://opensource.org/licenses/BSD-2-Clause>

Codes are based on:

https://github.com/pytorch/pytorch/blob/master/caffe2/utils/eigen_utils.h


Codes are based on:

https://github.com/pytorch/pytorch/blob/master/caffe2/operators/group_norm_op.cc


Typedef Documentation

◆ BlockReduce

template<typename T >
using dragon::BlockReduce = typedef cub::BlockReduce<T, CUDA_THREADS>

◆ CBLAS_TRANSPOSE

◆ ConstEigenArrayMap

template<typename T >
using dragon::ConstEigenArrayMap = typedef Eigen::Map< const Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic> >

◆ ConstEigenMatrixMap

template<typename T >
using dragon::ConstEigenMatrixMap = typedef Eigen::Map< const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> >

◆ ConstEigenVectorArrayMap

template<typename T >
using dragon::ConstEigenVectorArrayMap = typedef Eigen::Map< const Eigen::Array<T, Eigen::Dynamic, 1> >

◆ ConstEigenVectorMap

template<typename T >
using dragon::ConstEigenVectorMap = typedef Eigen::Map< const Eigen::Matrix<T, Eigen::Dynamic, 1> >

◆ EigenArrayMap

template<typename T >
using dragon::EigenArrayMap = typedef Eigen::Map< Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic> >

◆ EigenMatrixMap

template<typename T >
using dragon::EigenMatrixMap = typedef Eigen::Map< Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> >

◆ EigenVectorArrayMap

template<typename T >
using dragon::EigenVectorArrayMap = typedef Eigen::Map< Eigen::Array<T, Eigen::Dynamic, 1> >

◆ EigenVectorMap

template<typename T >
using dragon::EigenVectorMap = typedef Eigen::Map< Eigen::Matrix<T, Eigen::Dynamic, 1> >

◆ float16_t

typedef struct float16* dragon::float16_t

◆ GraphDef_t

typedef struct GraphDef* dragon::GraphDef_t

◆ Map

template<typename Key , typename Value >
using dragon::Map = typedef std::unordered_map<Key, Value>

◆ Set

template<typename Value >
using dragon::Set = typedef std::unordered_set<Value>

◆ TypeId

typedef intptr_t dragon::TypeId

◆ vec32_t

typedef std::vector<int> dragon::vec32_t

◆ vec64_t

typedef std::vector<int64_t> dragon::vec64_t

◆ Workspace_t

typedef struct Workspace* dragon::Workspace_t

Enumeration Type Documentation

◆ CBLAS_TRANSPOSE

Enumerator
CblasNoTrans 
CblasTrans 

◆ LogSeverity

Enumerator
DEBUG 
INFO 
WARNING 
ERROR 
FATAL 

◆ LRNMode

Enumerator
ACROSS_CHANNELS 
WITHIN_CHANNEL 

◆ StorageOrder

Enumerator
NCHW 
NHWC 

Function Documentation

◆ CreateFiller()

template<typename T , class Context >
Filler<T, Context>* dragon::CreateFiller ( const TensorFillerProto &  proto)

◆ CreateGraph() [1/2]

DRAGON_API std::string dragon::CreateGraph ( const GraphDef_t  graph_def,
const Device device,
Workspace_t  ws 
)

◆ CreateGraph() [2/2]

DRAGON_API std::string dragon::CreateGraph ( const std::string &  graph_file,
const Device device,
Workspace_t  ws 
)

◆ CreateGraphDef()

DRAGON_API void dragon::CreateGraphDef ( GraphDef_t graph_def)

◆ CreateTensor()

DRAGON_API void dragon::CreateTensor ( const std::string &  name,
Workspace_t  ws 
)

◆ CreateWorkspace()

DRAGON_API Workspace_t dragon::CreateWorkspace ( const std::string &  name)

◆ CUDA_2D_BLOCKS()

int dragon::CUDA_2D_BLOCKS ( const int  N)
inline

◆ CUDA_BLOCKS()

int dragon::CUDA_BLOCKS ( const int  N)
inline

◆ CUDA_GET_DEVICE()

int dragon::CUDA_GET_DEVICE ( )
inline

◆ CUDA_NUM_DEVICES()

int dragon::CUDA_NUM_DEVICES ( )
inline

◆ CUDA_TRUE_FP16_AVAILABLE()

bool dragon::CUDA_TRUE_FP16_AVAILABLE ( )
inline

◆ CuDNNCreateTensorDesc()

void dragon::CuDNNCreateTensorDesc ( cudnnTensorDescriptor_t *  desc)
inline

◆ CuDNNDestroyTensorDesc()

void dragon::CuDNNDestroyTensorDesc ( cudnnTensorDescriptor_t *  desc)
inline

◆ CuDNNSetTensor3dDesc() [1/2]

template<typename T >
void dragon::CuDNNSetTensor3dDesc ( cudnnTensorDescriptor_t *  desc,
const string &  data_format,
Tensor tensor 
)

◆ CuDNNSetTensor3dDesc() [2/2]

template<typename T >
void dragon::CuDNNSetTensor3dDesc ( cudnnTensorDescriptor_t *  desc,
const string &  data_format,
const vec64_t dims 
)

◆ CuDNNSetTensor3dDesc< double >() [1/2]

template void dragon::CuDNNSetTensor3dDesc< double > ( cudnnTensorDescriptor_t *  ,
const string &  ,
Tensor  
)

◆ CuDNNSetTensor3dDesc< double >() [2/2]

template void dragon::CuDNNSetTensor3dDesc< double > ( cudnnTensorDescriptor_t *  ,
const string &  ,
const vec64_t  
)

◆ CuDNNSetTensor3dDesc< float >() [1/2]

template void dragon::CuDNNSetTensor3dDesc< float > ( cudnnTensorDescriptor_t *  ,
const string &  ,
Tensor  
)

◆ CuDNNSetTensor3dDesc< float >() [2/2]

template void dragon::CuDNNSetTensor3dDesc< float > ( cudnnTensorDescriptor_t *  ,
const string &  ,
const vec64_t  
)

◆ CuDNNSetTensor3dDesc< float16 >() [1/2]

template void dragon::CuDNNSetTensor3dDesc< float16 > ( cudnnTensorDescriptor_t *  ,
const string &  ,
Tensor  
)

◆ CuDNNSetTensor3dDesc< float16 >() [2/2]

template void dragon::CuDNNSetTensor3dDesc< float16 > ( cudnnTensorDescriptor_t *  ,
const string &  ,
const vec64_t  
)

◆ CuDNNSetTensor4dDesc() [1/2]

template<typename T >
void dragon::CuDNNSetTensor4dDesc ( cudnnTensorDescriptor_t *  desc,
const string &  data_format,
Tensor tensor 
)

◆ CuDNNSetTensor4dDesc() [2/2]

template<typename T >
void dragon::CuDNNSetTensor4dDesc ( cudnnTensorDescriptor_t *  desc,
const string &  data_format,
const vec64_t dims 
)

◆ CuDNNSetTensor4dDesc< double >() [1/2]

template void dragon::CuDNNSetTensor4dDesc< double > ( cudnnTensorDescriptor_t *  ,
const string &  ,
Tensor  
)

◆ CuDNNSetTensor4dDesc< double >() [2/2]

template void dragon::CuDNNSetTensor4dDesc< double > ( cudnnTensorDescriptor_t *  ,
const string &  ,
const vec64_t  
)

◆ CuDNNSetTensor4dDesc< float >() [1/2]

template void dragon::CuDNNSetTensor4dDesc< float > ( cudnnTensorDescriptor_t *  ,
const string &  ,
Tensor  
)

◆ CuDNNSetTensor4dDesc< float >() [2/2]

template void dragon::CuDNNSetTensor4dDesc< float > ( cudnnTensorDescriptor_t *  ,
const string &  ,
const vec64_t  
)

◆ CuDNNSetTensor4dDesc< float16 >() [1/2]

template void dragon::CuDNNSetTensor4dDesc< float16 > ( cudnnTensorDescriptor_t *  ,
const string &  ,
Tensor  
)

◆ CuDNNSetTensor4dDesc< float16 >() [2/2]

template void dragon::CuDNNSetTensor4dDesc< float16 > ( cudnnTensorDescriptor_t *  ,
const string &  ,
const vec64_t  
)

◆ CuDNNSetTensor4dDescWithGroup()

template<typename T >
void dragon::CuDNNSetTensor4dDescWithGroup ( cudnnTensorDescriptor_t *  desc,
const string &  data_format,
const vec64_t dims,
const int64_t  group 
)

◆ CuDNNSetTensor4dDescWithGroup< double >()

template void dragon::CuDNNSetTensor4dDescWithGroup< double > ( cudnnTensorDescriptor_t *  ,
const string &  ,
const vec64_t ,
const  int64_t 
)

◆ CuDNNSetTensor4dDescWithGroup< float >()

template void dragon::CuDNNSetTensor4dDescWithGroup< float > ( cudnnTensorDescriptor_t *  ,
const string &  ,
const vec64_t ,
const  int64_t 
)

◆ CuDNNSetTensor4dDescWithGroup< float16 >()

template void dragon::CuDNNSetTensor4dDescWithGroup< float16 > ( cudnnTensorDescriptor_t *  ,
const string &  ,
const vec64_t ,
const  int64_t 
)

◆ CuDNNSetTensor5dDesc() [1/2]

template<typename T >
void dragon::CuDNNSetTensor5dDesc ( cudnnTensorDescriptor_t *  desc,
const string &  data_format,
Tensor tensor 
)

◆ CuDNNSetTensor5dDesc() [2/2]

template<typename T >
void dragon::CuDNNSetTensor5dDesc ( cudnnTensorDescriptor_t *  desc,
const string &  data_format,
const vec64_t dims 
)

◆ CuDNNSetTensor5dDesc< double >() [1/2]

template void dragon::CuDNNSetTensor5dDesc< double > ( cudnnTensorDescriptor_t *  ,
const string &  ,
Tensor  
)

◆ CuDNNSetTensor5dDesc< double >() [2/2]

template void dragon::CuDNNSetTensor5dDesc< double > ( cudnnTensorDescriptor_t *  ,
const string &  ,
const vec64_t  
)

◆ CuDNNSetTensor5dDesc< float >() [1/2]

template void dragon::CuDNNSetTensor5dDesc< float > ( cudnnTensorDescriptor_t *  ,
const string &  ,
Tensor  
)

◆ CuDNNSetTensor5dDesc< float >() [2/2]

template void dragon::CuDNNSetTensor5dDesc< float > ( cudnnTensorDescriptor_t *  ,
const string &  ,
const vec64_t  
)

◆ CuDNNSetTensor5dDesc< float16 >() [1/2]

template void dragon::CuDNNSetTensor5dDesc< float16 > ( cudnnTensorDescriptor_t *  ,
const string &  ,
Tensor  
)

◆ CuDNNSetTensor5dDesc< float16 >() [2/2]

template void dragon::CuDNNSetTensor5dDesc< float16 > ( cudnnTensorDescriptor_t *  ,
const string &  ,
const vec64_t  
)

◆ CuDNNSetTensorDesc() [1/3]

template<typename T >
void dragon::CuDNNSetTensorDesc ( cudnnTensorDescriptor_t *  desc,
Tensor tensor 
)

◆ CuDNNSetTensorDesc() [2/3]

template<typename T >
void dragon::CuDNNSetTensorDesc ( cudnnTensorDescriptor_t *  desc,
const vec64_t dims 
)

◆ CuDNNSetTensorDesc() [3/3]

template<typename T >
void dragon::CuDNNSetTensorDesc ( cudnnTensorDescriptor_t *  desc,
const vec64_t dims,
const vec64_t strides 
)

◆ CuDNNSetTensorDesc< double >() [1/3]

template void dragon::CuDNNSetTensorDesc< double > ( cudnnTensorDescriptor_t *  ,
Tensor  
)

◆ CuDNNSetTensorDesc< double >() [2/3]

template void dragon::CuDNNSetTensorDesc< double > ( cudnnTensorDescriptor_t *  ,
const vec64_t  
)

◆ CuDNNSetTensorDesc< double >() [3/3]

template void dragon::CuDNNSetTensorDesc< double > ( cudnnTensorDescriptor_t *  ,
const vec64_t ,
const vec64_t  
)

◆ CuDNNSetTensorDesc< float >() [1/3]

template void dragon::CuDNNSetTensorDesc< float > ( cudnnTensorDescriptor_t *  ,
Tensor  
)

◆ CuDNNSetTensorDesc< float >() [2/3]

template void dragon::CuDNNSetTensorDesc< float > ( cudnnTensorDescriptor_t *  ,
const vec64_t  
)

◆ CuDNNSetTensorDesc< float >() [3/3]

template void dragon::CuDNNSetTensorDesc< float > ( cudnnTensorDescriptor_t *  ,
const vec64_t ,
const vec64_t  
)

◆ CuDNNSetTensorDesc< float16 >() [1/3]

template void dragon::CuDNNSetTensorDesc< float16 > ( cudnnTensorDescriptor_t *  ,
Tensor  
)

◆ CuDNNSetTensorDesc< float16 >() [2/3]

template void dragon::CuDNNSetTensorDesc< float16 > ( cudnnTensorDescriptor_t *  ,
const vec64_t  
)

◆ CuDNNSetTensorDesc< float16 >() [3/3]

template void dragon::CuDNNSetTensorDesc< float16 > ( cudnnTensorDescriptor_t *  ,
const vec64_t ,
const vec64_t  
)

◆ DECLARE_FUNDAMENTAL_OP() [1/16]

dragon::DECLARE_FUNDAMENTAL_OP ( Add  )

◆ DECLARE_FUNDAMENTAL_OP() [2/16]

dragon::DECLARE_FUNDAMENTAL_OP ( Sub  )

◆ DECLARE_FUNDAMENTAL_OP() [3/16]

dragon::DECLARE_FUNDAMENTAL_OP ( Mul  )

◆ DECLARE_FUNDAMENTAL_OP() [4/16]

dragon::DECLARE_FUNDAMENTAL_OP ( Div  )

◆ DECLARE_FUNDAMENTAL_OP() [5/16]

dragon::DECLARE_FUNDAMENTAL_OP ( RAdd  )

◆ DECLARE_FUNDAMENTAL_OP() [6/16]

dragon::DECLARE_FUNDAMENTAL_OP ( RSub  )

◆ DECLARE_FUNDAMENTAL_OP() [7/16]

dragon::DECLARE_FUNDAMENTAL_OP ( RMul  )

◆ DECLARE_FUNDAMENTAL_OP() [8/16]

dragon::DECLARE_FUNDAMENTAL_OP ( RDiv  )

◆ DECLARE_FUNDAMENTAL_OP() [9/16]

dragon::DECLARE_FUNDAMENTAL_OP ( AddGradient  )

◆ DECLARE_FUNDAMENTAL_OP() [10/16]

dragon::DECLARE_FUNDAMENTAL_OP ( SubGradient  )

◆ DECLARE_FUNDAMENTAL_OP() [11/16]

dragon::DECLARE_FUNDAMENTAL_OP ( MulGradient  )

◆ DECLARE_FUNDAMENTAL_OP() [12/16]

dragon::DECLARE_FUNDAMENTAL_OP ( DivGradient  )

◆ DECLARE_FUNDAMENTAL_OP() [13/16]

dragon::DECLARE_FUNDAMENTAL_OP ( RAddGradient  )

◆ DECLARE_FUNDAMENTAL_OP() [14/16]

dragon::DECLARE_FUNDAMENTAL_OP ( RSubGradient  )

◆ DECLARE_FUNDAMENTAL_OP() [15/16]

dragon::DECLARE_FUNDAMENTAL_OP ( RMulGradient  )

◆ DECLARE_FUNDAMENTAL_OP() [16/16]

dragon::DECLARE_FUNDAMENTAL_OP ( RDivGradient  )

◆ DECLARE_REGISTRY() [1/7]

dragon::DECLARE_REGISTRY ( GraphRegistry  ,
GraphBase  ,
const GraphDef &  ,
Workspace  
)

◆ DECLARE_REGISTRY() [2/7]

dragon::DECLARE_REGISTRY ( GradientRegistry  ,
GradientMakerBase  ,
const OperatorDef &  ,
const vector< string > &   
)

◆ DECLARE_REGISTRY() [3/7]

dragon::DECLARE_REGISTRY ( NoGradientRegistry  ,
GradientMakerBase  ,
const OperatorDef &  ,
const vector< string > &   
)

◆ DECLARE_REGISTRY() [4/7]

dragon::DECLARE_REGISTRY ( CPUOperatorRegistry  ,
OperatorBase  ,
const OperatorDef &  ,
Workspace  
)

◆ DECLARE_REGISTRY() [5/7]

dragon::DECLARE_REGISTRY ( CUDAOperatorRegistry  ,
OperatorBase  ,
const OperatorDef &  ,
Workspace  
)

◆ DECLARE_REGISTRY() [6/7]

dragon::DECLARE_REGISTRY ( CUDNNOperatorRegistry  ,
OperatorBase  ,
const OperatorDef &  ,
Workspace  
)

◆ DECLARE_REGISTRY() [7/7]

dragon::DECLARE_REGISTRY ( CNMLOperatorRegistry  ,
OperatorBase  ,
const OperatorDef &  ,
Workspace  
)

◆ DEFINE_ARG_WITH_DESC() [1/9]

dragon::DEFINE_ARG_WITH_DESC ( int64_t  ,
ArangeOp  ,
start   
)

◆ DEFINE_ARG_WITH_DESC() [2/9]

dragon::DEFINE_ARG_WITH_DESC ( int64_t  ,
ArangeOp  ,
stop   
)

◆ DEFINE_ARG_WITH_DESC() [3/9]

dragon::DEFINE_ARG_WITH_DESC ( int64_t  ,
ArangeOp  ,
step   
)

◆ DEFINE_ARG_WITH_DESC() [4/9]

dragon::DEFINE_ARG_WITH_DESC ( float  ,
DropPathOp  ,
prob   
)

◆ DEFINE_ARG_WITH_DESC() [5/9]

dragon::DEFINE_ARG_WITH_DESC ( int64_t  ,
RepeatOp  ,
repeats   
)

◆ DEFINE_ARG_WITH_DESC() [6/9]

dragon::DEFINE_ARG_WITH_DESC ( int64_t  ,
RepeatGradientOp  ,
repeats   
)

◆ DEFINE_ARG_WITH_DESC() [7/9]

dragon::DEFINE_ARG_WITH_DESC ( float  ,
DropoutOp  ,
prob   
)

◆ DEFINE_ARG_WITH_DESC() [8/9]

dragon::DEFINE_ARG_WITH_DESC ( float  ,
DropoutGradientOp  ,
prob   
)

◆ DEFINE_ARG_WITH_DESC() [9/9]

dragon::DEFINE_ARG_WITH_DESC ( float  ,
DropBlock2dOp  ,
keep_prob   
)

◆ DEFINE_ARGS_WITH_DESC() [1/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
AssignOp  ,
starts   
)

◆ DEFINE_ARGS_WITH_DESC() [2/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
AssignOp  ,
sizes   
)

◆ DEFINE_ARGS_WITH_DESC() [3/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
TransposeOp  ,
perm   
)

◆ DEFINE_ARGS_WITH_DESC() [4/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
TileOp  ,
multiples   
)

◆ DEFINE_ARGS_WITH_DESC() [5/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
TransposeGradientOp  ,
perm   
)

◆ DEFINE_ARGS_WITH_DESC() [6/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
TileGradientOp  ,
multiples   
)

◆ DEFINE_ARGS_WITH_DESC() [7/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
CropOp  ,
starts   
)

◆ DEFINE_ARGS_WITH_DESC() [8/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
CropOp  ,
sizes   
)

◆ DEFINE_ARGS_WITH_DESC() [9/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
BilinearResizeOp  ,
dsize   
)

◆ DEFINE_ARGS_WITH_DESC() [10/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
NNResizeOp  ,
dsize   
)

◆ DEFINE_ARGS_WITH_DESC() [11/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
ReshapeOp  ,
dims   
)

◆ DEFINE_ARGS_WITH_DESC() [12/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
ConvOpBase  ,
output_shape   
)

◆ DEFINE_ARGS_WITH_DESC() [13/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
ConvOpBase  ,
output_padding   
)

◆ DEFINE_ARGS_WITH_DESC() [14/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
InitializeOp  ,
dims   
)

◆ DEFINE_ARGS_WITH_DESC() [15/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
FillOp  ,
dims   
)

◆ DEFINE_ARGS_WITH_DESC() [16/16]

dragon::DEFINE_ARGS_WITH_DESC ( int64_t  ,
GivenTensorFillOp  ,
dims   
)

◆ DEFINE_DIMENSION_GRADIENT_OP() [1/4]

dragon::DEFINE_DIMENSION_GRADIENT_OP ( Reshape  )

◆ DEFINE_DIMENSION_GRADIENT_OP() [2/4]

dragon::DEFINE_DIMENSION_GRADIENT_OP ( Flatten  )

◆ DEFINE_DIMENSION_GRADIENT_OP() [3/4]

dragon::DEFINE_DIMENSION_GRADIENT_OP ( ExpandDims  )

◆ DEFINE_DIMENSION_GRADIENT_OP() [4/4]

dragon::DEFINE_DIMENSION_GRADIENT_OP ( Squeeze  )

◆ DEFINE_REGISTRY() [1/7]

dragon::DEFINE_REGISTRY ( GraphRegistry  ,
GraphBase  ,
const GraphDef &  ,
Workspace  
)

◆ DEFINE_REGISTRY() [2/7]

dragon::DEFINE_REGISTRY ( CPUOperatorRegistry  ,
OperatorBase  ,
const OperatorDef &  ,
Workspace  
)

◆ DEFINE_REGISTRY() [3/7]

dragon::DEFINE_REGISTRY ( CUDAOperatorRegistry  ,
OperatorBase  ,
const OperatorDef &  ,
Workspace  
)

◆ DEFINE_REGISTRY() [4/7]

dragon::DEFINE_REGISTRY ( CUDNNOperatorRegistry  ,
OperatorBase  ,
const OperatorDef &  ,
Workspace  
)

◆ DEFINE_REGISTRY() [5/7]

dragon::DEFINE_REGISTRY ( CNMLOperatorRegistry  ,
OperatorBase  ,
const OperatorDef &  ,
Workspace  
)

◆ DEFINE_REGISTRY() [6/7]

dragon::DEFINE_REGISTRY ( GradientRegistry  ,
GradientMakerBase  ,
const OperatorDef &  ,
const vector< string > &   
)

◆ DEFINE_REGISTRY() [7/7]

dragon::DEFINE_REGISTRY ( NoGradientRegistry  ,
GradientMakerBase  ,
const OperatorDef &  ,
const vector< string > &   
)

◆ DEFINE_TENSOR_TYPES_DISPATCHER()

dragon::DEFINE_TENSOR_TYPES_DISPATCHER ( TensorTypes  ,
RunImpl   
)

◆ DEPLOY_CPU() [1/185]

dragon::DEPLOY_CPU ( Recurrent  )

◆ DEPLOY_CPU() [2/185]

dragon::DEPLOY_CPU ( RecurrentGradient  )

◆ DEPLOY_CPU() [3/185]

dragon::DEPLOY_CPU ( Shape  )

◆ DEPLOY_CPU() [4/185]

dragon::DEPLOY_CPU ( Copy  )

◆ DEPLOY_CPU() [5/185]

dragon::DEPLOY_CPU ( RMSPropUpdate  )

◆ DEPLOY_CPU() [6/185]

dragon::DEPLOY_CPU ( ExpandDims  )

◆ DEPLOY_CPU() [7/185]

dragon::DEPLOY_CPU ( NesterovUpdate  )

◆ DEPLOY_CPU() [8/185]

dragon::DEPLOY_CPU ( CTCLoss  )

◆ DEPLOY_CPU() [9/185]

dragon::DEPLOY_CPU ( SGDUpdate  )

◆ DEPLOY_CPU() [10/185]

dragon::DEPLOY_CPU ( ExpandDimsGradient  )

◆ DEPLOY_CPU() [11/185]

dragon::DEPLOY_CPU ( Squeeze  )

◆ DEPLOY_CPU() [12/185]

dragon::DEPLOY_CPU ( CTCLossGradient  )

◆ DEPLOY_CPU() [13/185]

dragon::DEPLOY_CPU ( AdamUpdate  )

◆ DEPLOY_CPU() [14/185]

dragon::DEPLOY_CPU ( OneHot  )

◆ DEPLOY_CPU() [15/185]

dragon::DEPLOY_CPU ( SqueezeGradient  )

◆ DEPLOY_CPU() [16/185]

dragon::DEPLOY_CPU ( Log  )

◆ DEPLOY_CPU() [17/185]

dragon::DEPLOY_CPU ( Sqrt  )

◆ DEPLOY_CPU() [18/185]

dragon::DEPLOY_CPU ( Exp  )

◆ DEPLOY_CPU() [19/185]

dragon::DEPLOY_CPU ( Square  )

◆ DEPLOY_CPU() [20/185]

dragon::DEPLOY_CPU ( Sigmoid  )

◆ DEPLOY_CPU() [21/185]

dragon::DEPLOY_CPU ( Tanh  )

◆ DEPLOY_CPU() [22/185]

dragon::DEPLOY_CPU ( LogGradient  )

◆ DEPLOY_CPU() [23/185]

dragon::DEPLOY_CPU ( SqrtGradient  )

◆ DEPLOY_CPU() [24/185]

dragon::DEPLOY_CPU ( ExpGradient  )

◆ DEPLOY_CPU() [25/185]

dragon::DEPLOY_CPU ( Flatten  )

◆ DEPLOY_CPU() [26/185]

dragon::DEPLOY_CPU ( SquareGradient  )

◆ DEPLOY_CPU() [27/185]

dragon::DEPLOY_CPU ( SElu  )

◆ DEPLOY_CPU() [28/185]

dragon::DEPLOY_CPU ( Relu  )

◆ DEPLOY_CPU() [29/185]

dragon::DEPLOY_CPU ( SigmoidGradient  )

◆ DEPLOY_CPU() [30/185]

dragon::DEPLOY_CPU ( TanhGradient  )

◆ DEPLOY_CPU() [31/185]

dragon::DEPLOY_CPU ( Elu  )

◆ DEPLOY_CPU() [32/185]

dragon::DEPLOY_CPU ( Arange  )

◆ DEPLOY_CPU() [33/185]

dragon::DEPLOY_CPU ( FlattenGradient  )

◆ DEPLOY_CPU() [34/185]

dragon::DEPLOY_CPU ( SEluGradient  )

◆ DEPLOY_CPU() [35/185]

dragon::DEPLOY_CPU ( ReluGradient  )

◆ DEPLOY_CPU() [36/185]

dragon::DEPLOY_CPU ( EluGradient  )

◆ DEPLOY_CPU() [37/185]

dragon::DEPLOY_CPU ( RNNParamSet  )

◆ DEPLOY_CPU() [38/185]

dragon::DEPLOY_CPU ( NonZero  )

◆ DEPLOY_CPU() [39/185]

dragon::DEPLOY_CPU ( ImageData  )

◆ DEPLOY_CPU() [40/185]

dragon::DEPLOY_CPU ( MaskedSelect  )

◆ DEPLOY_CPU() [41/185]

dragon::DEPLOY_CPU ( Conv2d  )

◆ DEPLOY_CPU() [42/185]

dragon::DEPLOY_CPU ( Accumulate  )

◆ DEPLOY_CPU() [43/185]

dragon::DEPLOY_CPU ( Cast  )

◆ DEPLOY_CPU() [44/185]

dragon::DEPLOY_CPU ( MaskedSelectGradient  )

◆ DEPLOY_CPU() [45/185]

dragon::DEPLOY_CPU ( MPIBroadcast  )

◆ DEPLOY_CPU() [46/185]

dragon::DEPLOY_CPU ( Reshape  )

◆ DEPLOY_CPU() [47/185]

dragon::DEPLOY_CPU ( Conv2dGradient  )

◆ DEPLOY_CPU() [48/185]

dragon::DEPLOY_CPU ( MaskedAssign  )

◆ DEPLOY_CPU() [49/185]

dragon::DEPLOY_CPU ( CastGradient  )

◆ DEPLOY_CPU() [50/185]

dragon::DEPLOY_CPU ( MPIBroadcastGradient  )

◆ DEPLOY_CPU() [51/185]

dragon::DEPLOY_CPU ( ReshapeGradient  )

◆ DEPLOY_CPU() [52/185]

dragon::DEPLOY_CPU ( ConvTranspose2d  )

◆ DEPLOY_CPU() [53/185]

dragon::DEPLOY_CPU ( Accuracy  )

◆ DEPLOY_CPU() [54/185]

dragon::DEPLOY_CPU ( Clip  )

◆ DEPLOY_CPU() [55/185]

dragon::DEPLOY_CPU ( GramMatrix  )

◆ DEPLOY_CPU() [56/185]

dragon::DEPLOY_CPU ( ChannelShuffle  )

◆ DEPLOY_CPU() [57/185]

dragon::DEPLOY_CPU ( LSTMCell  )

◆ DEPLOY_CPU() [58/185]

dragon::DEPLOY_CPU ( ConvTranspose2dGradient  )

◆ DEPLOY_CPU() [59/185]

dragon::DEPLOY_CPU ( Dropout  )

◆ DEPLOY_CPU() [60/185]

dragon::DEPLOY_CPU ( ClipGradient  )

◆ DEPLOY_CPU() [61/185]

dragon::DEPLOY_CPU ( GramMatrixGradient  )

◆ DEPLOY_CPU() [62/185]

dragon::DEPLOY_CPU ( Moments  )

◆ DEPLOY_CPU() [63/185]

dragon::DEPLOY_CPU ( MPIGather  )

◆ DEPLOY_CPU() [64/185]

dragon::DEPLOY_CPU ( ChannelShuffleGradient  )

◆ DEPLOY_CPU() [65/185]

dragon::DEPLOY_CPU ( LSTMCellGradient  )

◆ DEPLOY_CPU() [66/185]

dragon::DEPLOY_CPU ( Softmax  )

◆ DEPLOY_CPU() [67/185]

dragon::DEPLOY_CPU ( DropoutGradient  )

◆ DEPLOY_CPU() [68/185]

dragon::DEPLOY_CPU ( Pow  )

◆ DEPLOY_CPU() [69/185]

dragon::DEPLOY_CPU ( Repeat  )

◆ DEPLOY_CPU() [70/185]

dragon::DEPLOY_CPU ( MPIGatherGradient  )

◆ DEPLOY_CPU() [71/185]

dragon::DEPLOY_CPU ( BilinearResize  )

◆ DEPLOY_CPU() [72/185]

dragon::DEPLOY_CPU ( SoftmaxGradient  )

◆ DEPLOY_CPU() [73/185]

dragon::DEPLOY_CPU ( Multinomial  )

◆ DEPLOY_CPU() [74/185]

dragon::DEPLOY_CPU ( PowGradient  )

◆ DEPLOY_CPU() [75/185]

dragon::DEPLOY_CPU ( RepeatGradient  )

◆ DEPLOY_CPU() [76/185]

dragon::DEPLOY_CPU ( Stack  )

◆ DEPLOY_CPU() [77/185]

dragon::DEPLOY_CPU ( GradientGenerate  )

◆ DEPLOY_CPU() [78/185]

dragon::DEPLOY_CPU ( DropPath  )

◆ DEPLOY_CPU() [79/185]

dragon::DEPLOY_CPU ( BilinearResizeGradient  )

◆ DEPLOY_CPU() [80/185]

dragon::DEPLOY_CPU ( PRelu  )

◆ DEPLOY_CPU() [81/185]

dragon::DEPLOY_CPU ( DepthwiseConv2d  )

◆ DEPLOY_CPU() [82/185]

dragon::DEPLOY_CPU ( IndexSelect  )

◆ DEPLOY_CPU() [83/185]

dragon::DEPLOY_CPU ( StackGradient  )

◆ DEPLOY_CPU() [84/185]

dragon::DEPLOY_CPU ( GradientGather  )

◆ DEPLOY_CPU() [85/185]

dragon::DEPLOY_CPU ( DropPathGradient  )

◆ DEPLOY_CPU() [86/185]

dragon::DEPLOY_CPU ( BiasAdd  )

◆ DEPLOY_CPU() [87/185]

dragon::DEPLOY_CPU ( PReluGradient  )

◆ DEPLOY_CPU() [88/185]

dragon::DEPLOY_CPU ( DepthwiseConv2dGradient  )

◆ DEPLOY_CPU() [89/185]

dragon::DEPLOY_CPU ( IndexSelectGradient  )

◆ DEPLOY_CPU() [90/185]

dragon::DEPLOY_CPU ( GradientAdd  )

◆ DEPLOY_CPU() [91/185]

dragon::DEPLOY_CPU ( L1Loss  )

◆ DEPLOY_CPU() [92/185]

dragon::DEPLOY_CPU ( Concat  )

◆ DEPLOY_CPU() [93/185]

dragon::DEPLOY_CPU ( L2Loss  )

◆ DEPLOY_CPU() [94/185]

dragon::DEPLOY_CPU ( Compare  )

◆ DEPLOY_CPU() [95/185]

dragon::DEPLOY_CPU ( BiasAddGradient  )

◆ DEPLOY_CPU() [96/185]

dragon::DEPLOY_CPU ( ArgReduce  )

◆ DEPLOY_CPU() [97/185]

dragon::DEPLOY_CPU ( StopGradient  )

◆ DEPLOY_CPU() [98/185]

dragon::DEPLOY_CPU ( L1LossGradient  )

◆ DEPLOY_CPU() [99/185]

dragon::DEPLOY_CPU ( ConcatGradient  )

◆ DEPLOY_CPU() [100/185]

dragon::DEPLOY_CPU ( L2LossGradient  )

◆ DEPLOY_CPU() [101/185]

dragon::DEPLOY_CPU ( SmoothL1Loss  )

◆ DEPLOY_CPU() [102/185]

dragon::DEPLOY_CPU ( SigmoidCrossEntropy  )

◆ DEPLOY_CPU() [103/185]

dragon::DEPLOY_CPU ( Transpose  )

◆ DEPLOY_CPU() [104/185]

dragon::DEPLOY_CPU ( RSub  )

◆ DEPLOY_CPU() [105/185]

dragon::DEPLOY_CPU ( Sub  )

◆ DEPLOY_CPU() [106/185]

dragon::DEPLOY_CPU ( Add  )

◆ DEPLOY_CPU() [107/185]

dragon::DEPLOY_CPU ( RAdd  )

◆ DEPLOY_CPU() [108/185]

dragon::DEPLOY_CPU ( SmoothL1LossGradient  )

◆ DEPLOY_CPU() [109/185]

dragon::DEPLOY_CPU ( ROIAlign  )

◆ DEPLOY_CPU() [110/185]

dragon::DEPLOY_CPU ( SigmoidCrossEntropyGradient  )

◆ DEPLOY_CPU() [111/185]

dragon::DEPLOY_CPU ( TransposeGradient  )

◆ DEPLOY_CPU() [112/185]

dragon::DEPLOY_CPU ( RSubGradient  )

◆ DEPLOY_CPU() [113/185]

dragon::DEPLOY_CPU ( SubGradient  )

◆ DEPLOY_CPU() [114/185]

dragon::DEPLOY_CPU ( AddGradient  )

◆ DEPLOY_CPU() [115/185]

dragon::DEPLOY_CPU ( RAddGradient  )

◆ DEPLOY_CPU() [116/185]

dragon::DEPLOY_CPU ( ROIAlignGradient  )

◆ DEPLOY_CPU() [117/185]

dragon::DEPLOY_CPU ( Slice  )

◆ DEPLOY_CPU() [118/185]

dragon::DEPLOY_CPU ( Mul  )

◆ DEPLOY_CPU() [119/185]

dragon::DEPLOY_CPU ( RMul  )

◆ DEPLOY_CPU() [120/185]

dragon::DEPLOY_CPU ( ROIPool  )

◆ DEPLOY_CPU() [121/185]

dragon::DEPLOY_CPU ( Assign  )

◆ DEPLOY_CPU() [122/185]

dragon::DEPLOY_CPU ( Eltwise  )

◆ DEPLOY_CPU() [123/185]

dragon::DEPLOY_CPU ( RMulGradient  )

◆ DEPLOY_CPU() [124/185]

dragon::DEPLOY_CPU ( SliceGradient  )

◆ DEPLOY_CPU() [125/185]

dragon::DEPLOY_CPU ( Tile  )

◆ DEPLOY_CPU() [126/185]

dragon::DEPLOY_CPU ( MulGradient  )

◆ DEPLOY_CPU() [127/185]

dragon::DEPLOY_CPU ( ROIPoolGradient  )

◆ DEPLOY_CPU() [128/185]

dragon::DEPLOY_CPU ( EltwiseGradient  )

◆ DEPLOY_CPU() [129/185]

dragon::DEPLOY_CPU ( TileGradient  )

◆ DEPLOY_CPU() [130/185]

dragon::DEPLOY_CPU ( Affine  )

◆ DEPLOY_CPU() [131/185]

dragon::DEPLOY_CPU ( RDiv  )

◆ DEPLOY_CPU() [132/185]

dragon::DEPLOY_CPU ( Div  )

◆ DEPLOY_CPU() [133/185]

dragon::DEPLOY_CPU ( Maximum  )

◆ DEPLOY_CPU() [134/185]

dragon::DEPLOY_CPU ( Minimum  )

◆ DEPLOY_CPU() [135/185]

dragon::DEPLOY_CPU ( Fill  )

◆ DEPLOY_CPU() [136/185]

dragon::DEPLOY_CPU ( AffineGradient  )

◆ DEPLOY_CPU() [137/185]

dragon::DEPLOY_CPU ( RDivGradient  )

◆ DEPLOY_CPU() [138/185]

dragon::DEPLOY_CPU ( DropBlock2d  )

◆ DEPLOY_CPU() [139/185]

dragon::DEPLOY_CPU ( DivGradient  )

◆ DEPLOY_CPU() [140/185]

dragon::DEPLOY_CPU ( MaximumGradient  )

◆ DEPLOY_CPU() [141/185]

dragon::DEPLOY_CPU ( MinimumGradient  )

◆ DEPLOY_CPU() [142/185]

dragon::DEPLOY_CPU ( GivenTensorFill  )

◆ DEPLOY_CPU() [143/185]

dragon::DEPLOY_CPU ( NNResize  )

◆ DEPLOY_CPU() [144/185]

dragon::DEPLOY_CPU ( Reduce  )

◆ DEPLOY_CPU() [145/185]

dragon::DEPLOY_CPU ( RandomUniform  )

◆ DEPLOY_CPU() [146/185]

dragon::DEPLOY_CPU ( NNResizeGradient  )

◆ DEPLOY_CPU() [147/185]

dragon::DEPLOY_CPU ( ReduceGradient  )

◆ DEPLOY_CPU() [148/185]

dragon::DEPLOY_CPU ( RandomNormal  )

◆ DEPLOY_CPU() [149/185]

dragon::DEPLOY_CPU ( DropBlock2dGradient  )

◆ DEPLOY_CPU() [150/185]

dragon::DEPLOY_CPU ( SoftmaxCrossEntropy  )

◆ DEPLOY_CPU() [151/185]

dragon::DEPLOY_CPU ( GlorotUniform  )

◆ DEPLOY_CPU() [152/185]

dragon::DEPLOY_CPU ( SoftmaxCrossEntropyGradient  )

◆ DEPLOY_CPU() [153/185]

dragon::DEPLOY_CPU ( SigmoidFocalLoss  )

◆ DEPLOY_CPU() [154/185]

dragon::DEPLOY_CPU ( GlorotNormal  )

◆ DEPLOY_CPU() [155/185]

dragon::DEPLOY_CPU ( SigmoidFocalLossGradient  )

◆ DEPLOY_CPU() [156/185]

dragon::DEPLOY_CPU ( L2Norm  )

◆ DEPLOY_CPU() [157/185]

dragon::DEPLOY_CPU ( GroupNorm  )

◆ DEPLOY_CPU() [158/185]

dragon::DEPLOY_CPU ( L2NormGradient  )

◆ DEPLOY_CPU() [159/185]

dragon::DEPLOY_CPU ( Where  )

◆ DEPLOY_CPU() [160/185]

dragon::DEPLOY_CPU ( Matmul  )

◆ DEPLOY_CPU() [161/185]

dragon::DEPLOY_CPU ( NLLLoss  )

◆ DEPLOY_CPU() [162/185]

dragon::DEPLOY_CPU ( GroupNormGradient  )

◆ DEPLOY_CPU() [163/185]

dragon::DEPLOY_CPU ( WhereGradient  )

◆ DEPLOY_CPU() [164/185]

dragon::DEPLOY_CPU ( MatmulGradient  )

◆ DEPLOY_CPU() [165/185]

dragon::DEPLOY_CPU ( NLLLossGradient  )

◆ DEPLOY_CPU() [166/185]

dragon::DEPLOY_CPU ( SoftmaxFocalLoss  )

◆ DEPLOY_CPU() [167/185]

dragon::DEPLOY_CPU ( CollectiveUpdate  )

◆ DEPLOY_CPU() [168/185]

dragon::DEPLOY_CPU ( Crop  )

◆ DEPLOY_CPU() [169/185]

dragon::DEPLOY_CPU ( SoftmaxFocalLossGradient  )

◆ DEPLOY_CPU() [170/185]

dragon::DEPLOY_CPU ( Pad  )

◆ DEPLOY_CPU() [171/185]

dragon::DEPLOY_CPU ( FullyConnected  )

◆ DEPLOY_CPU() [172/185]

dragon::DEPLOY_CPU ( CropGradient  )

◆ DEPLOY_CPU() [173/185]

dragon::DEPLOY_CPU ( SparseSoftmaxCrossEntropy  )

◆ DEPLOY_CPU() [174/185]

dragon::DEPLOY_CPU ( PadGradient  )

◆ DEPLOY_CPU() [175/185]

dragon::DEPLOY_CPU ( FullyConnectedGradient  )

◆ DEPLOY_CPU() [176/185]

dragon::DEPLOY_CPU ( Pool2d  )

◆ DEPLOY_CPU() [177/185]

dragon::DEPLOY_CPU ( SparseSoftmaxCrossEntropyGradient  )

◆ DEPLOY_CPU() [178/185]

dragon::DEPLOY_CPU ( Pool2dGradient  )

◆ DEPLOY_CPU() [179/185]

dragon::DEPLOY_CPU ( LRN  )

◆ DEPLOY_CPU() [180/185]

dragon::DEPLOY_CPU ( LRNGradient  )

◆ DEPLOY_CPU() [181/185]

dragon::DEPLOY_CPU ( BatchNorm  )

◆ DEPLOY_CPU() [182/185]

dragon::DEPLOY_CPU ( BatchNormGradient  )

◆ DEPLOY_CPU() [183/185]

dragon::DEPLOY_CPU ( Dot  )

◆ DEPLOY_CPU() [184/185]

dragon::DEPLOY_CPU ( DotGradient  )

◆ DEPLOY_CPU() [185/185]

dragon::DEPLOY_CPU ( Proposal  )

◆ DEPLOY_CPU_CUDA()

dragon::DEPLOY_CPU_CUDA ( TruncatedNormal  )

◆ DEPLOY_CUDA() [1/185]

dragon::DEPLOY_CUDA ( Recurrent  )

◆ DEPLOY_CUDA() [2/185]

dragon::DEPLOY_CUDA ( RecurrentGradient  )

◆ DEPLOY_CUDA() [3/185]

dragon::DEPLOY_CUDA ( Shape  )

◆ DEPLOY_CUDA() [4/185]

dragon::DEPLOY_CUDA ( Copy  )

◆ DEPLOY_CUDA() [5/185]

dragon::DEPLOY_CUDA ( RMSPropUpdate  )

◆ DEPLOY_CUDA() [6/185]

dragon::DEPLOY_CUDA ( ExpandDims  )

◆ DEPLOY_CUDA() [7/185]

dragon::DEPLOY_CUDA ( NesterovUpdate  )

◆ DEPLOY_CUDA() [8/185]

dragon::DEPLOY_CUDA ( CTCLoss  )

◆ DEPLOY_CUDA() [9/185]

dragon::DEPLOY_CUDA ( SGDUpdate  )

◆ DEPLOY_CUDA() [10/185]

dragon::DEPLOY_CUDA ( ExpandDimsGradient  )

◆ DEPLOY_CUDA() [11/185]

dragon::DEPLOY_CUDA ( Squeeze  )

◆ DEPLOY_CUDA() [12/185]

dragon::DEPLOY_CUDA ( CTCLossGradient  )

◆ DEPLOY_CUDA() [13/185]

dragon::DEPLOY_CUDA ( AdamUpdate  )

◆ DEPLOY_CUDA() [14/185]

dragon::DEPLOY_CUDA ( OneHot  )

◆ DEPLOY_CUDA() [15/185]

dragon::DEPLOY_CUDA ( SqueezeGradient  )

◆ DEPLOY_CUDA() [16/185]

dragon::DEPLOY_CUDA ( Log  )

◆ DEPLOY_CUDA() [17/185]

dragon::DEPLOY_CUDA ( Sqrt  )

◆ DEPLOY_CUDA() [18/185]

dragon::DEPLOY_CUDA ( Exp  )

◆ DEPLOY_CUDA() [19/185]

dragon::DEPLOY_CUDA ( Square  )

◆ DEPLOY_CUDA() [20/185]

dragon::DEPLOY_CUDA ( Sigmoid  )

◆ DEPLOY_CUDA() [21/185]

dragon::DEPLOY_CUDA ( Tanh  )

◆ DEPLOY_CUDA() [22/185]

dragon::DEPLOY_CUDA ( LogGradient  )

◆ DEPLOY_CUDA() [23/185]

dragon::DEPLOY_CUDA ( SqrtGradient  )

◆ DEPLOY_CUDA() [24/185]

dragon::DEPLOY_CUDA ( ExpGradient  )

◆ DEPLOY_CUDA() [25/185]

dragon::DEPLOY_CUDA ( Flatten  )

◆ DEPLOY_CUDA() [26/185]

dragon::DEPLOY_CUDA ( SquareGradient  )

◆ DEPLOY_CUDA() [27/185]

dragon::DEPLOY_CUDA ( SElu  )

◆ DEPLOY_CUDA() [28/185]

dragon::DEPLOY_CUDA ( Relu  )

◆ DEPLOY_CUDA() [29/185]

dragon::DEPLOY_CUDA ( TanhGradient  )

◆ DEPLOY_CUDA() [30/185]

dragon::DEPLOY_CUDA ( SigmoidGradient  )

◆ DEPLOY_CUDA() [31/185]

dragon::DEPLOY_CUDA ( Elu  )

◆ DEPLOY_CUDA() [32/185]

dragon::DEPLOY_CUDA ( Arange  )

◆ DEPLOY_CUDA() [33/185]

dragon::DEPLOY_CUDA ( FlattenGradient  )

◆ DEPLOY_CUDA() [34/185]

dragon::DEPLOY_CUDA ( SEluGradient  )

◆ DEPLOY_CUDA() [35/185]

dragon::DEPLOY_CUDA ( EluGradient  )

◆ DEPLOY_CUDA() [36/185]

dragon::DEPLOY_CUDA ( ReluGradient  )

◆ DEPLOY_CUDA() [37/185]

dragon::DEPLOY_CUDA ( RNNParamSet  )

◆ DEPLOY_CUDA() [38/185]

dragon::DEPLOY_CUDA ( NonZero  )

◆ DEPLOY_CUDA() [39/185]

dragon::DEPLOY_CUDA ( ImageData  )

◆ DEPLOY_CUDA() [40/185]

dragon::DEPLOY_CUDA ( MaskedSelect  )

◆ DEPLOY_CUDA() [41/185]

dragon::DEPLOY_CUDA ( Conv2d  )

◆ DEPLOY_CUDA() [42/185]

dragon::DEPLOY_CUDA ( Accumulate  )

◆ DEPLOY_CUDA() [43/185]

dragon::DEPLOY_CUDA ( Cast  )

◆ DEPLOY_CUDA() [44/185]

dragon::DEPLOY_CUDA ( MaskedSelectGradient  )

◆ DEPLOY_CUDA() [45/185]

dragon::DEPLOY_CUDA ( MPIBroadcast  )

◆ DEPLOY_CUDA() [46/185]

dragon::DEPLOY_CUDA ( Reshape  )

◆ DEPLOY_CUDA() [47/185]

dragon::DEPLOY_CUDA ( Conv2dGradient  )

◆ DEPLOY_CUDA() [48/185]

dragon::DEPLOY_CUDA ( MaskedAssign  )

◆ DEPLOY_CUDA() [49/185]

dragon::DEPLOY_CUDA ( CastGradient  )

◆ DEPLOY_CUDA() [50/185]

dragon::DEPLOY_CUDA ( MPIBroadcastGradient  )

◆ DEPLOY_CUDA() [51/185]

dragon::DEPLOY_CUDA ( ReshapeGradient  )

◆ DEPLOY_CUDA() [52/185]

dragon::DEPLOY_CUDA ( ConvTranspose2d  )

◆ DEPLOY_CUDA() [53/185]

dragon::DEPLOY_CUDA ( Accuracy  )

◆ DEPLOY_CUDA() [54/185]

dragon::DEPLOY_CUDA ( Clip  )

◆ DEPLOY_CUDA() [55/185]

dragon::DEPLOY_CUDA ( GramMatrix  )

◆ DEPLOY_CUDA() [56/185]

dragon::DEPLOY_CUDA ( ChannelShuffle  )

◆ DEPLOY_CUDA() [57/185]

dragon::DEPLOY_CUDA ( LSTMCell  )

◆ DEPLOY_CUDA() [58/185]

dragon::DEPLOY_CUDA ( ConvTranspose2dGradient  )

◆ DEPLOY_CUDA() [59/185]

dragon::DEPLOY_CUDA ( Dropout  )

◆ DEPLOY_CUDA() [60/185]

dragon::DEPLOY_CUDA ( ClipGradient  )

◆ DEPLOY_CUDA() [61/185]

dragon::DEPLOY_CUDA ( GramMatrixGradient  )

◆ DEPLOY_CUDA() [62/185]

dragon::DEPLOY_CUDA ( Moments  )

◆ DEPLOY_CUDA() [63/185]

dragon::DEPLOY_CUDA ( MPIGather  )

◆ DEPLOY_CUDA() [64/185]

dragon::DEPLOY_CUDA ( ChannelShuffleGradient  )

◆ DEPLOY_CUDA() [65/185]

dragon::DEPLOY_CUDA ( LSTMCellGradient  )

◆ DEPLOY_CUDA() [66/185]

dragon::DEPLOY_CUDA ( Softmax  )

◆ DEPLOY_CUDA() [67/185]

dragon::DEPLOY_CUDA ( DropoutGradient  )

◆ DEPLOY_CUDA() [68/185]

dragon::DEPLOY_CUDA ( Pow  )

◆ DEPLOY_CUDA() [69/185]

dragon::DEPLOY_CUDA ( Repeat  )

◆ DEPLOY_CUDA() [70/185]

dragon::DEPLOY_CUDA ( MPIGatherGradient  )

◆ DEPLOY_CUDA() [71/185]

dragon::DEPLOY_CUDA ( BilinearResize  )

◆ DEPLOY_CUDA() [72/185]

dragon::DEPLOY_CUDA ( SoftmaxGradient  )

◆ DEPLOY_CUDA() [73/185]

dragon::DEPLOY_CUDA ( Multinomial  )

◆ DEPLOY_CUDA() [74/185]

dragon::DEPLOY_CUDA ( PowGradient  )

◆ DEPLOY_CUDA() [75/185]

dragon::DEPLOY_CUDA ( RepeatGradient  )

◆ DEPLOY_CUDA() [76/185]

dragon::DEPLOY_CUDA ( Stack  )

◆ DEPLOY_CUDA() [77/185]

dragon::DEPLOY_CUDA ( GradientGenerate  )

◆ DEPLOY_CUDA() [78/185]

dragon::DEPLOY_CUDA ( DropPath  )

◆ DEPLOY_CUDA() [79/185]

dragon::DEPLOY_CUDA ( BilinearResizeGradient  )

◆ DEPLOY_CUDA() [80/185]

dragon::DEPLOY_CUDA ( PRelu  )

◆ DEPLOY_CUDA() [81/185]

dragon::DEPLOY_CUDA ( IndexSelect  )

◆ DEPLOY_CUDA() [82/185]

dragon::DEPLOY_CUDA ( StackGradient  )

◆ DEPLOY_CUDA() [83/185]

dragon::DEPLOY_CUDA ( DepthwiseConv2d  )

◆ DEPLOY_CUDA() [84/185]

dragon::DEPLOY_CUDA ( GradientGather  )

◆ DEPLOY_CUDA() [85/185]

dragon::DEPLOY_CUDA ( DropPathGradient  )

◆ DEPLOY_CUDA() [86/185]

dragon::DEPLOY_CUDA ( BiasAdd  )

◆ DEPLOY_CUDA() [87/185]

dragon::DEPLOY_CUDA ( PReluGradient  )

◆ DEPLOY_CUDA() [88/185]

dragon::DEPLOY_CUDA ( IndexSelectGradient  )

◆ DEPLOY_CUDA() [89/185]

dragon::DEPLOY_CUDA ( DepthwiseConv2dGradient  )

◆ DEPLOY_CUDA() [90/185]

dragon::DEPLOY_CUDA ( GradientAdd  )

◆ DEPLOY_CUDA() [91/185]

dragon::DEPLOY_CUDA ( L1Loss  )

◆ DEPLOY_CUDA() [92/185]

dragon::DEPLOY_CUDA ( Concat  )

◆ DEPLOY_CUDA() [93/185]

dragon::DEPLOY_CUDA ( L2Loss  )

◆ DEPLOY_CUDA() [94/185]

dragon::DEPLOY_CUDA ( Compare  )

◆ DEPLOY_CUDA() [95/185]

dragon::DEPLOY_CUDA ( BiasAddGradient  )

◆ DEPLOY_CUDA() [96/185]

dragon::DEPLOY_CUDA ( ArgReduce  )

◆ DEPLOY_CUDA() [97/185]

dragon::DEPLOY_CUDA ( StopGradient  )

◆ DEPLOY_CUDA() [98/185]

dragon::DEPLOY_CUDA ( L1LossGradient  )

◆ DEPLOY_CUDA() [99/185]

dragon::DEPLOY_CUDA ( ConcatGradient  )

◆ DEPLOY_CUDA() [100/185]

dragon::DEPLOY_CUDA ( L2LossGradient  )

◆ DEPLOY_CUDA() [101/185]

dragon::DEPLOY_CUDA ( SmoothL1Loss  )

◆ DEPLOY_CUDA() [102/185]

dragon::DEPLOY_CUDA ( SigmoidCrossEntropy  )

◆ DEPLOY_CUDA() [103/185]

dragon::DEPLOY_CUDA ( Transpose  )

◆ DEPLOY_CUDA() [104/185]

dragon::DEPLOY_CUDA ( Sub  )

◆ DEPLOY_CUDA() [105/185]

dragon::DEPLOY_CUDA ( Add  )

◆ DEPLOY_CUDA() [106/185]

dragon::DEPLOY_CUDA ( RSub  )

◆ DEPLOY_CUDA() [107/185]

dragon::DEPLOY_CUDA ( RAdd  )

◆ DEPLOY_CUDA() [108/185]

dragon::DEPLOY_CUDA ( SmoothL1LossGradient  )

◆ DEPLOY_CUDA() [109/185]

dragon::DEPLOY_CUDA ( ROIAlign  )

◆ DEPLOY_CUDA() [110/185]

dragon::DEPLOY_CUDA ( SigmoidCrossEntropyGradient  )

◆ DEPLOY_CUDA() [111/185]

dragon::DEPLOY_CUDA ( TransposeGradient  )

◆ DEPLOY_CUDA() [112/185]

dragon::DEPLOY_CUDA ( RSubGradient  )

◆ DEPLOY_CUDA() [113/185]

dragon::DEPLOY_CUDA ( SubGradient  )

◆ DEPLOY_CUDA() [114/185]

dragon::DEPLOY_CUDA ( AddGradient  )

◆ DEPLOY_CUDA() [115/185]

dragon::DEPLOY_CUDA ( RAddGradient  )

◆ DEPLOY_CUDA() [116/185]

dragon::DEPLOY_CUDA ( ROIAlignGradient  )

◆ DEPLOY_CUDA() [117/185]

dragon::DEPLOY_CUDA ( Slice  )

◆ DEPLOY_CUDA() [118/185]

dragon::DEPLOY_CUDA ( RMul  )

◆ DEPLOY_CUDA() [119/185]

dragon::DEPLOY_CUDA ( Mul  )

◆ DEPLOY_CUDA() [120/185]

dragon::DEPLOY_CUDA ( ROIPool  )

◆ DEPLOY_CUDA() [121/185]

dragon::DEPLOY_CUDA ( Assign  )

◆ DEPLOY_CUDA() [122/185]

dragon::DEPLOY_CUDA ( Eltwise  )

◆ DEPLOY_CUDA() [123/185]

dragon::DEPLOY_CUDA ( RMulGradient  )

◆ DEPLOY_CUDA() [124/185]

dragon::DEPLOY_CUDA ( SliceGradient  )

◆ DEPLOY_CUDA() [125/185]

dragon::DEPLOY_CUDA ( Tile  )

◆ DEPLOY_CUDA() [126/185]

dragon::DEPLOY_CUDA ( MulGradient  )

◆ DEPLOY_CUDA() [127/185]

dragon::DEPLOY_CUDA ( ROIPoolGradient  )

◆ DEPLOY_CUDA() [128/185]

dragon::DEPLOY_CUDA ( EltwiseGradient  )

◆ DEPLOY_CUDA() [129/185]

dragon::DEPLOY_CUDA ( TileGradient  )

◆ DEPLOY_CUDA() [130/185]

dragon::DEPLOY_CUDA ( Affine  )

◆ DEPLOY_CUDA() [131/185]

dragon::DEPLOY_CUDA ( RDiv  )

◆ DEPLOY_CUDA() [132/185]

dragon::DEPLOY_CUDA ( Div  )

◆ DEPLOY_CUDA() [133/185]

dragon::DEPLOY_CUDA ( Maximum  )

◆ DEPLOY_CUDA() [134/185]

dragon::DEPLOY_CUDA ( Minimum  )

◆ DEPLOY_CUDA() [135/185]

dragon::DEPLOY_CUDA ( Fill  )

◆ DEPLOY_CUDA() [136/185]

dragon::DEPLOY_CUDA ( AffineGradient  )

◆ DEPLOY_CUDA() [137/185]

dragon::DEPLOY_CUDA ( RDivGradient  )

◆ DEPLOY_CUDA() [138/185]

dragon::DEPLOY_CUDA ( DropBlock2d  )

◆ DEPLOY_CUDA() [139/185]

dragon::DEPLOY_CUDA ( GivenTensorFill  )

◆ DEPLOY_CUDA() [140/185]

dragon::DEPLOY_CUDA ( DivGradient  )

◆ DEPLOY_CUDA() [141/185]

dragon::DEPLOY_CUDA ( MaximumGradient  )

◆ DEPLOY_CUDA() [142/185]

dragon::DEPLOY_CUDA ( MinimumGradient  )

◆ DEPLOY_CUDA() [143/185]

dragon::DEPLOY_CUDA ( Reduce  )

◆ DEPLOY_CUDA() [144/185]

dragon::DEPLOY_CUDA ( NNResize  )

◆ DEPLOY_CUDA() [145/185]

dragon::DEPLOY_CUDA ( RandomUniform  )

◆ DEPLOY_CUDA() [146/185]

dragon::DEPLOY_CUDA ( NNResizeGradient  )

◆ DEPLOY_CUDA() [147/185]

dragon::DEPLOY_CUDA ( ReduceGradient  )

◆ DEPLOY_CUDA() [148/185]

dragon::DEPLOY_CUDA ( RandomNormal  )

◆ DEPLOY_CUDA() [149/185]

dragon::DEPLOY_CUDA ( DropBlock2dGradient  )

◆ DEPLOY_CUDA() [150/185]

dragon::DEPLOY_CUDA ( SoftmaxCrossEntropy  )

◆ DEPLOY_CUDA() [151/185]

dragon::DEPLOY_CUDA ( GlorotUniform  )

◆ DEPLOY_CUDA() [152/185]

dragon::DEPLOY_CUDA ( SoftmaxCrossEntropyGradient  )

◆ DEPLOY_CUDA() [153/185]

dragon::DEPLOY_CUDA ( GlorotNormal  )

◆ DEPLOY_CUDA() [154/185]

dragon::DEPLOY_CUDA ( SigmoidFocalLoss  )

◆ DEPLOY_CUDA() [155/185]

dragon::DEPLOY_CUDA ( SigmoidFocalLossGradient  )

◆ DEPLOY_CUDA() [156/185]

dragon::DEPLOY_CUDA ( L2Norm  )

◆ DEPLOY_CUDA() [157/185]

dragon::DEPLOY_CUDA ( GroupNorm  )

◆ DEPLOY_CUDA() [158/185]

dragon::DEPLOY_CUDA ( L2NormGradient  )

◆ DEPLOY_CUDA() [159/185]

dragon::DEPLOY_CUDA ( Where  )

◆ DEPLOY_CUDA() [160/185]

dragon::DEPLOY_CUDA ( Matmul  )

◆ DEPLOY_CUDA() [161/185]

dragon::DEPLOY_CUDA ( NLLLoss  )

◆ DEPLOY_CUDA() [162/185]

dragon::DEPLOY_CUDA ( GroupNormGradient  )

◆ DEPLOY_CUDA() [163/185]

dragon::DEPLOY_CUDA ( WhereGradient  )

◆ DEPLOY_CUDA() [164/185]

dragon::DEPLOY_CUDA ( MatmulGradient  )

◆ DEPLOY_CUDA() [165/185]

dragon::DEPLOY_CUDA ( NLLLossGradient  )

◆ DEPLOY_CUDA() [166/185]

dragon::DEPLOY_CUDA ( SoftmaxFocalLoss  )

◆ DEPLOY_CUDA() [167/185]

dragon::DEPLOY_CUDA ( Crop  )

◆ DEPLOY_CUDA() [168/185]

dragon::DEPLOY_CUDA ( SoftmaxFocalLossGradient  )

◆ DEPLOY_CUDA() [169/185]

dragon::DEPLOY_CUDA ( CollectiveUpdate  )

◆ DEPLOY_CUDA() [170/185]

dragon::DEPLOY_CUDA ( Pad  )

◆ DEPLOY_CUDA() [171/185]

dragon::DEPLOY_CUDA ( FullyConnected  )

◆ DEPLOY_CUDA() [172/185]

dragon::DEPLOY_CUDA ( CropGradient  )

◆ DEPLOY_CUDA() [173/185]

dragon::DEPLOY_CUDA ( SparseSoftmaxCrossEntropy  )

◆ DEPLOY_CUDA() [174/185]

dragon::DEPLOY_CUDA ( FullyConnectedGradient  )

◆ DEPLOY_CUDA() [175/185]

dragon::DEPLOY_CUDA ( PadGradient  )

◆ DEPLOY_CUDA() [176/185]

dragon::DEPLOY_CUDA ( Pool2d  )

◆ DEPLOY_CUDA() [177/185]

dragon::DEPLOY_CUDA ( SparseSoftmaxCrossEntropyGradient  )

◆ DEPLOY_CUDA() [178/185]

dragon::DEPLOY_CUDA ( Pool2dGradient  )

◆ DEPLOY_CUDA() [179/185]

dragon::DEPLOY_CUDA ( LRN  )

◆ DEPLOY_CUDA() [180/185]

dragon::DEPLOY_CUDA ( LRNGradient  )

◆ DEPLOY_CUDA() [181/185]

dragon::DEPLOY_CUDA ( BatchNorm  )

◆ DEPLOY_CUDA() [182/185]

dragon::DEPLOY_CUDA ( BatchNormGradient  )

◆ DEPLOY_CUDA() [183/185]

dragon::DEPLOY_CUDA ( Dot  )

◆ DEPLOY_CUDA() [184/185]

dragon::DEPLOY_CUDA ( DotGradient  )

◆ DEPLOY_CUDA() [185/185]

dragon::DEPLOY_CUDA ( Proposal  )

◆ DEPLOY_CUDNN() [1/20]

dragon::DEPLOY_CUDNN ( Sigmoid  )

◆ DEPLOY_CUDNN() [2/20]

dragon::DEPLOY_CUDNN ( Tanh  )

◆ DEPLOY_CUDNN() [3/20]

dragon::DEPLOY_CUDNN ( SigmoidGradient  )

◆ DEPLOY_CUDNN() [4/20]

dragon::DEPLOY_CUDNN ( TanhGradient  )

◆ DEPLOY_CUDNN() [5/20]

dragon::DEPLOY_CUDNN ( LRN  )

◆ DEPLOY_CUDNN() [6/20]

dragon::DEPLOY_CUDNN ( LRNGradient  )

◆ DEPLOY_CUDNN() [7/20]

dragon::DEPLOY_CUDNN ( Softmax  )

◆ DEPLOY_CUDNN() [8/20]

dragon::DEPLOY_CUDNN ( Relu  )

◆ DEPLOY_CUDNN() [9/20]

dragon::DEPLOY_CUDNN ( SoftmaxGradient  )

◆ DEPLOY_CUDNN() [10/20]

dragon::DEPLOY_CUDNN ( ReluGradient  )

◆ DEPLOY_CUDNN() [11/20]

dragon::DEPLOY_CUDNN ( Pool2d  )

◆ DEPLOY_CUDNN() [12/20]

dragon::DEPLOY_CUDNN ( Pool2dGradient  )

◆ DEPLOY_CUDNN() [13/20]

dragon::DEPLOY_CUDNN ( BiasAdd  )

◆ DEPLOY_CUDNN() [14/20]

dragon::DEPLOY_CUDNN ( BiasAddGradient  )

◆ DEPLOY_CUDNN() [15/20]

dragon::DEPLOY_CUDNN ( DepthwiseConv2d  )

◆ DEPLOY_CUDNN() [16/20]

dragon::DEPLOY_CUDNN ( DepthwiseConv2dGradient  )

◆ DEPLOY_CUDNN() [17/20]

dragon::DEPLOY_CUDNN ( ConvTranspose2d  )

◆ DEPLOY_CUDNN() [18/20]

dragon::DEPLOY_CUDNN ( ConvTranspose2dGradient  )

◆ DEPLOY_CUDNN() [19/20]

dragon::DEPLOY_CUDNN ( Conv2d  )

◆ DEPLOY_CUDNN() [20/20]

dragon::DEPLOY_CUDNN ( Conv2dGradient  )

◆ DestroyGraphDef()

DRAGON_API void dragon::DestroyGraphDef ( GraphDef_t  graph_def)

◆ DestroyWorkspace() [1/2]

DRAGON_API void dragon::DestroyWorkspace ( const std::string &  name)

◆ DestroyWorkspace() [2/2]

DRAGON_API void dragon::DestroyWorkspace ( Workspace_t  ws)

◆ EveryNRegister()

int dragon::EveryNRegister ( const char *  file,
int  line,
int  severity,
int  n 
)

◆ FeedTensor() [1/2]

template<typename T >
DRAGON_API void dragon::FeedTensor ( const std::string &  name,
const std::vector< int64_t > &  shape,
const T *  data,
const Device device,
Workspace_t  ws 
)

◆ FeedTensor() [2/2]

template<typename T >
void dragon::FeedTensor ( const std::string &  name,
const vector< int64_t > &  shape,
const T *  data,
const Device device,
Workspace_t  ws 
)

◆ FeedTensor< float >()

template DRAGON_API void dragon::FeedTensor< float > ( const std::string &  ,
const std::vector< int64_t > &  ,
const float *  ,
const Device ,
Workspace_t   
)

◆ FeedTensor< float16 >()

template DRAGON_API void dragon::FeedTensor< float16 > ( const std::string &  ,
const std::vector< int64_t > &  ,
const float16 *  ,
const Device ,
Workspace_t   
)

◆ FeedTensor< int >()

template DRAGON_API void dragon::FeedTensor< int > ( const std::string &  ,
const std::vector< int64_t > &  ,
const int *  ,
const Device ,
Workspace_t   
)

◆ FeedTensor< int64_t >()

template DRAGON_API void dragon::FeedTensor< int64_t > ( const std::string &  ,
const std::vector< int64_t > &  ,
const int64_t *  ,
const Device ,
Workspace_t   
)

◆ FeedTensor< uint8_t >()

template DRAGON_API void dragon::FeedTensor< uint8_t > ( const std::string &  ,
const std::vector< int64_t > &  ,
const uint8_t *  ,
const Device ,
Workspace_t   
)

◆ FetchTensor() [1/2]

template<typename T >
DRAGON_API T* dragon::FetchTensor ( const std::string &  name,
std::vector< int64_t > &  shape,
Workspace_t  ws,
const bool  copy = false 
)

◆ FetchTensor() [2/2]

template<typename T >
T* dragon::FetchTensor ( const std::string &  name,
vector< int64_t > &  shape,
Workspace_t  ws,
const bool  copy 
)

◆ FetchTensor< float >()

template DRAGON_API float* dragon::FetchTensor< float > ( const std::string &  ,
std::vector< int64_t > &  ,
Workspace_t  ,
const bool   
)

◆ FetchTensor< float16 >()

template DRAGON_API float16* dragon::FetchTensor< float16 > ( const std::string &  ,
std::vector< int64_t > &  ,
Workspace_t  ,
const bool   
)

◆ FetchTensor< int >()

template DRAGON_API int* dragon::FetchTensor< int > ( const std::string &  ,
std::vector< int64_t > &  ,
Workspace_t  ,
const bool   
)

◆ FetchTensor< int64_t >()

template DRAGON_API int64_t* dragon::FetchTensor< int64_t > ( const std::string &  ,
std::vector< int64_t > &  ,
Workspace_t  ,
const bool   
)

◆ FetchTensor< uint8_t >()

template DRAGON_API uint8_t* dragon::FetchTensor< uint8_t > ( const std::string &  ,
std::vector< int64_t > &  ,
Workspace_t  ,
const bool   
)

◆ GenLogHashKey()

std::string dragon::GenLogHashKey ( const char *  file,
int  line 
)

◆ get_default()

template<class Map , typename Key = typename Map::key_type, typename Value = typename Map::mapped_type>
Map::mapped_type dragon::get_default ( const Map map,
const Key &  key,
Value &&  dflt 
)

◆ GetCUDADeviceProp()

const cudaDeviceProp& dragon::GetCUDADeviceProp ( int  device_id)
inline

◆ LoadCaffeModel() [1/2]

void dragon::LoadCaffeModel ( string  file,
Workspace ws 
)
inline

◆ LoadCaffeModel() [2/2]

DRAGON_API void dragon::LoadCaffeModel ( const std::string &  model_file,
Workspace_t  ws 
)

◆ LoadONNXModel()

DRAGON_API void dragon::LoadONNXModel ( const std::string &  model_file,
GraphDef_t  init_graph,
GraphDef_t  pred_graph,
std::vector< std::string > &  inputs,
std::vector< std::string > &  outputs 
)

◆ MakeGradientForOp()

Gradient dragon::MakeGradientForOp ( const OperatorDef &  op_def,
const vector< string > &  g_outputs 
)

◆ MakeOperatorDef() [1/3]

template<class IterableInputs , class IterableOutputs , class IterableArgs >
OperatorDef dragon::MakeOperatorDef ( const string &  type,
const string &  name,
const IterableInputs &  inputs,
const IterableOutputs &  outputs,
const IterableArgs &  args,
const DeviceOption &  device_option 
)
inline

◆ MakeOperatorDef() [2/3]

template<class IterableInputs , class IterableOutputs , class IterableArgs >
OperatorDef dragon::MakeOperatorDef ( const string &  type,
const string &  name,
const IterableInputs &  inputs,
const IterableOutputs &  outputs,
const IterableArgs &  args 
)
inline

◆ MakeOperatorDef() [3/3]

template<class IterableInputs , class IterableOutputs >
OperatorDef dragon::MakeOperatorDef ( const string &  type,
const string &  name,
const IterableInputs &  inputs,
const IterableOutputs &  outputs 
)
inline

◆ MoveWorkspace()

DRAGON_API void dragon::MoveWorkspace ( Workspace_t  dst,
Workspace_t  src 
)

◆ NewGraph()

GraphBase * dragon::NewGraph ( const GraphDef &  def,
Workspace ws 
)

Create a graph from the raw def.

◆ NewOperator()

OperatorBase * dragon::NewOperator ( const OperatorDef &  def,
Workspace ws 
)

New a operator from the raw def.

◆ NO_GRADIENT() [1/27]

dragon::NO_GRADIENT ( Shape  )

◆ NO_GRADIENT() [2/27]

dragon::NO_GRADIENT ( Copy  )

◆ NO_GRADIENT() [3/27]

dragon::NO_GRADIENT ( RMSPropUpdate  )

◆ NO_GRADIENT() [4/27]

dragon::NO_GRADIENT ( NesterovUpdate  )

◆ NO_GRADIENT() [5/27]

dragon::NO_GRADIENT ( SGDUpdate  )

◆ NO_GRADIENT() [6/27]

dragon::NO_GRADIENT ( AdamUpdate  )

◆ NO_GRADIENT() [7/27]

dragon::NO_GRADIENT ( OneHot  )

◆ NO_GRADIENT() [8/27]

dragon::NO_GRADIENT ( Arange  )

◆ NO_GRADIENT() [9/27]

dragon::NO_GRADIENT ( RNNParamSet  )

◆ NO_GRADIENT() [10/27]

dragon::NO_GRADIENT ( NonZero  )

◆ NO_GRADIENT() [11/27]

dragon::NO_GRADIENT ( ImageData  )

◆ NO_GRADIENT() [12/27]

dragon::NO_GRADIENT ( Accumulate  )

◆ NO_GRADIENT() [13/27]

dragon::NO_GRADIENT ( MaskedAssign  )

◆ NO_GRADIENT() [14/27]

dragon::NO_GRADIENT ( Accuracy  )

◆ NO_GRADIENT() [15/27]

dragon::NO_GRADIENT ( Moments  )

◆ NO_GRADIENT() [16/27]

dragon::NO_GRADIENT ( Multinomial  )

◆ NO_GRADIENT() [17/27]

dragon::NO_GRADIENT ( Compare  )

◆ NO_GRADIENT() [18/27]

dragon::NO_GRADIENT ( ArgReduce  )

◆ NO_GRADIENT() [19/27]

dragon::NO_GRADIENT ( Assign  )

◆ NO_GRADIENT() [20/27]

dragon::NO_GRADIENT ( StopGradient  )

◆ NO_GRADIENT() [21/27]

dragon::NO_GRADIENT ( Fill  )

◆ NO_GRADIENT() [22/27]

dragon::NO_GRADIENT ( GivenTensorFill  )

◆ NO_GRADIENT() [23/27]

dragon::NO_GRADIENT ( RandomUniform  )

◆ NO_GRADIENT() [24/27]

dragon::NO_GRADIENT ( RandomNormal  )

◆ NO_GRADIENT() [25/27]

dragon::NO_GRADIENT ( TruncatedNormal  )

◆ NO_GRADIENT() [26/27]

dragon::NO_GRADIENT ( GlorotUniform  )

◆ NO_GRADIENT() [27/27]

dragon::NO_GRADIENT ( GlorotNormal  )

◆ NumInputs() [1/15]

dragon::NumInputs ( ,
 
)

◆ NumInputs() [2/15]

dragon::NumInputs ( )

◆ NumInputs() [3/15]

dragon::NumInputs ( ,
INT_MAX   
)

◆ NumInputs() [4/15]

dragon::NumInputs ( ,
 
)

◆ NumInputs() [5/15]

dragon::NumInputs ( )

◆ NumInputs() [6/15]

dragon::NumInputs ( )

◆ NumInputs() [7/15]

dragon::NumInputs ( )

◆ NumInputs() [8/15]

dragon::NumInputs ( ,
 
)

◆ NumInputs() [9/15]

dragon::NumInputs ( ,
 
)

◆ NumInputs() [10/15]

dragon::NumInputs ( ,
 
)

◆ NumInputs() [11/15]

dragon::NumInputs ( ,
INT_MAX   
)

◆ NumInputs() [12/15]

dragon::NumInputs ( ,
 
)

◆ NumInputs() [13/15]

dragon::NumInputs ( )

◆ NumInputs() [14/15]

dragon::NumInputs ( )

◆ NumInputs() [15/15]

dragon::NumInputs ( ,
INT_MAX   
)

◆ OPERATOR_SCHEMA()

dragon::OPERATOR_SCHEMA ( CollectiveUpdate  )

◆ ParseProtoFromLargeString() [1/2]

bool dragon::ParseProtoFromLargeString ( const string &  str,
Message *  proto 
)

◆ ParseProtoFromLargeString() [2/2]

bool dragon::ParseProtoFromLargeString ( const string &  str,
google::protobuf::Message *  proto 
)

◆ ParseProtoFromText() [1/2]

bool dragon::ParseProtoFromText ( string  text,
Message *  proto 
)

◆ ParseProtoFromText() [2/2]

bool dragon::ParseProtoFromText ( string  text,
google::protobuf::Message *  proto 
)

◆ ReadProtoFromBinaryFile() [1/2]

bool dragon::ReadProtoFromBinaryFile ( const char *  filename,
Message *  proto 
)

◆ ReadProtoFromBinaryFile() [2/2]

bool dragon::ReadProtoFromBinaryFile ( const char *  filename,
google::protobuf::Message *  proto 
)

◆ REGISTER_GRADIENT() [1/77]

dragon::REGISTER_GRADIENT ( ExpandDims  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [2/77]

dragon::REGISTER_GRADIENT ( Squeeze  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [3/77]

dragon::REGISTER_GRADIENT ( Recurrent  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [4/77]

dragon::REGISTER_GRADIENT ( Log  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [5/77]

dragon::REGISTER_GRADIENT ( Exp  ,
InplaceGradientMaker   
)

◆ REGISTER_GRADIENT() [6/77]

dragon::REGISTER_GRADIENT ( Square  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [7/77]

dragon::REGISTER_GRADIENT ( Sqrt  ,
InplaceGradientMaker   
)

◆ REGISTER_GRADIENT() [8/77]

dragon::REGISTER_GRADIENT ( CTCLoss  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [9/77]

dragon::REGISTER_GRADIENT ( Tanh  ,
InplaceGradientMaker   
)

◆ REGISTER_GRADIENT() [10/77]

dragon::REGISTER_GRADIENT ( Sigmoid  ,
InplaceGradientMaker   
)

◆ REGISTER_GRADIENT() [11/77]

dragon::REGISTER_GRADIENT ( Flatten  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [12/77]

dragon::REGISTER_GRADIENT ( SElu  ,
InplaceGradientMaker   
)

◆ REGISTER_GRADIENT() [13/77]

dragon::REGISTER_GRADIENT ( Relu  ,
InplaceGradientMaker   
)

◆ REGISTER_GRADIENT() [14/77]

dragon::REGISTER_GRADIENT ( Elu  ,
InplaceGradientMaker   
)

◆ REGISTER_GRADIENT() [15/77]

dragon::REGISTER_GRADIENT ( Reshape  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [16/77]

dragon::REGISTER_GRADIENT ( GramMatrix  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [17/77]

dragon::REGISTER_GRADIENT ( Clip  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [18/77]

dragon::REGISTER_GRADIENT ( MaskedSelect  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [19/77]

dragon::REGISTER_GRADIENT ( ChannelShuffle  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [20/77]

dragon::REGISTER_GRADIENT ( Conv2d  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [21/77]

dragon::REGISTER_GRADIENT ( Cast  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [22/77]

dragon::REGISTER_GRADIENT ( MPIBroadcast  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [23/77]

dragon::REGISTER_GRADIENT ( Dropout  ,
InplaceGradientMaker   
)

◆ REGISTER_GRADIENT() [24/77]

dragon::REGISTER_GRADIENT ( Repeat  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [25/77]

dragon::REGISTER_GRADIENT ( Softmax  ,
InplaceGradientMaker   
)

◆ REGISTER_GRADIENT() [26/77]

dragon::REGISTER_GRADIENT ( ConvTranspose2d  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [27/77]

dragon::REGISTER_GRADIENT ( BilinearResize  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [28/77]

dragon::REGISTER_GRADIENT ( Stack  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [29/77]

dragon::REGISTER_GRADIENT ( DropPath  ,
InplaceGradientMaker   
)

◆ REGISTER_GRADIENT() [30/77]

dragon::REGISTER_GRADIENT ( LSTMCell  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [31/77]

dragon::REGISTER_GRADIENT ( MPIGather  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [32/77]

dragon::REGISTER_GRADIENT ( Pow  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [33/77]

dragon::REGISTER_GRADIENT ( Concat  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [34/77]

dragon::REGISTER_GRADIENT ( DepthwiseConv2d  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [35/77]

dragon::REGISTER_GRADIENT ( IndexSelect  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [36/77]

dragon::REGISTER_GRADIENT ( PRelu  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [37/77]

dragon::REGISTER_GRADIENT ( Transpose  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [38/77]

dragon::REGISTER_GRADIENT ( L1Loss  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [39/77]

dragon::REGISTER_GRADIENT ( L2Loss  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [40/77]

dragon::REGISTER_GRADIENT ( BiasAdd  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [41/77]

dragon::REGISTER_GRADIENT ( Eltwise  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [42/77]

dragon::REGISTER_GRADIENT ( SigmoidCrossEntropy  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [43/77]

dragon::REGISTER_GRADIENT ( SmoothL1Loss  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [44/77]

dragon::REGISTER_GRADIENT ( RSub  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [45/77]

dragon::REGISTER_GRADIENT ( RAdd  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [46/77]

dragon::REGISTER_GRADIENT ( ROIAlign  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [47/77]

dragon::REGISTER_GRADIENT ( Sub  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [48/77]

dragon::REGISTER_GRADIENT ( Add  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [49/77]

dragon::REGISTER_GRADIENT ( Minimum  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [50/77]

dragon::REGISTER_GRADIENT ( Maximum  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [51/77]

dragon::REGISTER_GRADIENT ( ROIPool  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [52/77]

dragon::REGISTER_GRADIENT ( RMul  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [53/77]

dragon::REGISTER_GRADIENT ( Slice  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [54/77]

dragon::REGISTER_GRADIENT ( Mul  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [55/77]

dragon::REGISTER_GRADIENT ( Tile  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [56/77]

dragon::REGISTER_GRADIENT ( Reduce  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [57/77]

dragon::REGISTER_GRADIENT ( NNResize  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [58/77]

dragon::REGISTER_GRADIENT ( DropBlock2d  ,
InplaceGradientMaker   
)

◆ REGISTER_GRADIENT() [59/77]

dragon::REGISTER_GRADIENT ( RDiv  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [60/77]

dragon::REGISTER_GRADIENT ( Affine  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [61/77]

dragon::REGISTER_GRADIENT ( Div  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [62/77]

dragon::REGISTER_GRADIENT ( L2Norm  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [63/77]

dragon::REGISTER_GRADIENT ( SoftmaxCrossEntropy  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [64/77]

dragon::REGISTER_GRADIENT ( Matmul  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [65/77]

dragon::REGISTER_GRADIENT ( SigmoidFocalLoss  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [66/77]

dragon::REGISTER_GRADIENT ( GroupNorm  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [67/77]

dragon::REGISTER_GRADIENT ( Where  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [68/77]

dragon::REGISTER_GRADIENT ( NLLLoss  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [69/77]

dragon::REGISTER_GRADIENT ( Crop  ,
SimpleGradientMaker   
)

◆ REGISTER_GRADIENT() [70/77]

dragon::REGISTER_GRADIENT ( SoftmaxFocalLoss  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [71/77]

dragon::REGISTER_GRADIENT ( FullyConnected  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [72/77]

dragon::REGISTER_GRADIENT ( Pad  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [73/77]

dragon::REGISTER_GRADIENT ( SparseSoftmaxCrossEntropy  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [74/77]

dragon::REGISTER_GRADIENT ( Pool2d  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [75/77]

dragon::REGISTER_GRADIENT ( LRN  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [76/77]

dragon::REGISTER_GRADIENT ( BatchNorm  ,
GradientMaker   
)

◆ REGISTER_GRADIENT() [77/77]

dragon::REGISTER_GRADIENT ( Dot  ,
SimpleGradientMaker   
)

◆ ResetWorkspace() [1/2]

DRAGON_API Workspace_t dragon::ResetWorkspace ( const std::string &  name)

◆ ResetWorkspace() [2/2]

DRAGON_API Workspace_t dragon::ResetWorkspace ( Workspace_t  ws)

◆ RunGraph()

DRAGON_API void dragon::RunGraph ( const std::string &  graph_name,
Workspace_t  ws,
const int  stream_id 
)

◆ SavaCaffeModel()

void dragon::SavaCaffeModel ( string  file,
const vector< Tensor * > &  tensors 
)
inline

◆ SetLogDestination()

void dragon::SetLogDestination ( LogSeverity  type)

◆ SetLoggingLevel()

DRAGON_API void dragon::SetLoggingLevel ( const std::string &  level)

◆ SeverityToStr()

std::string dragon::SeverityToStr ( LogSeverity  severity)

◆ StrToLogSeverity()

LogSeverity dragon::StrToLogSeverity ( std::string  level)

◆ TENSOR_CORE_AVAILABLE()

bool dragon::TENSOR_CORE_AVAILABLE ( )
inline

◆ TryCreateOperator()

OperatorBase* dragon::TryCreateOperator ( const string &  key,
const OperatorDef &  def,
Workspace ws 
)

◆ type_from_string()

int dragon::type_from_string ( std::string  type)

◆ TypeMetaToString()

const std::string dragon::TypeMetaToString ( const TypeMeta meta)
inline

◆ TypeStringToMeta()

const TypeMeta& dragon::TypeStringToMeta ( const std::string &  str_type)
inline

◆ TypeToString()

template<typename T >
const std::string dragon::TypeToString ( )
inline

◆ WriteProtoToBinaryFile() [1/2]

void dragon::WriteProtoToBinaryFile ( const Message &  proto,
const char *  filename 
)

◆ WriteProtoToBinaryFile() [2/2]

void dragon::WriteProtoToBinaryFile ( const google::protobuf::Message &  proto,
const char *  filename 
)

Variable Documentation

◆ CUDA_MAX_BLOCKS

const int dragon::CUDA_MAX_BLOCKS = 65535

The maximum number of blocks to use in the default kernel call.

We set it to 65535 which would work for compute capability 2.x, where 65536 is the limit.

◆ CUDA_THREADS

const int dragon::CUDA_THREADS = 1024

The number of cuda threads to use.

We set it to 1024 which would work for compute capability 2.x.

Set it to 512 if using compute capability 1.x.

◆ g_log_count

std::map<std::string, int> dragon::g_log_count

◆ g_log_destination

LogSeverity dragon::g_log_destination = INFO

◆ g_log_every

std::map<std::string, int> dragon::g_log_every

◆ g_mutex

std::mutex dragon::g_mutex

◆ g_workspaces

Map<string, unique_ptr < Workspace > > dragon::g_workspaces

◆ INT_MAX

dragon::INT_MAX

◆ LOG_LEVELS

std::map<std::string, LogSeverity> dragon::LOG_LEVELS
Initial value:
= {
{ "DEBUG", DEBUG },
{ "INFO", INFO },
{ "WARNING", WARNING },
{ "ERROR", ERROR },
{ "FATAL", FATAL }
}
Definition: logging.h:21
Definition: logging.h:21
Definition: logging.h:21
Definition: logging.h:21
Definition: logging.h:21

◆ LOG_SEVERITIES

std::string dragon::LOG_SEVERITIES[]
Initial value:
= {
"DEBUG",
"INFO",
"WARNING",
"ERROR",
"FATAL"
}

◆ sub_workspaces

Map<string, vector<string> > dragon::sub_workspaces