This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 123]

Ccaffe::Batch< Dtype >
Ccaffe::Blob< Dtype >	A wrapper around SyncedMemory holders serving as the basic computational unit through which Layers, Nets, and Solvers interact
Ccaffe::Blob< int >
Ccaffe::Blob< unsigned int >
Ccaffe::BlockingQueue< T >
Ccaffe::BlockingQueue< caffe::Batch< Dtype > *>
Ccaffe::Caffe
Ccaffe::Net< Dtype >::Callback
Ccaffe::Solver< Dtype >::Callback
Ccaffe::db::Cursor
Ccaffe::DataTransformer< Dtype >	Applies common transformations to the input data, such as scaling, mirroring, substracting the image mean..
Ccaffe::db::DB
▼Ccaffe::Filler< Dtype >	Fills a Blob with constant or randomly-generated data
Ccaffe::BilinearFiller< Dtype >	Fills a Blob with coefficients for bilinear interpolation
Ccaffe::ConstantFiller< Dtype >	Fills a Blob with constant values
Ccaffe::GaussianFiller< Dtype >	Fills a Blob with Gaussian-distributed values
Ccaffe::MSRAFiller< Dtype >	Fills a Blob with values $x \sim N(0, \sigma^2)$ where $\sigma^2$ is set inversely proportional to number of incoming nodes, outgoing nodes, or their average
Ccaffe::PositiveUnitballFiller< Dtype >	Fills a Blob with values $x \in [0, 1]$ such that $\forall i \sum_j x_{ij} = 1$
Ccaffe::UniformFiller< Dtype >	Fills a Blob with uniformly distributed values $x\sim U(a, b)$
Ccaffe::XavierFiller< Dtype >	Fills a Blob with values $x \sim U(-a, +a)$ where is set inversely proportional to number of incoming nodes, outgoing nodes, or their average
Ccaffe::Caffe::RNG::Generator
▼Ccaffe::InternalThread
►Ccaffe::BasePrefetchingDataLayer< Dtype >
Ccaffe::DataLayer< Dtype >
Ccaffe::ImageDataLayer< Dtype >	Provides data to the Net from image files
Ccaffe::WindowDataLayer< Dtype >	Provides data to the Net from windows of images files, specified by a window data file. This layer is DEPRECATED and only kept for archival purposes for use by the original R-CNN
▼Ccaffe::Layer< Dtype >	An interface for the units of computation which can be composed into a Net
Ccaffe::AccuracyLayer< Dtype >	Computes the classification accuracy for a one-of-many classification task
Ccaffe::ArgMaxLayer< Dtype >	Compute the index of the max values for each datum across all dimensions $(C \times H \times W)$
►Ccaffe::BaseConvolutionLayer< Dtype >	Abstract base class that factors out the BLAS code common to ConvolutionLayer and DeconvolutionLayer
Ccaffe::ConvolutionLayer< Dtype >	Convolves the input image with a bank of learned filters, and (optionally) adds biases
Ccaffe::DeconvolutionLayer< Dtype >	Convolve the input with a bank of learned filters, and (optionally) add biases, treating filters and convolution parameters in the opposite sense as ConvolutionLayer
►Ccaffe::BaseDataLayer< Dtype >	Provides base for data layers that feed blobs to the Net
Ccaffe::BasePrefetchingDataLayer< Dtype >
Ccaffe::MemoryDataLayer< Dtype >	Provides data to the Net from memory
Ccaffe::BatchNormLayer< Dtype >	Normalizes the input to have 0-mean and/or unit (1) variance across the batch
Ccaffe::BatchReindexLayer< Dtype >	Index into the input blob along its first axis
Ccaffe::BiasLayer< Dtype >	Computes a sum of two input Blobs, with the shape of the latter Blob "broadcast" to match the shape of the former. Equivalent to tiling the latter Blob, then computing the elementwise sum
Ccaffe::ConcatLayer< Dtype >	Takes at least two Blobs and concatenates them along either the num or channel dimension, outputting the result
Ccaffe::CropLayer< Dtype >	Takes a Blob and crop it, to the shape specified by the second input Blob, across all dimensions after the specified axis
Ccaffe::DummyDataLayer< Dtype >	Provides data to the Net generated by a Filler
Ccaffe::EltwiseLayer< Dtype >	Compute elementwise operations, such as product and sum, along multiple input Blobs
Ccaffe::EmbedLayer< Dtype >	A layer for learning "embeddings" of one-hot vector input. Equivalent to an InnerProductLayer with one-hot vectors as input, but for efficiency the input is the "hot" index of each column itself
Ccaffe::FilterLayer< Dtype >	Takes two+ Blobs, interprets last Blob as a selector and filter remaining Blobs accordingly with selector data (0 means that the corresponding item has to be filtered, non-zero means that corresponding item needs to stay)
Ccaffe::FlattenLayer< Dtype >	Reshapes the input Blob into flat vectors
Ccaffe::HDF5DataLayer< Dtype >	Provides data to the Net from HDF5 files
Ccaffe::HDF5OutputLayer< Dtype >	Write blobs to disk as HDF5 files
Ccaffe::Im2colLayer< Dtype >	A helper for image operations that rearranges image regions into column vectors. Used by ConvolutionLayer to perform convolution by matrix multiplication
Ccaffe::InnerProductLayer< Dtype >	Also known as a "fully-connected" layer, computes an inner product with a set of learned weights, and (optionally) adds biases
Ccaffe::InputLayer< Dtype >	Provides data to the Net by assigning tops directly
►Ccaffe::LossLayer< Dtype >	An interface for Layers that take two Blobs as input – usually (1) predictions and (2) ground-truth labels – and output a singleton Blob representing the loss
Ccaffe::ContrastiveLossLayer< Dtype >	Computes the contrastive loss $E = \frac{1}{2N} \sum\limits_{n=1}^N \left(y\right) d^2 + \left(1-y\right) \max \left(margin-d, 0\right)^2$ where $d = \left\| \left\| a_n - b_n \right\| \right\|_2$ . This can be used to train siamese networks
Ccaffe::EuclideanLossLayer< Dtype >	Computes the Euclidean (L2) loss $E = \frac{1}{2N} \sum\limits_{n=1}^N \left\| \left\| \hat{y}_n - y_n \right\| \right\|_2^2$ for real-valued regression tasks
Ccaffe::HingeLossLayer< Dtype >	Computes the hinge loss for a one-of-many classification task
Ccaffe::InfogainLossLayer< Dtype >	A generalization of MultinomialLogisticLossLayer that takes an "information gain" (infogain) matrix specifying the "value" of all label pairs
Ccaffe::MultinomialLogisticLossLayer< Dtype >	Computes the multinomial logistic loss for a one-of-many classification task, directly taking a predicted probability distribution as input
Ccaffe::SigmoidCrossEntropyLossLayer< Dtype >	Computes the cross-entropy (logistic) loss $E = \frac{-1}{n} \sum\limits_{n=1}^N \left[ p_n \log \hat{p}_n + (1 - p_n) \log(1 - \hat{p}_n) \right]$ , often used for predicting targets interpreted as probabilities
Ccaffe::SoftmaxWithLossLayer< Dtype >	Computes the multinomial logistic loss for a one-of-many classification task, passing real-valued predictions through a softmax to get a probability distribution over classes
Ccaffe::LRNLayer< Dtype >	Normalize the input in a local region across or within feature maps
Ccaffe::LSTMUnitLayer< Dtype >	A helper for LSTMLayer: computes a single timestep of the non-linearity of the LSTM, producing the updated cell and hidden states
Ccaffe::MVNLayer< Dtype >	Normalizes the input to have 0-mean and/or unit (1) variance
►Ccaffe::NeuronLayer< Dtype >	An interface for layers that take one blob as input ( ) and produce one equally-sized blob as output ( ), where each element of the output depends only on the corresponding input element
Ccaffe::AbsValLayer< Dtype >	Computes
Ccaffe::BNLLLayer< Dtype >	Computes $y = x + \log(1 + \exp(-x))$ if ; $y = \log(1 + \exp(x))$ otherwise
Ccaffe::DropoutLayer< Dtype >	During training only, sets a random portion of to 0, adjusting the rest of the vector magnitude accordingly
Ccaffe::ELULayer< Dtype >	Exponential Linear Unit non-linearity $y = \left\{ \begin{array}{lr} x & \mathrm{if} \; x > 0 \\ \alpha (\exp(x)-1) & \mathrm{if} \; x \le 0 \end{array} \right.$
Ccaffe::ExpLayer< Dtype >	Computes $y = \gamma ^ {\alpha x + \beta}$ , as specified by the scale $\alpha$ , shift $\beta$ , and base $\gamma$
Ccaffe::LogLayer< Dtype >	Computes $y = log_{\gamma}(\alpha x + \beta)$ , as specified by the scale $\alpha$ , shift $\beta$ , and base $\gamma$
Ccaffe::PowerLayer< Dtype >	Computes $y = (\alpha x + \beta) ^ \gamma$ , as specified by the scale $\alpha$ , shift $\beta$ , and power $\gamma$
Ccaffe::PReLULayer< Dtype >	Parameterized Rectified Linear Unit non-linearity $y_i = \max(0, x_i) + a_i \min(0, x_i)$ . The differences from ReLULayer are 1) negative slopes are learnable though backprop and 2) negative slopes can vary across channels. The number of axes of input blob should be greater than or equal to 2. The 1st axis (0-based) is seen as channels
Ccaffe::ReLULayer< Dtype >	Rectified Linear Unit non-linearity $y = \max(0, x)$ . The simple max is fast to compute, and the function does not saturate
Ccaffe::SigmoidLayer< Dtype >	Sigmoid function non-linearity $y = (1 + \exp(-x))^{-1}$ , a classic choice in neural networks
Ccaffe::TanHLayer< Dtype >	TanH hyperbolic tangent non-linearity $y = \frac{\exp(2x) - 1}{\exp(2x) + 1}$ , popular in auto-encoders
Ccaffe::ThresholdLayer< Dtype >	Tests whether the input exceeds a threshold: outputs 1 for inputs above threshold; 0 otherwise
Ccaffe::ParameterLayer< Dtype >
Ccaffe::PoolingLayer< Dtype >	Pools the input image by taking the max, average, etc. within regions
Ccaffe::PythonLayer< Dtype >
►Ccaffe::RecurrentLayer< Dtype >	An abstract class for implementing recurrent behavior inside of an unrolled network. This Layer type cannot be instantiated – instead, you should use one of its implementations which defines the recurrent architecture, such as RNNLayer or LSTMLayer
Ccaffe::LSTMLayer< Dtype >	Processes sequential inputs using a "Long Short-Term Memory" (LSTM) [1] style recurrent neural network (RNN). Implemented by unrolling the LSTM computation through time
Ccaffe::RNNLayer< Dtype >	Processes time-varying inputs using a simple recurrent neural network (RNN). Implemented as a network unrolling the RNN computation in time
Ccaffe::ReductionLayer< Dtype >	Compute "reductions" – operations that return a scalar output Blob for an input Blob of arbitrary size, such as the sum, absolute sum, and sum of squares
Ccaffe::ReshapeLayer< Dtype >
Ccaffe::ScaleLayer< Dtype >	Computes the elementwise product of two input Blobs, with the shape of the latter Blob "broadcast" to match the shape of the former. Equivalent to tiling the latter Blob, then computing the elementwise product. Note: for efficiency and convenience, this layer can additionally perform a "broadcast" sum too when `bias_term: true` is set
Ccaffe::SilenceLayer< Dtype >	Ignores bottom blobs while producing no top blobs. (This is useful to suppress outputs during testing.)
Ccaffe::SliceLayer< Dtype >	Takes a Blob and slices it along either the num or channel dimension, outputting multiple sliced Blob results
Ccaffe::SoftmaxLayer< Dtype >	Computes the softmax function
Ccaffe::SplitLayer< Dtype >	Creates a "split" path in the network by copying the bottom Blob into multiple top Blobs to be used by multiple consuming layers
Ccaffe::SPPLayer< Dtype >	Does spatial pyramid pooling on the input image by taking the max, average, etc. within regions so that the result vector of different sized images are of the same size
Ccaffe::TileLayer< Dtype >	Copy a Blob along specified dimensions
Ccaffe::LayerRegisterer< Dtype >
Ccaffe::LayerRegistry< Dtype >
Ccaffe::Net< Dtype >	Connects Layers together into a directed acyclic graph (DAG) specified by a NetParameter
Ccaffe::Caffe::RNG
Ccaffe::SignalHandler
▼Ccaffe::Solver< Dtype >	An interface for classes that perform optimization on Nets
►Ccaffe::SGDSolver< Dtype >	Optimizes the parameters of a Net using stochastic gradient descent (SGD) with momentum
Ccaffe::AdaDeltaSolver< Dtype >
Ccaffe::AdaGradSolver< Dtype >
Ccaffe::AdamSolver< Dtype >	AdamSolver, an algorithm for first-order gradient-based optimization of stochastic objective functions, based on adaptive estimates of lower-order moments. Described in [1]
Ccaffe::NesterovSolver< Dtype >
Ccaffe::RMSPropSolver< Dtype >
Ccaffe::SolverRegisterer< Dtype >
Ccaffe::SolverRegistry< Dtype >
Ccaffe::BlockingQueue< T >::sync
Ccaffe::SyncedMemory	Manages memory allocation and synchronization between the host (CPU) and device (GPU)
▼Ccaffe::Timer
Ccaffe::CPUTimer
Ccaffe::db::Transaction