| Cmshadow::op::complex::abs_square | |
| Cmxnet::runtime::ADTBuilder | A builder class that helps to incrementally build ADT |
| Cmxnet::Imperative::AGInfo | |
| Cmshadow::packet::AlignBytes< Arch > | |
| Cmxnet::runtime::array_type_info< T > | The type trait indicates subclass of TVM's NDArray. For irrelavant classes, code = -1. For TVM NDArray itself, code = 0. All subclasses of NDArray should override code > 0 |
| Cdmlc::array_view< ValueType > | Read only data structure to reference continuous memory region of array. Provide unified view for vector, array and C style array. This data structure do not guarantee aliveness of referenced array |
| Cdmlc::array_view< nnvm::IndexedGraph::NodeEntry > | |
| Cdmlc::array_view< uint32_t > | |
| Cmxnet::runtime::SimpleObjAllocator::ArrayHandler< ArrayType, ElemType > | |
| ►Cbasic_istream | |
| Cdmlc::istream | Std::istream class that can can wrap Stream objects, can use istream with that output to underlying Stream |
| ►Cbasic_ostream | |
| Cdmlc::ostream | Std::ostream class that can can wrap Stream objects, can use ostream with that output to underlying Stream |
| Cmshadow::expr::BLASEngine< Device, DType > | |
| Cmshadow::expr::BLASEngine< cpu, double > | |
| Cmshadow::expr::BLASEngine< cpu, float > | |
| Cmshadow::expr::BLASEngine< gpu, double > | |
| Cmshadow::expr::BLASEngine< gpu, float > | |
| Cmshadow::expr::BLASEngine< gpu, half::half_t > | |
| Cdmlc::InputSplit::Blob | Blob of memory region |
| Cmxnet::engine::CallbackOnComplete | OnComplete Callback to the engine, called by AsyncFn when action completes |
| Cdmlc::ConcurrentBlockingQueue< T, type > | Cocurrent blocking queue |
| Cdmlc::Config | Class for config parser |
| Cmshadow::op::complex::conjugate | |
| Cmxnet::cpp::Context | Context interface |
| Cmxnet::Context | Context information about the execution environment |
| Cmshadow::cpu | Device name CPU |
| Cmxnet::common::csr_idx_check | Indices should be non-negative, less than the number of columns and in ascending order per row |
| Cmxnet::common::csr_indptr_check | IndPtr should be non-negative, in non-decreasing order, start with 0 and end with value equal with size of indices |
| Cmxnet::common::cuda::CublasType< DType > | Converts between C++ datatypes and enums/constants needed by cuBLAS |
| Cmxnet::common::cuda::CublasType< double > | |
| Cmxnet::common::cuda::CublasType< float > | |
| Cmxnet::common::cuda::CublasType< int32_t > | |
| Cmxnet::common::cuda::CublasType< mshadow::half::half_t > | |
| Cmxnet::common::cuda::CublasType< uint8_t > | |
| CCustomOp | Class to hold custom operator registration |
| CCustomOpSelector | |
| CCustomPartitioner | An abstract class for subgraph property |
| CCustomPass | An abstract class for graph passes |
| CCustomStatefulOp | An abstract class for library authors creating stateful op custom library should override Forward and destructor, and has an option to implement Backward |
| CCustomStatefulOpWrapper | StatefulOp wrapper class to pass to backend OpState |
| Cmxnet::cpp::DataBatch | Default object for holding a mini-batch of data and related information |
| Cmxnet::DataBatch | DataBatch of NDArray, returned by Iterator |
| Cmxnet::DataInst | Single data instance |
| ►Cmxnet::cpp::DataIter | |
| Cmxnet::cpp::MXDataIter | |
| ►Cdmlc::DataIter< DType > | Data iterator interface this is not a C++ style iterator, but nice for data pulling:) This interface is used to pull in the data The system can do some useful tricks for you like pre-fetching from disk and pre-computation |
| Cdmlc::ThreadedIter< DType > | Iterator that was backed by a thread to pull data eagerly from a single producer into a bounded buffer the consumer can pull the data at its own rate |
| Cmxnet::IIterator< DType > | Iterator type |
| ►Cdmlc::DataIter< RowBlock< IndexType, DType > > | |
| Cdmlc::Parser< IndexType, DType > | Parser interface that parses input data used to load dmlc data format into your own data format Difference between RowBlockIter and Parser: RowBlockIter caches the data internally that can be used to iterate the dataset multiple times, Parser holds very limited internal state and was usually used to read data only once |
| Cdmlc::RowBlockIter< IndexType, DType > | Data structure that holds the data Row block iterator interface that gets RowBlocks Difference between RowBlockIter and Parser: RowBlockIter caches the data internally that can be used to iterate the dataset multiple times, Parser holds very limited internal state and was usually used to read data only once |
| Cmshadow::DataType< DType > | |
| Cmshadow::DataType< bfloat::bf16_t > | |
| Cmshadow::DataType< bool > | |
| Cmshadow::DataType< double > | |
| Cmshadow::DataType< float > | |
| Cmshadow::DataType< half::half2_t > | |
| Cmshadow::DataType< half::half_t > | |
| Cmshadow::DataType< int32_t > | |
| Cmshadow::DataType< int64_t > | |
| Cmshadow::DataType< int8_t > | |
| Cmshadow::DataType< uint8_t > | |
| Cmxnet::common::cuda::DeviceStore | |
| Cmshadow::op::complex::div | |
| Cmshadow::op::div | Divide operator |
| Cmshadow::sv::divto | Divide to saver: /= |
| CDLContext | A Device context for Tensor and operator |
| CDLDataType | The data type the tensor can hold |
| CDLManagedTensor | C Tensor object, manage memory of DLTensor. This data structure is intended to facilitate the borrowing of DLTensor by another framework. It is not meant to transfer the tensor. When the borrowing framework doesn't need the tensor, it should call the deleter to notify the host that the resource is no longer needed |
| CDLTensor | Plain C Tensor object, does not manage memory |
| Cdnnl_batch_normalization_desc_t | A descriptor of a Batch Normalization operation |
| Cdnnl_binary_desc_t | A descriptor of a binary operation |
| Cdnnl_blocking_desc_t | |
| Cdnnl_convolution_desc_t | A descriptor of a convolution operation |
| Cdnnl_eltwise_desc_t | A descriptor of a element-wise operation |
| Cdnnl_engine | An opaque structure to describe an engine |
| Cdnnl_exec_arg_t | |
| Cdnnl_inner_product_desc_t | A descriptor of an inner product operation |
| Cdnnl_layer_normalization_desc_t | A descriptor of a Layer Normalization operation |
| Cdnnl_lrn_desc_t | A descriptor of a Local Response Normalization (LRN) operation |
| Cdnnl_matmul_desc_t | |
| Cdnnl_memory | |
| Cdnnl_memory_desc_t | |
| Cdnnl_memory_extra_desc_t | Description of extra information stored in memory |
| Cdnnl_pooling_desc_t | A descriptor of a pooling operation |
| Cdnnl_post_ops | An opaque structure for a chain of post operations |
| Cdnnl_primitive | |
| Cdnnl_primitive_attr | An opaque structure for primitive descriptor attributes |
| Cdnnl_primitive_desc | An opaque structure to describe a primitive descriptor |
| Cdnnl_primitive_desc_iterator | An opaque structure to describe a primitive descriptor iterator |
| Cdnnl_resampling_desc_t | A descriptor of resampling operation |
| Cdnnl_rnn_desc_t | A descriptor for an RNN operation |
| Cdnnl_rnn_packed_desc_t | Description of tensor of packed weights for rnn |
| Cdnnl_shuffle_desc_t | A descriptor of a shuffle operation |
| Cdnnl_softmax_desc_t | A descriptor of a Softmax operation |
| Cdnnl_stream | |
| Cdnnl_version_t | |
| Cdnnl_wino_desc_t | Description of tensor of weights for winograd 2x3 convolution |
| Cmshadow::expr::DotEngine< SV, Device, ddim, ldim, rdim, ltrans, rtrans, DType > | |
| Cmshadow::expr::DotEngine< SV, xpu, 1, 1, 2, false, transpose_right, DType > | |
| Cmshadow::expr::DotEngine< SV, xpu, 2, 1, 1, true, false, DType > | |
| Cmshadow::expr::DotEngine< SV, xpu, 2, 2, 2, transpose_left, transpose_right, DType > | |
| Cmxnet::Engine | Dependency engine that schedules operations |
| Cmxnet::features::EnumNames | |
| Cmxnet::op::EnvArguments | Environment arguments that is used by the function. These can be things like scalar arguments when add a value with scalar |
| ►Cmxnet::cpp::EvalMetric | |
| Cmxnet::cpp::Accuracy | |
| Cmxnet::cpp::LogLoss | |
| Cmxnet::cpp::MAE | |
| Cmxnet::cpp::MSE | |
| Cmxnet::cpp::PSNR | |
| Cmxnet::cpp::RMSE | |
| Cmshadow::op::complex::exchange | |
| Cmxnet::cpp::Executor | Executor interface |
| Cmxnet::Executor | Executor of a computation graph. Executor can be created by Binding a symbol |
| Cmshadow::expr::Exp< SubType, DType, exp_type > | Defines how expression exp can be evaluated and stored into dst |
| ►Cmshadow::expr::Exp< BinaryMapExp< OP, TA, TB, DType, etype >, DType, etype > | |
| Cmshadow::expr::BinaryMapExp< OP, TA, TB, DType, etype > | Binary map expression lhs [op] rhs |
| ►Cmshadow::expr::Exp< ComplexBinaryMapExp< calctype, OP, TA, TB, DType, etype >, DType, etype > | |
| Cmshadow::expr::ComplexBinaryMapExp< calctype, OP, TA, TB, DType, etype > | Binary map expression lhs [op] rhs where lhs and rhs are complex tensors |
| ►Cmshadow::expr::Exp< ComplexUnitaryExp< calctype, OP, TA, DType, etype >, DType, etype > | |
| Cmshadow::expr::ComplexUnitaryExp< calctype, OP, TA, DType, etype > | Compute conj(src) where src is a complex tensor |
| ►Cmshadow::expr::Exp< ConcatExp< LhsExp, RhsExp, Device, DType, srcdim, dimsrc_m_cat >, DType, type::kRValue > | |
| ►Cmshadow::expr::RValueExp< ConcatExp< LhsExp, RhsExp, Device, DType, srcdim, dimsrc_m_cat >, DType > | |
| ►Cmshadow::TRValue< ConcatExp< LhsExp, RhsExp, Device, DType, srcdim, dimsrc_m_cat >, Device, srcdim, DType > | |
| Cmshadow::expr::ConcatExp< LhsExp, RhsExp, Device, DType, srcdim, dimsrc_m_cat > | Concat expression, concat two tensor's channel |
| ►Cmshadow::expr::Exp< Container, DType, type::kRValue > | |
| ►Cmshadow::expr::RValueExp< Container, DType > | Base class of all rvalues |
| Cmshadow::TRValue< Container, Device, dimension, DType > | Tensor RValue, this is the super type of all kinds of possible tensors |
| ►Cmshadow::expr::Exp< DotExp< TA, TB, ltrans, rtrans, DType >, DType, type::kComplex > | |
| Cmshadow::expr::DotExp< TA, TB, ltrans, rtrans, DType > | Matrix multiplication expression dot(lhs[.T], rhs[.T]) |
| ►Cmshadow::expr::Exp< FlipExp< SrcExp, Device, DType, srcdim >, DType, type::kRValue > | |
| ►Cmshadow::expr::RValueExp< FlipExp< SrcExp, Device, DType, srcdim >, DType > | |
| ►Cmshadow::TRValue< FlipExp< SrcExp, Device, DType, srcdim >, Device, srcdim, DType > | |
| Cmshadow::expr::FlipExp< SrcExp, Device, DType, srcdim > | Slice expression, slice a tensor's channel |
| ►Cmshadow::expr::Exp< ImplicitGEMMExp< LhsExp, RhsExp, DType >, DType, type::kChainer > | |
| Cmshadow::expr::ImplicitGEMMExp< LhsExp, RhsExp, DType > | Matrix multiplication |
| ►Cmshadow::expr::Exp< MakeTensorExp< Broadcast1DExp< SrcExp, DType, dimdst, dimdst_m_cast >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< Broadcast1DExp< SrcExp, DType, dimdst, dimdst_m_cast >, SrcExp, dimdst, DType > | |
| Cmshadow::expr::Broadcast1DExp< SrcExp, DType, dimdst, dimdst_m_cast > | Broadcast Tensor1D into a higher dimension Tensor input: Tensor<Device,1>: ishape[0] output: Tensor<Device,dimdst> : oshape[dimcast] = ishape[0] |
| ►Cmshadow::expr::Exp< MakeTensorExp< BroadcastScalarExp< SrcExp, DType, dimdst >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< BroadcastScalarExp< SrcExp, DType, dimdst >, SrcExp, dimdst, DType > | |
| Cmshadow::expr::BroadcastScalarExp< SrcExp, DType, dimdst > | Broadcast scalar into a higher dimension Tensor input: Tensor<Device,1>: ishape = {1} output: Tensor<Device, dimdst> : oshape[dimcast] = ishape[0] |
| ►Cmshadow::expr::Exp< MakeTensorExp< BroadcastWithAxisExp< SrcExp, DType, dimsrc, dimdst >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< BroadcastWithAxisExp< SrcExp, DType, dimsrc, dimdst >, SrcExp, dimdst, DType > | |
| Cmshadow::expr::BroadcastWithAxisExp< SrcExp, DType, dimsrc, dimdst > | Broadcasting the tensor in the given axis. If keepdim is off, insert the broadcasting dim after axis. Otherwise broadcasting axis |
| ►Cmshadow::expr::Exp< MakeTensorExp< BroadcastWithMultiAxesExp< SrcExp, DType, dimsrc >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< BroadcastWithMultiAxesExp< SrcExp, DType, dimsrc >, SrcExp, dimsrc, DType > | |
| Cmshadow::expr::BroadcastWithMultiAxesExp< SrcExp, DType, dimsrc > | Broadcasting the tensor in multiple axes. The dimension of the source tensor in the given axes must be 1 |
| ►Cmshadow::expr::Exp< MakeTensorExp< ChannelPoolingExp< Reducer, SrcExp, DType, srcdim >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< ChannelPoolingExp< Reducer, SrcExp, DType, srcdim >, SrcExp, srcdim, DType > | |
| Cmshadow::expr::ChannelPoolingExp< Reducer, SrcExp, DType, srcdim > | Channel pooling expression, do reduction over (local nearby) channels, used to implement local response normalization |
| ►Cmshadow::expr::Exp< MakeTensorExp< ChannelUnpoolingExp< Reducer, SrcExp, DType, srcdim >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< ChannelUnpoolingExp< Reducer, SrcExp, DType, srcdim >, SrcExp, srcdim, DType > | |
| Cmshadow::expr::ChannelUnpoolingExp< Reducer, SrcExp, DType, srcdim > | Channel pooling expression, do reduction over (local nearby) channels, used to implement local response normalization |
| ►Cmshadow::expr::Exp< MakeTensorExp< CroppingExp< SrcExp, DType, srcdim >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< CroppingExp< SrcExp, DType, srcdim >, SrcExp, srcdim, DType > | |
| Cmshadow::expr::CroppingExp< SrcExp, DType, srcdim > | Crop expression, cut off the boundary region, reverse operation of padding |
| ►Cmshadow::expr::Exp< MakeTensorExp< MirroringExp< SrcExp, DType, srcdim >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< MirroringExp< SrcExp, DType, srcdim >, SrcExp, srcdim, DType > | |
| Cmshadow::expr::MirroringExp< SrcExp, DType, srcdim > | Mirror expression, mirror a image in width |
| ►Cmshadow::expr::Exp< MakeTensorExp< PackColToPatchXExp< SrcExp, DType, dstdim >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< PackColToPatchXExp< SrcExp, DType, dstdim >, SrcExp, dstdim, DType > | |
| Cmshadow::expr::PackColToPatchXExp< SrcExp, DType, dstdim > | Reverse operation of UnpackPatchToCol, used to backprop gradient back this is a version supporting multiple images |
| ►Cmshadow::expr::Exp< MakeTensorExp< PaddingExp< SrcExp, DType, srcdim >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< PaddingExp< SrcExp, DType, srcdim >, SrcExp, srcdim, DType > | |
| Cmshadow::expr::PaddingExp< SrcExp, DType, srcdim > | Padding expression, pad a image with zeros |
| ►Cmshadow::expr::Exp< MakeTensorExp< PoolingExp< Reducer, SrcExp, DType, srcdim >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< PoolingExp< Reducer, SrcExp, DType, srcdim >, SrcExp, srcdim, DType > | |
| Cmshadow::expr::PoolingExp< Reducer, SrcExp, DType, srcdim > | Pooling expression, do reduction over local patches of a image |
| ►Cmshadow::expr::Exp< MakeTensorExp< ReduceWithAxisExp< Reducer, SrcExp, DType, dimsrc, mask, dimdst >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< ReduceWithAxisExp< Reducer, SrcExp, DType, dimsrc, mask, dimdst >, SrcExp, dimdst, DType > | |
| Cmshadow::expr::ReduceWithAxisExp< Reducer, SrcExp, DType, dimsrc, mask, dimdst > | Reduce out the dimension of src labeled by axis |
| ►Cmshadow::expr::Exp< MakeTensorExp< ReshapeExp< SrcExp, DType, dimdst, dimsrc >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< ReshapeExp< SrcExp, DType, dimdst, dimsrc >, SrcExp, dimdst, DType > | |
| Cmshadow::expr::ReshapeExp< SrcExp, DType, dimdst, dimsrc > | Reshape the content to another shape input: Tensor<Device,dimsrc>: ishape output: Tensor<Device,dimdst> ishape.Size() == oshape.Size() |
| ►Cmshadow::expr::Exp< MakeTensorExp< SubType, SrcExp, dim, DType >, DType, type::kChainer > | |
| Cmshadow::expr::MakeTensorExp< SubType, SrcExp, dim, DType > | General class that allows extension that makes tensors of some shape |
| ►Cmshadow::expr::Exp< MakeTensorExp< SwapAxisExp< SrcExp, DType, dimsrc, m_a1, a2 >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< SwapAxisExp< SrcExp, DType, dimsrc, m_a1, a2 >, SrcExp, dimsrc, DType > | |
| Cmshadow::expr::SwapAxisExp< SrcExp, DType, dimsrc, m_a1, a2 > | Swap two axis of a tensor input: Tensor<Device,dim>: ishape output: Tensor<Device,dimdst> oshape[a1],oshape[a2] = ishape[a2],oshape[a1] |
| ►Cmshadow::expr::Exp< MakeTensorExp< TransposeExExp< SrcExp, DType, dimsrc >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< TransposeExExp< SrcExp, DType, dimsrc >, SrcExp, dimsrc, DType > | |
| Cmshadow::expr::TransposeExExp< SrcExp, DType, dimsrc > | Transpose axes of a tensor input: Tensor<Device,dim>: ishape output: Tensor<Device,dimdst> oshape[a1],oshape[a2] = ishape[a2],oshape[a1] |
| ►Cmshadow::expr::Exp< MakeTensorExp< UnpackPatchToColXExp< SrcExp, DType, srcdim >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< UnpackPatchToColXExp< SrcExp, DType, srcdim >, SrcExp, 2, DType > | |
| Cmshadow::expr::UnpackPatchToColXExp< SrcExp, DType, srcdim > | Unpack local (overlap) patches of image to column of mat, can be used to implement convolution, this expression allow unpack of a batch this is a version support unpacking multiple images after getting unpacked mat, we can use: output = dot(weight, mat) to get covolved results, the relations: |
| ►Cmshadow::expr::Exp< MakeTensorExp< UnPoolingExp< Reducer, SrcExp, DType, srcdim >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< UnPoolingExp< Reducer, SrcExp, DType, srcdim >, SrcExp, srcdim, DType > | |
| Cmshadow::expr::UnPoolingExp< Reducer, SrcExp, DType, srcdim > | Unpooling expr reverse operation of pooling, used to pass gradient back |
| ►Cmshadow::expr::Exp< MakeTensorExp< UpSamplingNearestExp< SrcExp, DType, srcdim >, SrcExp, dim, DType >, DType, type::kChainer > | |
| ►Cmshadow::expr::MakeTensorExp< UpSamplingNearestExp< SrcExp, DType, srcdim >, SrcExp, srcdim, DType > | |
| Cmshadow::expr::UpSamplingNearestExp< SrcExp, DType, srcdim > | Nearest neighboor upsampling out(x, y) = in(int(x / scale_x), int(y / scale_y)) |
| ►Cmshadow::expr::Exp< MaskExp< IndexExp, SrcExp, DType >, DType, type::kChainer > | |
| Cmshadow::expr::MaskExp< IndexExp, SrcExp, DType > | Broadcast a mask and do element-wise multiplication |
| ►Cmshadow::expr::Exp< MatChooseRowElementExp< SrcExp, IndexExp, DType >, DType, type::kChainer > | |
| Cmshadow::expr::MatChooseRowElementExp< SrcExp, IndexExp, DType > | Make a choice of index in the lowest changing dimension |
| ►Cmshadow::expr::Exp< MatFillRowElementExp< SrcExp, ValExp, IndexExp, DType >, DType, type::kChainer > | |
| Cmshadow::expr::MatFillRowElementExp< SrcExp, ValExp, IndexExp, DType > | Set value of a specific element in each line of the data matrix |
| ►Cmshadow::expr::Exp< OneHotEncodeExp< IndexExp, DType >, DType, type::kChainer > | |
| Cmshadow::expr::OneHotEncodeExp< IndexExp, DType > | Create a one-hot indicator array |
| ►Cmshadow::expr::Exp< RangeExp< DType >, DType, type::kMapper > | |
| Cmshadow::expr::RangeExp< DType > | Generate a range vector similar to python: range(start, stop[, step][, repeat]). If step is positive, the last element is the largest start + i * step less than stop If step is negative, the last element is the smallest start + i * step greater than stop. All elements are repeated for repeat times, e.g range(0, 4, 2, 3) –> 0, 0, 0, 2, 2, 2 |
| ►Cmshadow::expr::Exp< ReduceTo1DExp< SrcExp, DType, Reducer, m_dimkeep >, DType, type::kComplex > | |
| Cmshadow::expr::ReduceTo1DExp< SrcExp, DType, Reducer, m_dimkeep > | Reduction to 1 dimension tensor input: Tensor<Device,k>: ishape output: Tensor<Device,1> shape[0] = ishape[dimkeep]; |
| ►Cmshadow::expr::Exp< ScalarExp< DType >, DType, type::kMapper > | |
| Cmshadow::expr::ScalarExp< DType > | Scalar expression |
| ►Cmshadow::expr::Exp< SliceExExp< SrcExp, Device, DType, srcdim >, DType, type::kRValue > | |
| ►Cmshadow::expr::RValueExp< SliceExExp< SrcExp, Device, DType, srcdim >, DType > | |
| ►Cmshadow::TRValue< SliceExExp< SrcExp, Device, DType, srcdim >, Device, srcdim, DType > | |
| Cmshadow::expr::SliceExExp< SrcExp, Device, DType, srcdim > | Slice expression, slice a tensor's channel |
| ►Cmshadow::expr::Exp< SliceExp< SrcExp, Device, DType, srcdim, dimsrc_m_slice >, DType, type::kRValue > | |
| ►Cmshadow::expr::RValueExp< SliceExp< SrcExp, Device, DType, srcdim, dimsrc_m_slice >, DType > | |
| ►Cmshadow::TRValue< SliceExp< SrcExp, Device, DType, srcdim, dimsrc_m_slice >, Device, srcdim, DType > | |
| Cmshadow::expr::SliceExp< SrcExp, Device, DType, srcdim, dimsrc_m_slice > | Slice expression, slice a tensor's channel |
| ►Cmshadow::expr::Exp< TakeExp< IndexExp, SrcExp, DType >, DType, type::kChainer > | |
| Cmshadow::expr::TakeExp< IndexExp, SrcExp, DType > | Take a column from a matrix |
| ►Cmshadow::expr::Exp< TakeGradExp< IndexExp, SrcExp, DType >, DType, type::kChainer > | |
| Cmshadow::expr::TakeGradExp< IndexExp, SrcExp, DType > | Calculate embedding gradient |
| ►Cmshadow::expr::Exp< Tensor< Device, 1, DType >, DType, type::kRValue > | |
| ►Cmshadow::expr::RValueExp< Tensor< Device, 1, DType >, DType > | |
| ►Cmshadow::TRValue< Tensor< Device, 1, DType >, Device, 1, DType > | |
| Cmshadow::Tensor< Device, 1, DType > | |
| ►Cmshadow::expr::Exp< Tensor< Device, dimension, DType >, DType, type::kRValue > | |
| ►Cmshadow::expr::RValueExp< Tensor< Device, dimension, DType >, DType > | |
| ►Cmshadow::TRValue< Tensor< Device, dimension, DType >, Device, dimension, DType > | |
| Cmshadow::Tensor< Device, dimension, MSHADOW_DEFAULT_DTYPE > | General tensor |
| Cmshadow::Tensor< Device, 2, DType > | |
| ►Cmshadow::Tensor< Device, dimension, DType > | |
| Cmshadow::TensorContainer< Device, dimension, DType > | Tensor container that does memory allocation and resize like STL, use it to save the lines of FreeSpace in class. Do not abuse it, efficiency can come from pre-allocation and no re-allocation |
| ►Cmshadow::expr::Exp< Tensor< mshadow::cpu, dimension, DType >, DType, type::kRValue > | |
| ►Cmshadow::expr::RValueExp< Tensor< mshadow::cpu, dimension, DType >, DType > | |
| ►Cmshadow::TRValue< Tensor< mshadow::cpu, dimension, DType >, mshadow::cpu, dimension, DType > | |
| Cmshadow::Tensor< mshadow::cpu, 2, DType > | |
| ►Cmshadow::Tensor< mshadow::cpu, dimension, DType > | |
| Cmshadow::TensorContainer< mshadow::cpu, 1, DType > | |
| ►Cmshadow::expr::Exp< Tensor< mshadow::gpu, dimension, DType >, DType, type::kRValue > | |
| ►Cmshadow::expr::RValueExp< Tensor< mshadow::gpu, dimension, DType >, DType > | |
| ►Cmshadow::TRValue< Tensor< mshadow::gpu, dimension, DType >, mshadow::gpu, dimension, DType > | |
| Cmshadow::Tensor< mshadow::gpu, 2, DType > | |
| ►Cmshadow::Tensor< mshadow::gpu, dimension, DType > | |
| Cmshadow::TensorContainer< mshadow::gpu, 1, DType > | |
| ►Cmshadow::expr::Exp< TernaryMapExp< OP, TA, TB, TC, DType, etype >, DType, etype > | |
| Cmshadow::expr::TernaryMapExp< OP, TA, TB, TC, DType, etype > | Ternary map expression |
| ►Cmshadow::expr::Exp< TransposeExp< EType, DType >, DType, type::kChainer > | |
| Cmshadow::expr::TransposeExp< EType, DType > | Represent a transpose expression of a container |
| ►Cmshadow::expr::Exp< TransposeIndicesExp< SrcExp, DType, dimsrc, etype >, DType, etype > | |
| Cmshadow::expr::TransposeIndicesExp< SrcExp, DType, dimsrc, etype > | Transform contiguous indices of the source tensor to indices of the transposed tensor. input: Tensor<Device, k>: ishape output: Tensor<Device, k>: oshape = ishape |
| ►Cmshadow::expr::Exp< TypecastExp< DstDType, SrcDType, EType, etype >, DstDType, etype > | |
| Cmshadow::expr::TypecastExp< DstDType, SrcDType, EType, etype > | Typecast expression, cast the type of elements |
| ►Cmshadow::expr::Exp< UnaryMapExp< OP, TA, DType, etype >, DType, etype > | |
| Cmshadow::expr::UnaryMapExp< OP, TA, DType, etype > | Unary map expression op(src) |
| Cmshadow::expr::ExpComplexEngine< SV, RV, E, DType > | Some engine that evaluate complex expression |
| Cmshadow::expr::ExpComplexEngine< SV, Tensor< Device, 1, DType >, ReduceTo1DExp< SrcExp, DType, Reducer, 1 >, DType > | |
| Cmshadow::expr::ExpComplexEngine< SV, Tensor< Device, 1, DType >, ReduceTo1DExp< SrcExp, DType, Reducer, m_dimkeep >, DType > | |
| Cmshadow::expr::ExpComplexEngine< SV, Tensor< Device, dim, DType >, DotExp< Tensor< Device, ldim, DType >, Tensor< Device, rdim, DType >, ltrans, rtrans, DType >, DType > | |
| Cmshadow::expr::ExpEngine< SV, RV, DType > | Engine that dispatches simple operations |
| Cmshadow::expr::ExpInfo< E > | Static type inference template, used to get the dimension of each expression, if ExpInfo<E>::kDim == -1, this means here are mismatch in expression if (ExpInfo<E>::kDevMask & cpu::kDevMask) != 0, this means this expression can be assigned to cpu |
| Cmshadow::expr::ExpInfo< BinaryMapExp< OP, TA, TB, DType, etype > > | |
| Cmshadow::expr::ExpInfo< ComplexBinaryMapExp< calctype, OP, TA, TB, DType, etype > > | |
| Cmshadow::expr::ExpInfo< ComplexUnitaryExp< calctype, OP, TA, DType, etype > > | |
| Cmshadow::expr::ExpInfo< ConcatExp< LhsExp, RhsExp, Device, DType, srcdim, dimsrc_m_cat > > | |
| Cmshadow::expr::ExpInfo< FlipExp< SrcExp, Device, DType, srcdim > > | |
| Cmshadow::expr::ExpInfo< ImplicitGEMMExp< LhsExp, RhsExp, DType > > | |
| Cmshadow::expr::ExpInfo< MakeTensorExp< T, SrcExp, dim, DType > > | |
| Cmshadow::expr::ExpInfo< MaskExp< IndexExp, SrcExp, DType > > | |
| Cmshadow::expr::ExpInfo< MatChooseRowElementExp< SrcExp, IndexExp, DType > > | |
| Cmshadow::expr::ExpInfo< MatFillRowElementExp< SrcExp, ValExp, IndexExp, DType > > | |
| Cmshadow::expr::ExpInfo< OneHotEncodeExp< IndexExp, DType > > | |
| Cmshadow::expr::ExpInfo< RangeExp< DType > > | |
| Cmshadow::expr::ExpInfo< ScalarExp< DType > > | |
| Cmshadow::expr::ExpInfo< SliceExExp< SrcExp, Device, DType, srcdim > > | |
| Cmshadow::expr::ExpInfo< SliceExp< SrcExp, Device, DType, srcdim, dimsrc_m_slice > > | |
| Cmshadow::expr::ExpInfo< TakeExp< IndexExp, SrcExp, DType > > | |
| Cmshadow::expr::ExpInfo< TakeGradExp< IndexExp, SrcExp, DType > > | |
| Cmshadow::expr::ExpInfo< Tensor< Device, dim, DType > > | |
| Cmshadow::expr::ExpInfo< TernaryMapExp< OP, TA, TB, TC, DType, etype > > | |
| Cmshadow::expr::ExpInfo< TransposeExp< E, DType > > | |
| Cmshadow::expr::ExpInfo< TransposeIndicesExp< SrcExp, DType, dimsrc, etype > > | |
| Cmshadow::expr::ExpInfo< TypecastExp< DstDType, SrcDType, EType, etype > > | |
| Cmshadow::expr::ExpInfo< UnaryMapExp< OP, TA, DType, etype > > | |
| Cmxnet::runtime::extension_type_info< T > | Type traits to mark if a class is tvm extension type |
| Cmxnet::cpp::FeedForward | |
| Cmxnet::cpp::FeedForwardConfig | |
| ►CFieldEntryBase | |
| Cdmlc::parameter::FieldEntry< mxnet::TShape > | |
| Cdmlc::io::FileInfo | Use to store file information |
| Cdmlc::io::FileSystem | File system system interface |
| Cmxnet::runtime::detail::for_each_dispatcher< stop, I, F > | |
| Cmxnet::runtime::detail::for_each_dispatcher< true, I, F > | |
| Cdmlc::FunctionRegEntryBase< EntryType, FunctionType > | Common base class for function registry |
| ►Cdmlc::FunctionRegEntryBase< DataIteratorReg, DataIteratorFactory > | |
| Cmxnet::DataIteratorReg | Registry entry for DataIterator factory functions |
| ►Cdmlc::FunctionRegEntryBase< NDArrayFunctionReg, NDArrayAPIFunction > | |
| Cmxnet::NDArrayFunctionReg | Registry entry for NDArrayFunction |
| ►Cdmlc::FunctionRegEntryBase< OperatorPropertyReg, OperatorPropertyFactory > | |
| Cmxnet::OperatorPropertyReg | Registry entry for OperatorProperty factory functions |
| ►Cdmlc::FunctionRegEntryBase< ParserFactoryReg< IndexType, DType >, Parser< IndexType, DType >::Factory > | |
| Cdmlc::ParserFactoryReg< IndexType, DType > | Registry entry of parser factory |
| ►Cdmlc::FunctionRegEntryBase< PassFunctionReg, PassFunction > | |
| Cnnvm::PassFunctionReg | Registry entry for pass functions |
| Cmshadow::gpu | Device name GPU |
| Cmxnet::GPUAuxStream | Holds an auxiliary mshadow gpu stream that can be synced with a primary stream |
| ►Cmxnet::op::GradFunctionArgument | Super class of all gradient function argument |
| Cmxnet::op::Input0 | First input to the function |
| Cmxnet::op::Input1 | Second input to the function |
| Cmxnet::op::OutputGrad | Gradient of output value |
| Cmxnet::op::OutputValue | Ouput value of the function to the function |
| Cnnvm::Graph | Symbolic computation graph. This is the intermediate representation for optimization pass |
| Cmxnet::Storage::Handle | Storage handle |
| Cdmlc::lua_stack::Handler< T > | |
| Cmxnet::runtime::SimpleObjAllocator::Handler< T > | |
| Cdmlc::serializer::Handler< T > | Generic serialization handler |
| Cdmlc::has_saveload< T > | Whether a type have save/load function |
| Cstd::hash< dmlc::optional< T > > | Std hash function for optional |
| Cstd::hash< mxnet::TShape > | Hash function for TShape |
| Cstd::hash< mxnet::Tuple< T > > | Hash function for Tuple |
| Cstd::hash< nnvm::TShape > | Hash function for TShape |
| Cstd::hash< nnvm::Tuple< T > > | Hash function for Tuple |
| Cmshadow::op::identity | Identity function that maps a real number to it self |
| Cdmlc::IfThenElseType< cond, Then, Else > | Template to select type based on condition For example, IfThenElseType<true, int, float>::Type will give int |
| Cmxnet::Imperative | Runtime functions for NDArray |
| Cmxnet::common::random::RandGenerator< cpu, DType >::Impl | |
| Cmxnet::common::random::RandGenerator< gpu, DType >::Impl | |
| Cmxnet::common::random::RandGenerator< gpu, double >::Impl | |
| Cnnvm::IndexedGraph | Auxiliary data structure to index a graph. It maps Nodes in the graph to consecutive integers node_id. It also maps IndexedGraph::NodeEntry to consecutive integer entry_id. This allows storing properties of Node and NodeEntry into compact vector and quickly access them without resorting to hashmap |
| ►Cmxnet::cpp::Initializer | |
| Cmxnet::cpp::Bilinear | |
| ►Cmxnet::cpp::Constant | |
| Cmxnet::cpp::One | |
| Cmxnet::cpp::Zero | |
| Cmxnet::cpp::Normal | |
| Cmxnet::cpp::Uniform | |
| ►Cmxnet::cpp::Xavier | |
| Cmxnet::cpp::MSRAPrelu | |
| Cmxnet::runtime::InplaceArrayBase< ArrayType, ElemType > | Base template for classes with array like memory layout |
| ►Cmxnet::runtime::InplaceArrayBase< ADTObj, ObjectRef > | |
| Cmxnet::runtime::ADTObj | An object representing a structure or enumeration |
| ►Cdmlc::InputSplit | Input split creates that allows reading of records from split of data, independent part that covers all the dataset |
| Cdmlc::InputSplitShuffle | Class to construct input split with global shuffling |
| Cmxnet::InspectorManager | This singleton struct mediates individual TensorInspector objects so that we can control the global behavior from each of them |
| Cdmlc::is_arithmetic< T > | Whether a type is arithemetic type |
| Cdmlc::is_floating_point< T > | Whether a type is floating point type |
| Cdmlc::is_integral< T > | Whether a type is integer type |
| Cdmlc::is_pod< T > | Whether a type is pod type |
| Cmshadow::utils::IStream | Interface of stream I/O, used to serialize data, mshadow does not restricted to only this interface in SaveBinary/LoadBinary mshadow accept all class that implements Read and Write |
| Cmxnet::IterAdapter< Converter, TIter > | Iterator adapter that adapts TIter to return another type |
| ►Citerator | |
| Cdmlc::Config::ConfigIterator | Iterator class |
| Cdmlc::JSONObjectReadHelper | Helper class to read JSON into a class or struct object |
| CJsonParser | Functions used for parsing JSON |
| Cdmlc::JSONReader | Lightweight JSON Reader to read any STL compositions and structs. The user need to know the schema of the |
| CJsonVal | Definition of JSON objects |
| Cdmlc::JSONWriter | Lightweight json to write any STL compositions |
| Cmxnet::cpp::KVStore | |
| Cmxnet::KVStore | Distributed key-value store |
| Cnnvm::Layout | |
| Cmshadow::LayoutType< layout > | |
| Cmshadow::LayoutType< kNCDHW > | |
| Cmshadow::LayoutType< kNCHW > | |
| Cmshadow::LayoutType< kNDHWC > | |
| Cmshadow::LayoutType< kNHWC > | |
| Cmxnet::common::LazyAllocArray< TElem > | |
| CLibFeature | |
| Cmxnet::features::LibInfo | |
| ►Cmxnet::cpp::LRScheduler | Lr scheduler interface |
| Cmxnet::cpp::FactorScheduler | |
| Cdmlc::LuaRef | Reference to lua object |
| Cdmlc::LuaState | A Lua state |
| Cdmlc::ManualEvent | Simple manual-reset event gate which remains open after signalled |
| Cmshadow::MapExpCPUEngine< pass_check, Saver, R, dim, DType, E, etype > | |
| Cmshadow::MapExpCPUEngine< true, SV, Tensor< cpu, dim, DType >, dim, DType, E, etype > | |
| Cmshadow::red::maximum | Maximum reducer |
| Cdmlc::MemoryPool< size, align > | A memory pool that allocate memory of fixed size and alignment |
| Cmshadow::red::minimum | Minimum reducer |
| Cmshadow::op::minus | Minus operator |
| Cmshadow::sv::minusto | Minus to saver: -= |
| Cmxnet::cpp::Monitor | Monitor interface |
| Cmshadow::op::complex::mul | |
| Cmshadow::op::mul | Mul operator |
| Cmshadow::sv::multo | Multiply to saver: *= |
| CMXCallbackList | |
| CMXContext | Context info passing from MXNet OpContext dev_type is string repr of supported context, currently only "cpu" and "gpu" dev_id is the device index where the tensor locates |
| Cmxnet::cpp::MXDataIterBlob | |
| Cmxnet::cpp::MXDataIterMap | |
| Cmxnet::runtime::MXNetArgs | Arguments into TVM functions |
| Cmxnet::runtime::MXNetArgsSetter | |
| CMXNetByteArray | Byte array type used to pass in byte array When kBytes is used as data type |
| Cmxnet::runtime::MXNetDataType | Runtime primitive data type |
| ►Cmxnet::runtime::MXNetPODValue_ | Internal base class to handle conversion to POD values |
| Cmxnet::runtime::MXNetArgValue | A single argument value to PackedFunc. Containing both type_code and MXNetValue |
| Cmxnet::runtime::MXNetRetValue | Return Value container, Unlike MXNetArgValue, which only holds reference and do not delete the underlying container during destruction |
| CMXNetValue | Union type of values being passed through API and function calls |
| Cmxnet::runtime::detail::MXNetValueCast< T, TSrc, is_ext, is_nd > | |
| CMXSparse | |
| CMXTensor | Tensor data structure used by custom operator |
| CNativeOpInfo | |
| Cmxnet::cpp::NDArray | NDArray interface |
| Cmxnet::NDArray | Ndarray interface |
| CNDArrayOpInfo | |
| Cmxnet::cpp::NDBlob | Struct to store NDArrayHandle |
| Cnnvm::IndexedGraph::Node | Node data structure in IndexedGraph |
| Cnnvm::Node | Node represents an operation in a computation graph |
| Cnnvm::NodeAttrs | The attributes of the current operation node. Usually are additional parameters like axis, |
| Cnnvm::IndexedGraph::NodeEntry | Data in the graph |
| Cnnvm::NodeEntry | Entry that represents output data from a node |
| Cnnvm::NodeEntryEqual | This lets you use a NodeEntry as a key in a unordered_map of the form unordered_map<NodeEntry, ValueType, NodeEntryHash, NodeEntryEqual> |
| Cnnvm::NodeEntryHash | This lets you use a NodeEntry as a key in a unordered_map of the form unordered_map<NodeEntry, ValueType, NodeEntryHash, NodeEntryEqual> |
| Cdmlc::nullopt_t | Dummy type for assign null to optional |
| Cmxnet::runtime::ObjAllocatorBase< Derived > | Base class of object allocators that implements make. Use curiously recurring template pattern |
| ►Cmxnet::runtime::ObjAllocatorBase< SimpleObjAllocator > | |
| Cmxnet::runtime::SimpleObjAllocator | |
| ►Cmxnet::runtime::Object | Base class of all object containers |
| Cmxnet::runtime::ADTObj | An object representing a structure or enumeration |
| Cmxnet::runtime::EllipsisObj | Ellipsis |
| Cmxnet::runtime::IntegerObj | |
| Cmxnet::runtime::SliceObj | Slice |
| Cmxnet::runtime::ObjectEqual | ObjectRef equal functor |
| Cmxnet::runtime::ObjectHash | ObjectRef hash functor |
| Cmxnet::common::ObjectPool< T > | Object pool for fast allocation and deallocation |
| Cmxnet::common::ObjectPoolAllocatable< T > | Helper trait class for easy allocation and deallocation |
| Cmxnet::runtime::ObjectPtr< T > | A custom smart pointer for Object |
| Cmxnet::runtime::ObjectPtr< mxnet::runtime::ADTObj > | |
| Cmxnet::runtime::ObjectPtr< mxnet::runtime::Object > | |
| ►Cmxnet::runtime::ObjectRef | Base class of all object reference |
| Cmxnet::runtime::ADT | Reference to algebraic data type objects |
| Cmxnet::runtime::Integer | |
| Cmxnet::runtime::Slice | |
| Cdmlc::OMPException | OMP Exception class catches, saves and rethrows exception from OMP blocks |
| Cnnvm::Op | Operator structure |
| Cmxnet::OpContext | All the possible information needed by Operator.Forward and Backward This is the superset of RunContext. We use this data structure to bookkeep everything needed by Forward and Backward |
| Cmxnet::cpp::Operator | Operator interface |
| Cmxnet::Operator | Operator interface. Operator defines basic operation unit of optimized computation graph in mxnet. This interface relies on pre-allocated memory in TBlob, the caller need to set the memory region in TBlob correctly before calling Forward and Backward |
| Cmxnet::OperatorProperty | OperatorProperty is a object that stores all information about Operator. It also contains method to generate context(device) specific operators |
| Cnnvm::OpGroup | Auxiliary data structure used to set attributes to a group of operators |
| Cmxnet::cpp::OpMap | OpMap instance holds a map of all the symbol creators so we can get symbol creators by name. This is used internally by Symbol and Operator |
| Cnnvm::OpMap< ValueType > | A map data structure that takes Op* as key and returns ValueType |
| COpResource | Provide resource APIs memory allocation mechanism to Forward/Backward functions |
| Cmxnet::OpStatePtr | Operator state. This is a pointer type, its content is mutable even if OpStatePtr is const |
| ►Cmxnet::cpp::Optimizer | Optimizer interface |
| Cmxnet::cpp::AdaDeltaOptimizer | |
| Cmxnet::cpp::AdaGradOptimizer | |
| Cmxnet::cpp::AdamOptimizer | |
| Cmxnet::cpp::RMSPropOptimizer | |
| Cmxnet::cpp::SGDOptimizer | |
| Cmxnet::cpp::SignumOptimizer | |
| Cmxnet::cpp::OptimizerRegistry | |
| Cdmlc::optional< T > | C++17 compatible optional class |
| Cmxnet::runtime::PackedFunc | Packed function is a type-erased function. The arguments are passed by packed format |
| Cmshadow::packet::Packet< DType, Arch > | Generic packet type |
| Cmshadow::packet::Packet< double, kSSE2 > | Vector real type for float |
| Cmshadow::packet::Packet< DType, kPlain > | |
| Cmshadow::packet::Packet< float, kSSE2 > | |
| Cmshadow::expr::PacketAlignCheck< dim, E, Arch > | |
| Cmshadow::expr::PacketAlignCheck< dim, BinaryMapExp< OP, TA, TB, DType, etype >, Arch > | |
| Cmshadow::expr::PacketAlignCheck< dim, ScalarExp< DType >, Arch > | |
| Cmshadow::expr::PacketAlignCheck< dim, Tensor< cpu, dim, DType >, Arch > | |
| Cmshadow::expr::PacketAlignCheck< dim, UnaryMapExp< OP, TA, DType, etype >, Arch > | |
| Cmshadow::expr::PacketCheck< E, Arch > | Static check packet enable |
| Cmshadow::expr::PacketCheck< BinaryMapExp< OP, TA, TB, DType, etype >, Arch > | |
| Cmshadow::expr::PacketCheck< double, Arch > | |
| Cmshadow::expr::PacketCheck< float, Arch > | |
| Cmshadow::expr::PacketCheck< ScalarExp< DType >, Arch > | |
| Cmshadow::expr::PacketCheck< Tensor< cpu, dim, DType >, Arch > | |
| Cmshadow::expr::PacketCheck< UnaryMapExp< OP, TA, DType, etype >, Arch > | |
| Cmshadow::packet::PacketOp< OP, DType, Arch > | Generic Packet operator |
| Cmshadow::packet::PacketOp< op::div, DType, Arch > | |
| Cmshadow::packet::PacketOp< op::identity, DType, Arch > | |
| Cmshadow::packet::PacketOp< op::minus, DType, Arch > | |
| Cmshadow::packet::PacketOp< op::mul, DType, Arch > | |
| Cmshadow::packet::PacketOp< op::plus, DType, Arch > | |
| Cmshadow::expr::PacketPlan< ExpType, DType, Arch > | |
| Cmshadow::expr::PacketPlan< BinaryMapExp< OP, TA, TB, DType, etype >, DType, Arch > | |
| Cmshadow::expr::PacketPlan< ScalarExp< DType >, DType, Arch > | |
| Cmshadow::expr::PacketPlan< TA, DType, Arch > | |
| Cmshadow::expr::PacketPlan< TB, DType, Arch > | |
| Cmshadow::expr::PacketPlan< Tensor< Device, dim, DType >, DType, Arch > | |
| Cmshadow::expr::PacketPlan< UnaryMapExp< OP, TA, DType, etype >, DType, Arch > | |
| Cmshadow::op::complex::pad_imag | |
| CPassResource | |
| Cmshadow::expr::Plan< ExpType, DType > | |
| Cmshadow::expr::Plan< BinaryMapExp< OP, TA, TB, DType, etype >, DType > | |
| Cmshadow::expr::Plan< Broadcast1DExp< SrcExp, DType, dimdst, 1 >, DType > | Execution plan of Broadcast1DExp |
| Cmshadow::expr::Plan< Broadcast1DExp< SrcExp, DType, dimdst, dimdst_m_cast >, DType > | |
| Cmshadow::expr::Plan< BroadcastScalarExp< SrcExp, DType, dimdst >, DType > | Execution plan of Broadcast1DExp |
| Cmshadow::expr::Plan< BroadcastWithAxisExp< SrcExp, DType, dimsrc, dimdst >, DType > | |
| Cmshadow::expr::Plan< BroadcastWithMultiAxesExp< SrcExp, DType, dimsrc >, DType > | |
| Cmshadow::expr::Plan< ChannelPoolingExp< Reducer, SrcExp, DType, srcdim >, DType > | |
| Cmshadow::expr::Plan< ChannelUnpoolingExp< Reducer, SrcExp, DType, srcdim >, DType > | |
| Cmshadow::expr::Plan< ComplexBinaryMapExp< op::complex::kBinaryCC, OP, TA, TB, DType, etype >, DType > | |
| Cmshadow::expr::Plan< ComplexBinaryMapExp< op::complex::kBinaryCR, OP, TA, TB, DType, etype >, DType > | |
| Cmshadow::expr::Plan< ComplexBinaryMapExp< op::complex::kBinaryRC, OP, TA, TB, DType, etype >, DType > | |
| Cmshadow::expr::Plan< ComplexUnitaryExp< op::complex::kUnitaryC2C, OP, TA, DType, etype >, DType > | |
| Cmshadow::expr::Plan< ComplexUnitaryExp< op::complex::kUnitaryC2R, OP, TA, DType, etype >, DType > | |
| Cmshadow::expr::Plan< ComplexUnitaryExp< op::complex::kUnitaryR2C, OP, TA, DType, etype >, DType > | |
| Cmshadow::expr::Plan< ConcatExp< LhsExp, RhsExp, Device, DType, srcdim, 1 >, DType > | |
| Cmshadow::expr::Plan< ConcatExp< LhsExp, RhsExp, Device, DType, srcdim, dimsrc_m_cat >, DType > | |
| Cmshadow::expr::Plan< CroppingExp< SrcExp, DType, srcdim >, DType > | |
| Cmshadow::expr::Plan< EType, DType > | |
| Cmshadow::expr::Plan< EType, SrcDType > | |
| Cmshadow::expr::Plan< FlipExp< SrcExp, Device, DType, srcdim >, DType > | |
| Cmshadow::expr::Plan< ImplicitGEMMExp< LhsExp, RhsExp, DType >, DType > | |
| Cmshadow::expr::Plan< IndexExp, DType > | |
| Cmshadow::expr::Plan< LhsExp, DType > | |
| Cmshadow::expr::Plan< MakeTensorExp< SubType, SrcExp, dim, DType >, DType > | |
| Cmshadow::expr::Plan< MaskExp< IndexExp, SrcExp, DType >, DType > | |
| Cmshadow::expr::Plan< MatChooseRowElementExp< SrcExp, IndexExp, DType >, DType > | |
| Cmshadow::expr::Plan< MatFillRowElementExp< SrcExp, ValExp, IndexExp, DType >, DType > | |
| Cmshadow::expr::Plan< MirroringExp< SrcExp, DType, srcdim >, DType > | |
| Cmshadow::expr::Plan< OneHotEncodeExp< IndexExp, DType >, DType > | |
| Cmshadow::expr::Plan< PackColToPatchXExp< SrcExp, DType, dstdim >, DType > | |
| Cmshadow::expr::Plan< PaddingExp< SrcExp, DType, srcdim >, DType > | |
| Cmshadow::expr::Plan< PoolingExp< Reducer, SrcExp, DType, srcdim >, DType > | |
| Cmshadow::expr::Plan< RangeExp< DType >, DType > | |
| Cmshadow::expr::Plan< ReduceWithAxisExp< Reducer, SrcExp, DType, dimsrc, mask, dimdst >, DType > | |
| Cmshadow::expr::Plan< ReshapeExp< SrcExp, DType, dimdst, 1 >, DType > | |
| Cmshadow::expr::Plan< ReshapeExp< SrcExp, DType, dimdst, dimsrc >, DType > | |
| Cmshadow::expr::Plan< RhsExp, DType > | |
| Cmshadow::expr::Plan< ScalarExp< DType >, DType > | |
| Cmshadow::expr::Plan< SliceExExp< SrcExp, Device, DType, srcdim >, DType > | |
| Cmshadow::expr::Plan< SliceExp< SrcExp, Device, DType, srcdim, 1 >, DType > | |
| Cmshadow::expr::Plan< SliceExp< SrcExp, Device, DType, srcdim, dimsrc_m_slice >, DType > | |
| Cmshadow::expr::Plan< SrcExp, DType > | |
| Cmshadow::expr::Plan< SubType, DType > | |
| Cmshadow::expr::Plan< SwapAxisExp< SrcExp, DType, dimsrc, 1, a2 >, DType > | |
| Cmshadow::expr::Plan< SwapAxisExp< SrcExp, DType, dimsrc, m_a1, a2 >, DType > | |
| Cmshadow::expr::Plan< TA, DType > | |
| Cmshadow::expr::Plan< TakeExp< IndexExp, SrcExp, DType >, DType > | |
| Cmshadow::expr::Plan< TakeGradExp< IndexExp, SrcExp, DType >, DType > | |
| Cmshadow::expr::Plan< TB, DType > | |
| Cmshadow::expr::Plan< TC, DType > | |
| Cmshadow::expr::Plan< Tensor< Device, 1, DType >, DType > | |
| Cmshadow::expr::Plan< Tensor< Device, dim, DType >, DType > | |
| Cmshadow::expr::Plan< TernaryMapExp< OP, TA, TB, TC, DType, etype >, DType > | |
| Cmshadow::expr::Plan< TransposeExExp< SrcExp, DType, dimsrc >, DType > | |
| Cmshadow::expr::Plan< TransposeExp< EType, DType >, DType > | |
| Cmshadow::expr::Plan< TransposeIndicesExp< SrcExp, DType, dimsrc, etype >, DType > | |
| Cmshadow::expr::Plan< TypecastExp< DstDType, SrcDType, EType, etype >, DstDType > | |
| Cmshadow::expr::Plan< UnaryMapExp< OP, TA, DType, etype >, DType > | |
| Cmshadow::expr::Plan< UnpackPatchToColXExp< SrcExp, DType, srcdim >, DType > | |
| Cmshadow::expr::Plan< UnPoolingExp< Reducer, SrcExp, DType, srcdim >, DType > | |
| Cmshadow::expr::Plan< UpSamplingNearestExp< SrcExp, DType, srcdim >, DType > | |
| Cmshadow::expr::Plan< ValExp, DType > | |
| Cmshadow::op::plus | Plus operator |
| Cmshadow::sv::plusto | Save to saver: += |
| Cdmlc::ThreadedIter< DType >::Producer | Producer class interface that threaditer used as source to preduce the content |
| Cmxnet::common::random::RandGenerator< Device, MSHADOW_DEFAULT_DTYPE > | |
| Cmxnet::common::random::RandGenerator< cpu, DType > | |
| Cmxnet::common::random::RandGenerator< gpu, double > | |
| Cmxnet::common::random::RandGenerator< gpu, DType > | |
| Cmxnet::common::random::RandGenerator< mshadow::gpu, double > | |
| Cmxnet::common::random::RandGenerator< mshadow::gpu, DType > | |
| Cmshadow::Random< Device, MSHADOW_DEFAULT_DTYPE > | Random number generator |
| Cmshadow::Random< cpu, DType > | CPU random number generator |
| Cmshadow::Random< gpu, DType > | GPU random number generator |
| Cdmlc::RecordIOChunkReader | Reader of binary recordio from Blob returned by InputSplit This class divides the blob into several independent parts specified by caller, and read from one segment. The part reading can be used together with InputSplit::NextChunk for multi-threaded parsing(each thread take a RecordIOChunkReader) |
| Cdmlc::RecordIOReader | Reader of binary recordio to reads in record from stream |
| Cdmlc::RecordIOWriter | Writer of binary recordio binary format for recordio recordio format: magic lrecord data pad |
| Cmxnet::runtime::Registry | Registry for global function |
| CRegistry< T > | Registry class to registers things (ops, properties) Singleton class |
| Cdmlc::Registry< EntryType > | Registry class. Registry can be used to register global singletons. The most commonly use case are factory functions |
| Cmxnet::Resource | Resources used by mxnet operations. A resource is something special other than NDArray, but will still participate |
| Cmxnet::ResourceManager | Global resource manager |
| Cmxnet::ResourceRequest | The resources that can be requested by Operator |
| Cmshadow::op::right | Get rhs |
| Cdmlc::Row< IndexType, DType > | One row of training instance |
| Cdmlc::RowBlock< IndexType, DType > | Block of data, containing several rows in sparse matrix This is useful for (streaming-sxtyle) algorithms that scans through rows of data examples include: SGD, GD, L-BFGS, kmeans |
| Cmxnet::common::rsp_idx_check | Indices of RSPNDArray should be non-negative, less than the size of first dimension and in ascending order |
| Cmxnet::RunContext | Execution time context. The information needed in runtime for actual execution |
| Cmshadow::packet::Saver< SV, TFloat, Arch > | |
| Cmshadow::packet::Saver< sv::saveto, TFloat, Arch > | |
| Cmshadow::sv::saveto | Save to saver: = |
| Cdmlc::ScopedThread | Wrapper class to manage std::thread; uses RAII pattern to automatically join std::thread upon destruction |
| Cdmlc::Serializable | Interface for serializable objects |
| Cmxnet::cpp::Shape | Dynamic shape class that can hold shape of arbirary dimension |
| Cmshadow::Shape< dimension > | Shape of a tensor |
| Cmshadow::Shape< 1 > | |
| Cmshadow::Shape< 2 > | |
| Cmshadow::Shape< 4 > | |
| Cmshadow::Shape< dim > | |
| Cmshadow::Shape< dimsrc > | |
| Cmshadow::Shape< srcdim > | |
| Cmshadow::expr::ShapeCheck< dim, E > | Runtime shape checking template get the shape of an expression, report error if shape mismatch |
| Cmshadow::expr::ShapeCheck< dim, BinaryMapExp< OP, TA, TB, DType, etype > > | |
| Cmshadow::expr::ShapeCheck< dim, ComplexBinaryMapExp< calctype, OP, TA, TB, DType, etype > > | |
| Cmshadow::expr::ShapeCheck< dim, ComplexUnitaryExp< calctype, OP, TA, DType, etype > > | |
| Cmshadow::expr::ShapeCheck< dim, ImplicitGEMMExp< LhsExp, RhsExp, DType > > | |
| Cmshadow::expr::ShapeCheck< dim, MakeTensorExp< T, SrcExp, dim, DType > > | |
| Cmshadow::expr::ShapeCheck< dim, MaskExp< IndexExp, SrcExp, DType > > | |
| Cmshadow::expr::ShapeCheck< dim, MatChooseRowElementExp< SrcExp, IndexExp, DType > > | |
| Cmshadow::expr::ShapeCheck< dim, MatFillRowElementExp< SrcExp, ValExp, IndexExp, DType > > | |
| Cmshadow::expr::ShapeCheck< dim, OneHotEncodeExp< IndexExp, DType > > | |
| Cmshadow::expr::ShapeCheck< dim, RangeExp< DType > > | |
| Cmshadow::expr::ShapeCheck< dim, ScalarExp< DType > > | |
| Cmshadow::expr::ShapeCheck< dim, TakeExp< IndexExp, SrcExp, DType > > | |
| Cmshadow::expr::ShapeCheck< dim, TakeGradExp< IndexExp, SrcExp, DType > > | |
| Cmshadow::expr::ShapeCheck< dim, Tensor< Device, dim, DType > > | |
| Cmshadow::expr::ShapeCheck< dim, TernaryMapExp< OP, TA, TB, TC, DType, etype > > | |
| Cmshadow::expr::ShapeCheck< dim, TransposeExp< E, DType > > | |
| Cmshadow::expr::ShapeCheck< dim, TransposeIndicesExp< SrcExp, DType, dimsrc, etype > > | |
| Cmshadow::expr::ShapeCheck< dim, TypecastExp< DstDType, SrcDType, EType, etype > > | |
| Cmshadow::expr::ShapeCheck< dim, UnaryMapExp< OP, TA, DType, etype > > | |
| Cmshadow::expr::ShapeCheck< srcdim, ConcatExp< LhsExp, RhsExp, Device, DType, srcdim, dimsrc_m_cat > > | |
| Cmshadow::expr::ShapeCheck< srcdim, FlipExp< SrcExp, Device, DType, srcdim > > | |
| Cmshadow::expr::ShapeCheck< srcdim, SliceExExp< SrcExp, Device, DType, srcdim > > | |
| Cmshadow::expr::ShapeCheck< srcdim, SliceExp< SrcExp, Device, DType, srcdim, dimsrc_m_slice > > | |
| Cmxnet::op::SimpleOpRegEntry | Registry entry to register simple operators via functions |
| Cmxnet::op::SimpleOpRegistry | Registry for TBlob functions |
| Cdmlc::Spinlock | Simple userspace spinlock implementation |
| Cmxnet::common::StaticArray< T, num > | Static array. This code is borrowed from struct Shape<ndim>, except that users can specify the type of the elements of the statically allocated array. The object instance of the struct is copyable between CPU and GPU |
| Cmxnet::Storage | Storage manager across multiple devices |
| Cdmlc::Str2T< T > | Interface class that defines a single method get() to convert a string into type T. Define template specialization of this class to define the conversion method for a particular type |
| Cdmlc::Str2T< double > | Template specialization of Str2T<> interface for double type |
| Cdmlc::Str2T< float > | Template specialization of Str2T<> interface for float type |
| Cdmlc::Str2T< int32_t > | Template specialization of Str2T<> interface for signed 32-bit integer |
| Cdmlc::Str2T< int64_t > | Template specialization of Str2T<> interface for signed 64-bit integer |
| Cdmlc::Str2T< uint32_t > | Template specialization of Str2T<> interface for unsigned 32-bit integer |
| Cdmlc::Str2T< uint64_t > | Template specialization of Str2T<> interface for unsigned 64-bit integer |
| Cmshadow::Stream< Device > | Computaion stream structure, used for asynchronous computations |
| ►Cdmlc::Stream | Interface of stream I/O for serialization |
| ►Cdmlc::SeekStream | Interface of i/o stream that support seek |
| Cdmlc::MemoryFixedSizeStream | A Stream that operates on fixed region of memory This class allows us to read/write from/to a fixed memory region |
| Cdmlc::MemoryStringStream | A in memory stream that is backed by std::string. This class allows us to read/write from/to a std::string |
| Cmshadow::Stream< gpu > | |
| Cmshadow::Stream< mshadow::cpu > | |
| Cmshadow::Stream< mshadow::gpu > | |
| Cmshadow::expr::StreamInfo< Device, E > | |
| Cmshadow::expr::StreamInfo< Device, ConcatExp< LhsExp, RhsExp, Device, DType, srcdim, dimsrc_m_cat > > | |
| Cmshadow::expr::StreamInfo< Device, FlipExp< SrcExp, Device, DType, srcdim > > | |
| Cmshadow::expr::StreamInfo< Device, SliceExExp< SrcExp, Device, DType, srcdim > > | |
| Cmshadow::expr::StreamInfo< Device, SliceExp< SrcExp, Device, DType, srcdim, dimsrc_m_slice > > | |
| Cmshadow::expr::StreamInfo< Device, Tensor< Device, dim, DType > > | |
| Cmshadow::red::sum | Sum reducer |
| Cmshadow::op::complex::sum_real_imag | |
| Cmxnet::cpp::SymBlob | Struct to store SymbolHandle |
| Cmxnet::cpp::Symbol | Symbol interface |
| Cnnvm::Symbol | Symbol is help class used to represent the operator node in Graph |
| Cmxnet::SyncedGPUAuxStream | Provides automatic coordination of an auxilary stream with a primary one. This object, upon construction, prepares an aux stream for use by syncing it with enqueued primary-stream work. Object destruction will sync again so future primary-stream work will wait on enqueued aux-stream work. If MXNET_GPU_WORKER_NSTREAMS == 1, then this defaults simply: the primary stream will equal the aux stream and the syncs will be executed as nops. See ./src/operator/cudnn/cudnn_convolution-inl.h for a usage example |
| Cmxnet::TBlob | Tensor blob class that can be used to hold tensor of any dimension, any device and any data type, This is a weak type that can be used to transfer data through interface TBlob itself doesn't involve any arithmetic operations, but it can be converted to tensor of fixed dimension for further operations |
| Cdmlc::TemporaryDirectory | Manager class for temporary directories. Whenever a new TemporaryDirectory object is constructed, a temporary directory is created. The directory is deleted when the object is deleted or goes out of scope. Note: no symbolic links are allowed inside the temporary directory |
| Cmxnet::TensorInspector | This class provides a unified interface to inspect the value of all data types including Tensor, TBlob, and NDArray. If the tensor resides on GPU, then it will be copied from GPU memory back to CPU memory to be operated on. Internally, all data types are stored as a TBlob object tb_ |
| ►Cdmlc::ThreadGroup::Thread | Lifecycle-managed thread (used by ThreadGroup) |
| Cdmlc::BlockingQueueThread< ObjectType, quit_item > | Blocking queue thread class |
| Cdmlc::TimerThread< Duration > | Managed timer thread |
| Cdmlc::ThreadGroup | Thread lifecycle management group |
| Cdmlc::ThreadlocalAllocator< T > | A thread local allocator that get memory from a threadlocal memory pool. This is suitable to allocate objects that do not cross thread |
| Cdmlc::ThreadlocalSharedPtr< T > | Shared pointer like type that allocate object from a threadlocal object pool. This object is not thread-safe but can be faster than shared_ptr in certain usecases |
| Cdmlc::ThreadLocalStore< T > | A threadlocal store to store threadlocal variables. Will return a thread local singleton of type T |
| Cmshadow::op::complex::toreal | |
| Cmxnet::Tuple< ValueType > | A dynamic sized array data structure that is optimized for storing small number of elements with same type |
| Cnnvm::Tuple< ValueType > | A dynamic sized array data structure that is optimized for storing small number of elements with same type |
| ►Cmxnet::Tuple< dim_t > | |
| Cmxnet::TShape | A Shape class that is used to represent shape of each tensor |
| ►Cnnvm::Tuple< dim_t > | |
| Cnnvm::TShape | A Shape class that is used to represent shape of each tensor |
| Cdmlc::type_name_helper< T > | Helper class to construct a string that represents type name |
| Cdmlc::type_name_helper< mxnet::Tuple< T > > | |
| Cdmlc::type_name_helper< nnvm::Tuple< T > > | |
| Cmshadow::expr::TypeCheck< Device, dim, DType, E > | Template to do type check |
| Cmshadow::expr::TypeCheckPass< kPass > | Used to help static type check |
| Cmshadow::expr::TypeCheckPass< false > | |
| Cmshadow::expr::TypeCheckPass< true > | |
| Cmxnet::runtime::detail::typed_packed_call_dispatcher< R > | |
| Cmxnet::runtime::detail::typed_packed_call_dispatcher< void > | |
| Cmxnet::runtime::TypedPackedFunc< FType > | Please refer to TypedPackedFunc<R(Args..)> |
| Cmxnet::runtime::TypedPackedFunc< R(Args...)> | A PackedFunc wrapper to provide typed function signature. It is backed by a PackedFunc internally |
| Cmxnet::common::helper::UniqueIf< T > | Helper for non-array type T |
| Cmxnet::common::helper::UniqueIf< T[]> | Helper for an array of unknown bound T |
| Cmxnet::common::helper::UniqueIf< T[kSize]> | Helper for an array of known bound T |
| Cmxnet::runtime::detail::unpack_call_dispatcher< R, nleft, index, F > | |
| Cmxnet::runtime::detail::unpack_call_dispatcher< R, 0, index, F > | |
| Cmxnet::runtime::detail::unpack_call_dispatcher< void, 0, index, F > | |
| Cdmlc::io::URI | Common data structure for URI |
| Cmxnet::Array< T, typename >::ValueConverter | |
| Cmxnet::engine::Var | Base class of engine variables |
| ►CObject | |
| Cmxnet::ArrayNode | Array node content in array |
| ►Cmxnet::BaseExprNode | Base type of all the expressions |
| ►Cmxnet::PrimExprNode | Base node of all primitive expressions |
| Cmxnet::FloatImmNode | Constant floating point literals in the program |
| Cmxnet::IntImmNode | Constant integer literals in the program |
| ►CObjectRef | |
| Cmxnet::Array< T, typename > | Array container of NodeRef in DSL graph. Array implements copy on write semantics, which means array is mutable but copy will happen when array is referenced in more than two places |
| ►Cmxnet::BaseExpr | Managed reference to BaseExprNode |
| ►Cmxnet::PrimExpr | Reference to PrimExprNode |
| Cmxnet::FloatImm | Managed reference class to FloatImmNode |
| Cmxnet::IntImm | Managed reference class to IntImmNode |
1.8.11
