Packages

Here are the packages with brief descriptions (if available):

[detail level 123456]

▼NMyCaffe	The MyCaffe namespace contains the main body of MyCaffe code that closesly tracks the C++ Caffe open-source project.
►Nbasecode	The MyCaffe.basecode contains all generic types used throughout MyCaffe.
►Ndescriptors	The descriptors namespace contains all descriptor used to describe various items stored within the database.
CBaseDescriptor	The BaseDescriptor is the base class for all other descriptors, where descriptors are used to describe various items stored within the database.
CDatasetDescriptor	The DatasetDescriptor class describes a dataset which contains both a training data source and testing data source.
CGroupDescriptor	The GroupDescriptor class defines a group.
CImageDescriptor	The ImageDescriptor class describes a single image in the database.
CLabelDescriptor	The LabelDescriptor class describes a single label.
COrderedValueStreamDescriptorSet	The ordered value stream descriptor set is used to order the value stream descriptors by class and value type.
CParameterDescriptor	The ParameterDescriptor class describes a parameter in the database.
CParameterDescriptorCollection	The ParameterDescriptorCollection class contains a list of ParameterDescriptor's.
CProjectDescriptor	The ProjectDescriptor class contains all information describing a project, such as its: dataset, group, settings, solver description, model description, and parmeters.
CResultDescriptor	The ResultDescriptor class describes the results of a run.
CSourceDescriptor	The SourceDescriptor class contains all information describing a data source.
CStateDescriptor	The StateDescriptor class contains the information related to the state of a project incuding the solver state and weights.
CTemporalDescriptor	The TemporalDescriptor is used to describe a temporal aspects of the data source.
CValueDescriptor	The ValueDescriptor class contains the description of a single value.
CValueDescriptorCollection	The ValueDescriptorCollection class contains a list of ValueDescriptor's.
CValueItemDescriptor	The ValueItemDescriptor describes each value item (e.g., customer, station or stock)
CValueStreamDescriptor	The value stream descriptor describes a single value stream within a value item.
NProperties
CAnnotation	The Annotation class is used by annotations attached to SimpleDatum's and used in SSD.
CAnnotationGroup	The AnnoationGroup class manages a group of annotations.
CAnnotationGroupCollection	Defines a collection of AnnotationGroups.
CBaseParameter	The BaseParameter class is the base class for all other parameter classes.
CBinaryData	The BinaryData class is used to pack and unpack DataCriteria binary data, optionally stored within each SimpleDatum.
CBucket	The Bucket class contains the information describing a single range of values within a BucketCollection.
CBucketCollection	The BucketCollection contains a set of Buckets.
CBytemap	The Bytemap operates similar to a bitmap but is actually just an array of bytes.
CCalculateImageMeanArgs	The CalculateImageMeanArgs is passed as an argument to the MyCaffeImageDatabase::OnCalculateImageMean event.
CCancelEvent	The CancelEvent provides an extension to the manual cancel event that allows for overriding the manual cancel event.
CColorMapper	The ColorMapper maps a value within a number range, to a Color within a color scheme.
CConnectInfo	The ConnectInfo class specifies the server, database and username/password used to connect to a database.
CCryptoRandom	The CryptoRandom is a random number generator that can use either the standard .Net Random objec or the more precise RandomNumberGenerator defined within the System.Security.Cryptograph.
CDatum	The Datum class is a simple wrapper to the SimpleDatum class to ensure compatibility with the original C++ Caffe code.
CDirectBitmap	The DirectBitmap class provides an efficient bitmap creating class.
CGenericList	The GenericList provides a base used to implement a generic list by only implementing the minimum amount of the list functionality.
CIBinaryPersist	The IBinaryPersist interface provides generic save and load functionality.
CImageData	The ImageData class is a helper class used to convert between Datum, other raw data, and Images such as a Bitmap.
CImageTools	The ImageTools class is a helper class used to manipulate image data.
CITestKnownFailures	Defines the ITest interface used by the Test module to return its known failures.
CIXDatabaseBase	The IXDatabaseBase interface defines the general interface to the in-memory database.
CIXImageDatabase1	The IXImageDatabase interface defines the eneral interface to the in-memory image database.
CIXImageDatabase2	The IXImageDatabase2 interface defines the general interface to the in-memory image database (v2).
CIXImageDatabaseBase	The IXImageDatabaseBase interface defines the general interface to the in-memory image database.
CIXTemporalDatabaseBase	Teh IXTemporalDatabaseBase interface defines the general interface to the in-memory temporal database.
CLabelBBox	The LabelBBox manages a bounding box used in SSD.
CLabelMapping	The LabelMapping class represents a single label mapping.
CLabelMappingCollection	The LabelMappingCollection manages a collection of LabelMapping's.
CLockBitmap	The LockBitmap class provides very efficient SetPixel and GetPixel functionality of a bitmap by using LockBits to directly access the bitmap data.
CLog	The Log class provides general output in text form.
CLogArg	The LogArg is passed as an argument to the Log::OnWriteLine event.
CLogProgressArg	The LogProgressArg is passed as an argument to the Log::OnProgress event.
CLossArgs	The LossArgs contains the loss values for a given batch.
CMyCaffeModelData	The MyCaffeModelData object contains the model descriptor, model weights and optionally the image mean.
CNormalizedBBox	The NormalizedBBox manages a bounding box used in SSD.
COverrideProjectArgs	The OverrideProjectArgs is passed as an argument to the OnOverrideModel and OnOverrideSolver events fired by the ProjectEx class.
CProjectEx	The ProjectEx class manages a project containing the solver description, model description, data set (with training data source and testing data source) and project results.
CPropertySet	Specifies a key-value pair of properties.
CRawProto	The RawProto class is used to parse and output Google prototxt file data.
CRawProtoCollection	The RawProtoCollection class is a list of RawProto objects.
CRawProtoFile	The RawProtoFile class writes and reads prototxt to and from a file.
CResult	The Result class contains a single result.
CSettingsCaffe	The SettingsCaffe defines the settings used by the MyCaffe CaffeControl.
CSimpleDatum	The SimpleDatum class holds a data input within host memory.
CSimpleDatumCollection	The SimpleDatumCollection holds a named array of SimpleDatums
CSimpleDictionary	The SimpleDictionary is a dictionary used to store a set of key/value pairs, primarily as the DICTIONARY Data Criteria type.
CSimpleResult	The SimpleResult class holds the result data stored in the RawImageResults table.
CSimpleTemporalDatum	The SimpleTemporalDatum is used to return temporal data
CSimpleTemporalDatumCollection	The SimpleTemporalDatumCollection manages a collection of SimpleTemporalDatum objects.
CTarFile	The TarFile functions are used to expand tar files.
CUtility	The Utility class provides general utility funtions.
CValuemap	The Realmap operates similar to a bitmap but is actually just an array of doubles.
►Ncommon	The MyCaffe.common namespace contains common MyCaffe classes.
CActionStateArgs	The ActionStateArgs are sent to the DoWork event when fired from the InternalThreadEntry.
CBackwardArgs	The BackwardArgs are passed to the OnBackward event of the EventLayer.
CBatchInput	The BatchInput class stores the mini-batch index and input data.
CBBoxUtility	The BBox class processes the NormalizedBBox data used with SSD.
CBeamSearch	The BeamSearch uses the softmax output from the network and continually runs the net on each output (using the output as input) until the end of token is reached. The beam-search tree is returned.
CBlob	The Blob is the main holder of data that moves through the Layers of the Net.
CBlobCollection	The BlobCollection contains a list of Blobs.
CBlobDebugInformation	The BlobDebugInformation describes debug information relating to a given Blob in a given Layer.
CBlobName	The BlobName class is used to build unique blob names.
CBlockingQueue	The BlockingQueue is used for synchronized Queue operations.
CCache	The Cache class is used to cache blobs over time.
CComputeGraph	The ComputeGraph class provides a simple computation graph of operations used in a forward pass that are stored in an array on each call and then unwound with calls that calculate the gradients on the backward pass.
CCudaDnn	The CudaDnn object is the main interface to the Low-Level Cuda C++ DLL.
CCudaDnnMemoryTracker	The CudaDnnMemoryTracker is used for diagnostics in that it helps estimate the amount of memory that a Net will use.
CCustomForwardBackArgs	The CustomForwardBackArgs provide the arguments to the OnCustomForwardBack event within the Solver Step function.
CDebugInformation	The DebugInformation contains information used to help debug the Layers of a Net while it is training.
CForwardArgs	The ForwardArgs are passed to the OnForward event of the EventLayer.
CGetBytesArgs	The GetBytesArgs is passed along to the SnapshotArgs::OnGetWeights and SnapshotArgs::OnGetState events.
CGetConversionBlobArgs	The GetConversionBlobArgs are passed to the Layer::OnGetConversionBlobs event which fires each time a blob needs to be converted form half to base or back.
CGetIterationArgs	The GetIterationArgs is sent bubbled up to the solver when a layer needs to know the curret training iteration.
CGetWorkBlobArgs	The GetWorkBlobArgs are passed to the Layer::OnGetWorkBlob event which is supported for debugging only.
CGPUParams	The GPUParams contains the connection to the low-level Cuda, and the stream associated with this instance.
CGradientsReadyArgs	The GradientsReadyArgs is sent to the Solver::OnGradientsReady event which fires at the end of each Solver::Step.
CHostBuffer	The HostBuffer helps manage host memory, often used when implementing CPU versions of a function or layer.
CInternalThread	The InternalThread manages an internal thread used for Parallel and data collection operations.
CIXDebugData	The IXDebugData interface is implemented by the DebugLayer to give access to the debug information managed by the layer.
CIXMyCaffe	The IXMyCaffe interface contains functions used to perform MyCaffe operations that work with the MyCaffeImageDatabase.
CIXMyCaffeExtension	The IXMyCaffeExtension interface allows for easy extension management of the low-level software that interacts directly with CUDA.
CIXMyCaffeNoDb	The IXMyCaffeNoDb interface contains functions used to perform MyCaffe operations that run in a light-weight manner without the MyCaffeImageDatabase.
CIXMyCaffeState	The IXMyCaffeState interface contains functions related to the MyCaffeComponent state.
CIXPersist	The IXPersist interface is used by the CaffeControl to load and save weights.
CLayerDebugInformation	The LayerDebugInformation describes debug information relating to a given Layer in the Net.
CNCCL	The NCCL class manages the multi-GPU operations using the low-level NCCL functionality provided by the low-level Cuda Dnn DLL.
CNet	Connects Layer's together into a direct acrylic graph (DAG) specified by a NetParameter
CNumpyFile	The NumpyFile reads data from a numpy file in the base type specified.
CParams	The Params contains the base parameters used in multi-GPU training.
CPersistCaffe	The PersistCaffe class is used to load and save weight files in the .caffemodel format.
CProperty	The Property class stores both a numeric and text value.
CPropertyTree	The PropertyTree class implements a simple property tree similar to the ptree in Boost.
CResultCollection	The ResultCollection contains the result of a given CaffeControl::Run.
CSnapshotArgs	The SnapshotArgs is sent to the Solver::OnSnapshot event which fires each time the Solver::Snapshot method is called.
CSolverInfo	The SolverInfo defines the user supplied arguments passed to each Worker.
CSsdSampler	The SsdSampler is used by the SSD algorithm to sample BBoxes.
CSyncedMemory	The SyncedMemory manages the low-level connection between the GPU and host memory.
CTestArgs	The TestArgs are passed to the Solver::OnTest event.
CTestingIterationArgs	Specifies the TestingIterationArgs sent to the Solver::OnTestingIteration, which is called at the end of a testing cycle.
CTestResultArgs	The TestResultArgs are passed to the Solver::OnTestResults event.
CTrainingIterationArgs	The TrainingIterationArgs is sent to the Solver::OnTrainingIteration event that fires at the end of a training cycle.
CTransferInput	The TransferInput class is used to transfer get and set input data.
CWeightInfo	The WeightInfo class describes the weights of a given weight set including the blob names and sizes of the weights.
CWorker	The Worker manages each 'non' root sover running, where each Worker operates on a different GPU.
CWorkspaceArgs	The WorkspaceArgs are passed to both the Layer::OnSetWorkspace and Layer::OnGetWorkspace events.
►Nconverter
►Nonnx	The MyCaffe.converter.onnx namespace contains the objects used to convert to/from the MyCaffe and CAFFE model formats from/to the ONNX model format.
CMyCaffeConversionControl	The MyCaffeConversionControl handles converting between MyCaffe and ONNX formats. The OnnxControl is used to read and write ONNX files.
►Npytorch	The MyCaffe.converter.pytorch namespace contains the objects used to convert from the MyCaffe and CAFFE model formats to PyTorch *.py models.
Nlayers
CMyCaffeConversionControl	The MyCaffeConversionControl is used to convert a MyCaffe model to a PyTorch model.
►Ndata	The MyCaffe.data namespace contains dataset creators used to create common testing datasets such as MNIST, CIFAR-10 and VOC0712.
CBinaryFile	The BinaryFile class is used to manage binary files used by the MNIST dataset creator.
CCiFar10DataLoader	The CiFar10DataLoader is used to create the CIFAR-10 dataset and load it into the database managed by the MyCaffe Image Database.
CCiFar10DataParameters	Contains the dataset parameters used to create the CIFAR-10 dataset.
CCursor	The Cursor is used to traverse through a given data source within the database.
CDataTransformer	Applies common transformations to the input data, such as scaling, mirroring, subtracting the image mean...
CDB	A generic database class used to connect to the underlying database and create a Cursor that traverses through it.
CImageTransforms	The ImageTransforms class provides several useful image transformation function used with SSD.
CMnistDataLoader	The MnistDataLoader is used to create the MNIST dataset and load it into the database managed by the MyCaffe Image Database.
CMnistDataLoaderLite	The MnistDataLoader is used to extrac the MNIST dataset to disk and load the data into the training proces.
CMnistDataParameters	Contains the dataset parameters used to create the MNIST dataset.
CProgressArgs	Defines the arguments sent to the OnProgress and OnError events.
CProgressInfo	The ProgressInfo is used when reporting the overall progress of creating a dataset.
CVOCDataLoader	The VOCDataLoader is used to create the VOC0712 (VOC2007 and VOC2012) dataset and load it into the database managed by the MyCaffe Image Database.
CVOCDataParameters	Contains the dataset parameters used to create the VOC0712 dataset.
►Ndb
►Nimage	The MyCaffe.db.image namespace contains all image database related classes.
NProperties
CDatabase	The Database class manages the actual connection to the physical database using Entity Framworks from Microsoft.
CDatabaseInstanceQuery	The DatabaseInstanceQuery class is used to find all installed instances of SQL on a given machine.
CDatabaseManagement	The DatabaseManagement class is used to create the image database.
CDatasetEx	The DatasetEx class provides the in-memory dataset functionality that is used by the image database to manage data sets. Both the Testing and Training ImageSet objects are managed by the DatasetEx, which in turn coordinates the loading and usage of each.
CDatasetEx2	[V2 Image Database] The DatasetEx2 class provides the in-memory dataset functionality that is used by the image database to manage data sets. Both the Testing and Training ImageSet2 objects are managed by the DatasetEx2, which in turn coordinates the loading and usage of each.
CDatasetExCollection	The DatasetExCollection contains a list of DatasetEx objects.
CDatasetExCollection2	[V2 Image Database] The DatasetExCollection2 contains a list of DatasetEx2 objects.
CDatasetFactory	The DatasetFactory manages the connection to the Database object.
CDbItem	Specifies a database item used when querying boosted items.
CDNNConfiguration	The DNNConfiguration class used to define the connection strategy.
CDNNEntities	The DNNEntities class defines the entities used to connecto the database via Entity Frameworks.
CEntitiesConnection	The EntitiesConnection class defines how to connect to the database via Entity Frameworks.
CImageSet	The ImageSet class contains the list of image for a data source as well as a list of LabelSets that map into it.
CImageSet2	[V2 Image Database] The ImageSet2 manages the data source data including the master list of images, and the master indexes that describe the data source layout (e.g. labels, boosts, etc).
CImageSetBase	The ImageSetBase class contains the list of image for a data source as well as a list of LabelSets that map into it.
CLabelBoostDescriptor	The LabelBoostDescriptor class describes a label boost.
CLabelSet	The LabelSet 'points' into the main image list via references objects that are already created in the main image list of the ImageSet.
CMasterIndexes	The MasterIndexes stores the indexes that define the index structure of the data source data.
CMasterList	The MasterList is responsible for loading and managing access to the master list of images for a data source.
CMyCaffeImageDatabase	The MyCaffeImageDatabase provides an enhanced in-memory image database used for quick image retrieval.
CMyCaffeImageDatabase2	[V2 Image Database] The MyCaffeImageDatabase2 provides an enhanced in-memory image database used for quick image retrieval.
CParameterData	The ParameterData class is used to save and retrieve parameter data.
CQueryState	Initially the QueryState is copied from the MasterIndexes and during each query is altered by removing items already observed. Once empty, each Index within the QueryState is then refreshed with the corresponding MasterIndexes ensuring that all images are hit over time.
CQueryStateCollection	The QueryStateCollection manages all query states used by matching the QueryState handles with the QueryStates where each handle points to both the training set query state and testing set query state.
►Nstream	The MyCaffe.db.stream namespace contains all data streaming related classes.
CCustomQueryCollection	The CustomQueryCollection manages the external Custom Queries placed in the
CDataItem	The DataItem manages one synchronized data item where the first element is the sync field.
CDataItemCollection	The DataItemCollection contains the collection of synchronized data items collected from all custom queries.
CDataQuery	The DataQuery manages a custom query interface and queues data from the custom query via an internal query thread.
CDataQueryCollection	The DataQueryCollection manages all active data queries.
CIXCustomQuery	The custom query interface defines the functions implemented by each Custom Query object used to specifically query the tables of the underlying database.
CIXStreamDatabase	The IXStreamDatabase interface is the main interface to the MyCaffe Streaing Database.
CMgrQueryGeneral	The MgrQueryTime class manages the collection of data queries, and the internal data queue that contains all synchronized data items from the data queries, all fused together.
CMgrQueryTime	The MgrQueryTime class manages the collection of data queries, and the internal data queue that contains all synchronized data items from the data queries, all fused together.
CMyCaffeStreamDatabase	The MyCaffeStreamDatabase provides a streaming data input source to MyCaffe gyms used as input for dynamic, reinforcement learning.
CParamPacker	The ParamPacker is use to pack and unpack parameters sent to each custom query.
CStandardQueryTextFile	The StandardQueryTextFile provides queries that read text (*.txt) files residing in a given directory.
CStandardQueryWAVFile	The StandardQueryWAVFile provides queries that read sound frequencies from (*.WAV) files residing in a given directory.
CWaveFormat	The WaveFormat structure describes the header information of a WAV file.
CWaveFormatExtensible	The WaveFormatExtensible structure describes the extended set of information of a WAV file.
CWAVProcessor	The WAVProcessor is used to process WAV files and perform tasks such as downsampling.
CWAVReader	The WAVReader is an extension of the BinaryReader and is used to read WAV files.
CWAVWriter	The WAVWriter is a special BinaryWriter used to write WAV files.
►Ntemporal	The MyCaffe.db.temporal namespace contains all classes used to create the MyCaffeTemporalDatabase in-memory database.
CDatabaseLoader	The DatasetLoader is used to load descriptors from the database.
CDatabaseTemporal	The DatabaseTemporal is used to manage all temporal specific database objects.
CDataSet	The DataSet class loads the training and testing data.
CDatasetCollection	The DatasetCollection manages a set of datasets.
CDNNEntitiesTemporal	The DNNEntities class defines the entities used to connecto the database via Entity Frameworks.
CEntitiesConnectionTemporal	The EntitiesConnection class defines how to connect to the database via Entity Frameworks.
CItemSet	The ItemSet manages the data for a single item (e.g., customer, station, stock symbol, etc.) and its associated streams.
CMyCaffeTemporalDatabase	[Temporal Database] The MyCaffeTemporalDatabase provides an enhanced in-memory temporal database used for quick temporal data retrieval.
CRawValueData	The RawValueData class contains a single raw value item.
CRawValueDataCollection	The RawValueDataCollection class is used to hold a collection of RawValueData items.
CRawValueSet	The RawValueData class is used to hold the data values for an ItemID.
CTemporalSet	The TemporalSet manages a set of temporal data for a given data source.
►Nextras	The MyCaffe.extras namespace contains classes that use the MyCaffe and other namespaces to add enhanced features.
CDeepDraw	The DeepDraw class implements both deep drawing and deep dream as originally introduced by Google.
CNeuralStyleIntermediateOutputArgs	The NeuralStyleIntermediateOutputArgs contains the arguments sent to the OnIntermediateOutput event.
CNeuralStyleTransfer	The NeuralStyleTransfer object uses the GramLayer, TVLossLayer and LBFGSSolver to perform the neural style transfer algorithm.
COctaves	The Octave class defines the setting sused when images are generated.
COctavesCollection	The OctavesCollection manages a list of Octaves.
►Nfillers	The MyCaffe.fillers namespace contains all fillers including the Filler class.
CBilinearFiller	Fills a Blob with coefficients for bilinear interpolation.
CConstantFiller	Fills a Blob with constant values x = c.
CFiller	Abstract Filler class used to fill blobs with values.
CGaussianFiller	Fills a Blob with Gaussian-distributed values .
CMsraFiller	Fills a Blob with values where is set inversely proportionla to number of incomming nodes, outgoing nodes, or their average.
CPositiveUnitballFiller	Fills a Blob with values such that .
CSequenceFiller	Fills a Blob with a sequence of values x0 = c; x1 = c + 0.01...
CUniformFiller	Fills a Blob with uniformly distributed values
CXavierFiller	Fills a Blob with values where is set inversely proportional to number of incoming nodes, outgoing nodes, or their average.
►Ngym	The MyCaffe.gym namespace contains all classes related to the Gym's supported by MyCaffe.
NProperties
►Npython
CCurrentState	The State contains the current state of the gym.
CMyCaffePythonGym	The MyCaffePythonGym class provides a simple interface that can easily be used from within Python.
CAtariGym	The Atari Gym provides acess to the Atari-2600 Emulator from Stella (https://github.com/stella-emu/stella) via a slightly modified version of the Arcade-Learning-Envrionment (ALE) from mgbellemare (https://github.com/mgbellemare/Arcade-Learning-Environment).
CCartPoleGym	The CartPole Gym provides a simulation of a cart with a balancing pole standing on top of it.
CCurveGym	The Curve Gym provides a simulation of continuous curve such as Sin or Cos.
CDataGeneralGym	The DataGeneral Gym provides access to the MyCaffe Streaming Database with GENERAL query types.
CDataPoint	The DataPoint contains the data used when training.
CFormActionImage	The FormActionImage displays the action image (if one exists)
CFormGym	The FormGym displays the gym visualization.
CFormGyms	The FormGyms dialog displays the available gyms.
CGeomEllipse	The GeomEllipse object is used to render an ellipse.
CGeomLine	The GeomLine object is used to render a line.
CGeomObj	The GoomObj is the base class for all other gometric objects used to draw Gym objects.
CGeomPolygon	The GeomPolygon object is used to render an polygon.
CGeomPolyLine	The GeomPolyLine object is used to render an spline.
CGeomRectangle	The GeomEllipse object is used to render an rectangle.
CGeomView	The GeomView manages and renders a collection of Geometric objects.
CGymCollection	The GymCollection contains the available Gyms.
CIXMyCaffeGym	The IXMyCaffeGym interface is used to interact with each Gym.
CIXMyCaffeGymData	The IXMyCaffeGym interface is used to interact with each Gym.
CIXMyCaffeGymRange	The IXMyCaffeGymRange interface is used to query the data range for the vocabulary.
CIXMyCaffeGymUiCallback	The IXMyCaffeGymUiCallback is used to interact with the user of the IXMyCaffeGymUiService interface.
CIXMyCaffeGymUiService	The IXMYCaffeGymUiService interface provides access to the MyCaffeGymUiService used to display the visualizations of each Gym as they run.
CModelGym	The Model Gym runs a given Project over the dataset specified within the project where each step advanced to another data item within the project's dataset.
CMyCaffeGymControl	The MyCaffeGymControl displays the actual Gym visualizations.
CMyCaffeGymUiProxy	The MyCaffeGymUiProxy is used to interact with the MyCaffeGymUiService.
CMyCaffeGymUiService	The MyCaffeGymUiService provides the service used to show the Gym visualizations.
CMyCaffeGymUiServiceHost	The MyCaffeGymUiServiceHost provides the hosting service that listens for users of the user interface service.
CObservation	The Observation contains data describing the Gym as it runs.
CState	The State class defines an abstract base class for the state information and gym data.
►Nlayers	The MyCaffe.layers namespace contains all layers that have a solidified code base, including the Layer class.
►Nalpha	The MyCaffe.layers.alpha namespace contains all experimental layers that have a fluid and changing code base.
CLayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.ssd namespace.
►Nbeta	The MyCaffe.layers.beta namespace contains all beta stage layers.
►NModelData
CIterationInfo	The IterationInfo class contains information about each iteration.
COnGetDataArgs	Defines the arguments passed to the OnGetData event.
►NTextData
CIterationInfo	The IterationInfo class contains information about each iteration.
COnGetDataArgs	Defines the arguments passed to the OnGetData event.
CVocabulary	The Vocabulary object manages the overall word dictionary and word to index and index to word mappings.
CAccuracyDecodeLayer	The AccuracyDecodeLayer compares the labels output by the DecodeLayer with the expected labels output by the DataLayer. This layer is initialized with the MyCaffe.param.AccuracyParameter.
CAccuracyEncodingLayer	The AccuracyEncodingLayer computes the classification accuracy for an encoding used in a classification task that uses a Siamese Network or similar type of net that creates an encoding mapped to a label. This layer is initialized with the MyCaffe.param.AccuracyParameter.
CConvolutionOctaveLayer	The ConvolutionOctaveLayer processes high and low frequency portions of images using convolution.
CDataSequenceLayer	DataSequence Layer - this caches inputs by label and then outputs data item tuplets that include an 'anchor', optionally a 'positive' match, and at least one 'negative' match
CDecodeLayer	The DecodeLayer decodes the label of a classification for an encoding produced by a Siamese Network or similar type of net that creates an encoding mapped to a set of distances where the smallest distance indicates the label for which the encoding belongs.
CGatherLayer	The GatherLayer extracts (gathers) data from specified indices along a given axis from the input and returns it as the output. The indices are passed in as the second bottom blob.
CGlobResNormLayer	The GRNLayer performs an L2 normalization over the input data.
CInterpLayer	The InterpLayer changes the spatial resolution by bi-linear interpolation.
CKnnLayer
CLayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.ssd namespace.
CMeanErrorLossLayer	The MeanErrorLossLayer computes losses based on various different Mean Error methods as shown below. This layer is used to solve regression problems such as time-series predictions
CMergeLayer	The MergeLayer merges two bottom blobs with a specified copy pattern and outputs a single blob result.
CMishLayer	The MishLayer provides a novel activation function that tends to work better than ReLU. This layer is initialized with the MyCaffe.param.MishParameter.
CModelDataLayer	The ModelDataLayer loads data from RawImageResults table for an encoder/decoder type model.
CNormalization1Layer	The Normalization1Layer performs an L2 normalization over the input data. This layer is initialized with the MyCaffe.param.Normalization1Parameter.
CSerfLayer	The SerfLayer provides a novel activation function that tends to work better than ReLU.
CSqueezeLayer	The SqueezeLayer performs a squeeze operation where all single dimensions are removed.
CTextDataLayer	The TextDataLayer loads data from text data files for an encoder/decoder type model. This layer is initialized with the MyCaffe.param.TextDataParameter.
CTransposeLayer	The TransposeLayer performs a permute and transpose operation similar to numpy.transpose.
CTripletLossLayer	TripletLoss Layer - this is the triplet loss layer used to calculate the triplet loss and gradients using the triplet loss method of learning. The triplet loss method involves image triplets using the following format: Anchor (A), Positives (P) and Negatives (N)
CUnPoolingLayer
CUnPoolingLayer1
CUnsqueezeLayer	The UnsqueezeLayer performs an unsqueeze operation where a single dimension is inserted at each index specified.
►Ngpt	The MyCaffe.layers.gpt namespace contains all GPT related layers.
CCausalSelfAttentionLayer	The CausalSelfAttention provides a vanilla multi-head self-attention layer with projection at the end.
CCausalSelfAttentionLayer2	The CausalSelfAttention provides a vanilla multi-head self-attention layer with projection at the end.
CCustomListData	The CustomData supports external data input via an external Assembly DLL that supports the ICustomTokenInput interface.
CGeluLayer	The GeluLayer implements the New GELU activation function currently in Google BERT repo (same as OpenAI GPT)
CICustomTokenInput	The ICustomTokenInput interface specifies the interface that all custom token inputs implement.
CInputData	The InputData is an abstract class used to get training data and tokenize input data.
CIVocabulary	The IVocabulary interface specifies the interface that all Vocabularies implement.
CLayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.gpt namespace.
CLayerNormLayer	The LayerNormalizationLayer performs layer normalization similar to the PyTorch LayerNorm layer.
CMultiheadAttentionLayer	The MultiheadAttention provides a vanilla multi-head layer.
CNLLLossLayer	Computes the nll loss for a one-of-many classification task, passing real-valued predictions (from a softmax or logsoftmax) to get a probability distribution over classes.
CPositionalEncodingLayer	The PositionalEncodingLayer is a neuron layer that adds positional encoding to the input.
CTextInputData	The TextInputData manages character data read in from a text file. Data is tokenized into indexes that reference each character within the vocabulary.
CTextListData	The TextListData manages parallel lists of data where the first list contains the encoder input data and the second the decoder input/target data.
CTokenizedDataLayer	The TokenizedDataLayer loads and tokenizes data for a transformer model where data is loaded in the form: data, pos, target(optional)
CTokenizedDataPairsLayer	The TokenizedDataPairsLayer loads and tokenizes data for a transformer model where data is loaded in the form: data, pos, target(optional)
CTransformerBlockLayer	The TransformerBlock provides a generic transformer block
CVocabularyCharacter	The VocabularyCharacters class manages the data vocabulary of characters.
CVocabularySentencePiece	The VocabularySentencePieces class manages the data vocabulary of words.
CVocabularyWord	The VocabularyWords class manages the data vocabulary of words.
►Nhdf5	The MyCaffe.layers.hdf5 namespace contains all HDF5 related layers.
CHDF5	The HDF5 object provides HDF5 dataset support to the HDF5DataLayer.
CHDF5DataLayer	The HDF5DataLayer loads data from files in the HDF5 data format. This layer is initialized with the MyCaffe.param.HDF5DataParameter.
CIHDF5Load	The HDF5Load interface is used to load weights into objects like a Net.
CLayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.ssd namespace.
►Nlnn	The MyCaffe.layers.lnn namespace contains all Liquid Neural Network (LNN) related layers.
CCfcLayer	The CfcLayer implements the Closed form Continuous layer.
CCfcUnitLayer	The CfcUnitLayer implements the Closed form Continuous Cell (CfcCell) layer.
CLayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.tft namespace.
CLeCunLayer	The LeCunLayer performs the LeCun's Tanh function
CLnnUnitLayer	The LnnUnitLayer implements the base class to the Cfc and Ltc Unit layers.
CLtcUnitLayer	The LtcUnitLayer implements the liquid time constant with ODE solver (LTCCell) layer.
CSiLULayer	The SiLULayer implements the Sigmoid-weighted Linear Unit (SiLU) activation function
CSoftPlusLayer	The SoftPlusLayer implements the Softplus function, a smooth approximation of the ReLU function
►Nnt	The MyCaffe.layers.nt namespace contains all Neural Transfer related layers.
CEventLayer	The EventLayer provides an event that fires on the forward pass and another that fires on the backward pass.
CGramLayer	The GramLayer computes the Gram matrix used in Neural Style.
CLayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.ssd namespace.
COneHotLayer	The OneHotLayer is a layer for converting real values into a one-hot vector where a 1 is placed within the bucketized range for which the input value falls.
CScalarLayer	The ScalarLayer computes the operation with the value on the input.
CTVLossLayer	The TVLossLayer computes total variation loss as described by 'Mahendran' et al., and used in Neural Style.
►Nssd	The MyCaffe.layers.ssd namespace contains all Single-Shot MultiBox (SSD) related layers.
CAnnotatedDataLayer	The AnnotatedDataLayer provides annotated data to the Net by assigning top Blobs directly. This layer is initialized with the MyCaffe.param.AnnotatedDataParameter.
CDetectionEvaluateLayer	The DetectionEvaluateLayer generates the detection evaluation based on the DetectionOutputLayer and ground truth bounding box labels.
CDetectionOutputLayer	The DetectionOutputLayer generates the detection output based on location and confidence predictions by doing non maximum supression. Intended for use with MultiBox detection method used in SSD.
CLayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.ssd namespace.
CMultiBoxLossLayer	The MultiBoxLossLayer performs multibox operations including the following:
CNormalization2Layer	The Normalization2Layer performs normalization used by the SSD algorithm. This layer is initialized with the MyCaffe.param.Normalization2Parameter.
CPermuteLayer	The PermuteLayer performs permutation on the input blob by changing the memory order of the data which is used by the SSD algorithm. This layer is initialized with the MyCaffe.param.PermuteParameter.
CPriorBoxLayer	The PriorBoxLayer generates prior boxes of designated sizes and aspect ratios across all dimensions of which is used by the SSD algorithm. This layer is initialized with the MyCaffe.param.ssd.PriorBoxParameter.
CSmoothL1LossLayer	Fast R-CNN Copyright (c) Microsoft Licensed under The MIT License [see fast-rcnn/LICENSE for details] Originally written in C by Ross Girshick Modified by Wei Liu in C Rewritten in C# by SignalPop LLC
CVideoDataLayer	The VideoDataLayer provides data to the Net from a WebCam or Video file. This layer is initialized with the MyCaffe.param.VideoDataParameter.
►Ntft	The MyCaffe.layers.tft namespace contains all TFT related layers.
CCategoricalTransformationLayer	The CategoricalTransformationLayer implements the transforming/embeddings for the set of categorical input variables from a single input channel. Each input variable is projected using a dedicated embedding layer to a vector of width state_size. The result of applying this module is a list, with length num_inputs, that contians the embedding of each input variable for all observations and time steps.
CChannelEmbeddingLayer	The ChannelEmbeddingLayer implements the transforming/embeddings for both the numeric and categorical data of an input channel. This layer manages both a NumericTransformationLayer and CategoricalTransformationLayer
CDataSchema	The DataSchema class is used by the DataTemporalLayer to load the data schema describing the NPY files containing the dataset.
CDataTemporalLayer	The DataTemporalLayer implements the data layer used to load the temporal data into the model.
CField	The Field class manages a single field.
CFieldCollection	The FieldCollection manages a collection of fields.
CGateAddNormLayer	The GateAddNormLayer implements the Dropout, Gated Linear Unit layer, LayerNorm while adding in the residual.
CGluLayer	The GluLayer implements the Gated Linear Unit layer.
CGrnLayer	The GrnLayer implements the Gated Linear Unit layer.
CLayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.tft namespace.
CLookup	The Lookup class is used to manage a single lookup table.
CLookupCollection	The LookupCollection class contains a collection of Lookup objects.
CLookupItem	The lookup item manages a single lookup item used to map a name to an ID.
CMultiHeadAttentionInterpLayer	The MultiHeadAttentionInterpLayer implements the Multi-head Attention Interpretive Layer
CNumericTransformationLayer	The NumericTransformationLayer implements the transforming/embeddings for the set of numeric input variables from a single input channel. Each input variable is projected using a dedicated inner product layer to a vector of width state_size. The result of applying this module is a list, with length num_inputs, that contians the embedding of each input variable for all observations and time steps.
CQuantileAccuracyLayer	The QuantileAccuracyLayer implements the Quantile Accuracy Layer used in TFT models.
CRawData	The RawData class is the base class for all raw data types.
CRawFileData	The RawFileData object is used to load raw NPY file data.
CRawSqlData	The RawSqlData class loads data from a database.
CReshapeTemporalLayer	The ReshapeTemporalLayer implements the Variable Selection Network
CVarSetNetLayer	The VarSetNetLayer implements the Variable Selection Network
CAbsValLayer	The AbsValLayer computes the absolute value of the input.
CAccuracyLayer	The AccuracyLayer computes the classification accuracy for a one-of-many classification task. This layer is initialized with the MyCaffe.param.AccuracyParameter.
CArgMaxLayer	The ArgMaxLayer computes the index of the K max values for each datum across all dimensions . This layer is initialized with the MyCaffe.param.ArgMaxParameter.
CAttentionLayer	[DEPRECIATED] The AttentionLayer provides focus for LSTM based encoder/decoder models.
CBaseConvolutionLayer	The BaseConvolutionLayer is an abstract base class that factors out BLAS code common to ConvolutionLayer and DeconvolutionLayer
CBaseDataLayer	The BaseDataLayer is the base class for data Layers that feed Blobs of data into the Net.
CBasePrefetchingDataLayer	The BasePrefetchingDataLayer is the base class for data Layers that pre-fetch data before feeding the Blobs of data into the Net.
CBatch	The Batch contains both the data and label Blobs of the batch.
CBatchNormLayer	The BatchNormLayer normalizes the input to have 0-mean and/or unit (1) variance across the batch. This layer is initialized with the BatchNormParameter.
CBatchReindexLayer	The BatchReindexLayer provides an index into the input blob along its first axis.
CBiasLayer	The BiasLayer 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. This layer is initialized with the MyCaffe.param.BiasParameter.
CBNLLLayer	The Binomial Normal Log Liklihod Layer.
CClipLayer	The ClipLayer provides a neuron layer that clips the data to fit within the [min,max] range. This layer is initialized with the MyCaffe.param.ClipParameter.
CConcatLayer	The ConcatLayer takes at least two Blobs and concatentates them along either the num or channel dimension, outputing the result. This layer is initialized with the MyCaffe.param.ConcatParameter.
CConstantLayer	The ConstantLayer provides a layer that just outputs a constant value. This layer is initialized with the MyCaffe.param.ConstantParameter.
CContrastiveLossLayer	The ContrastiveLossLayer computes the contrastive loss where . This layer is initialized with the MyCaffe.param.ContrastiveLossParameter.
CConvolutionLayer	The ConvolutionLayer convolves the input image with a bank of learned filters, and (optionally) adds biases. This layer is initialized with the MyCaffe.param.ConvolutionParameter.
CCopyLayer	The CopyLayer copies the src bottom to the dst bottom. The layer has no output.
CCropLayer	The CropLayer takes a Blob and crops it to the shape specified by the second input Blob, across all dimensions after the specified axis
CDataLayer	The DataLayer loads data from the IXImageDatabase database. This layer is initialized with the MyCaffe.param.DataParameter.
CDataNormalizerLayer	The DataNormalizerLayer normalizes the input data (and optionally label) based on the normalization operations specified in the layer parameter.
CDebugLayer	The DebugLayer merely stores, up to max_stored_batches, batches of input which are then optionally used by various debug visualizers. This layer is initialized with the MyCaffe.param.DebugParameter.
CDeconvolutionLayer	The DeconvolutionLayer convolves the input with a bank of learned filtered, and (optionally) add biases, treating filters and convolution parameters in the opposite sense as ConvolutionLayer. This layer is initialized with the MyCaffe.param.ConvolutionParameter
CDropoutLayer	During training only, sets a random portion of to 0, adjusting the rest of the vector magnitude accordingly This layer is initialized with the MyCaffe.param.DropoutParameter.
CDummyDataLayer	The DummyDataLayer provides data to the Net generated by a Filler. This layer is initialized with the MyCaffe.param.DummyDataParameter.
CEltwiseLayer	The EltwiseLayer computes elementwise oeprations, such as product and sum, along multiple input blobs. This layer is initialized with the MyCaffe.param.EltwiseParameter.
CELULayer	The ELULayer computes exponential linear unit non-linearity . This layer is initialized with the MyCaffe.param.EluParameter.
CEmbedLayer	The EmbedLayer is a layer for learning 'embeddings' of one-hot vector input. This layer is initialized with the MyCaffe.param.EmbedParameter.
CEuclideanLossLayer	The EuclideanLossLayer computes the Euclidean (L2) loss for real-valued regression tasks.
CExpLayer	The ExpLayer which computes the exponential of the input. This layer is initialized with the MyCaffe.param.ExpParameter.
CFilterLayer	The FilterLayer takes two+ Blobs, interprets last Blob as a selector and filters 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).
CFlattenLayer	The FlattenLayer reshapes the input Blob into flat vectors This layer is initialized with the MyCaffe.param.FlattenParameter.
CGradientScaleLayer	The GradientScaleLayer which scales the deltas during the backpropagation. This layer is initialized with the MyCaffe.param.GradientScaleParameter.
CHingeLossLayer	The HingeLossLayer computes the hinge loss for a one-of-many classification task. This layer is initialized with the MyCaffe.param.HingeLossParameter.
CIm2colLayer	The Im2ColLayer is a helper layer for image operations that rearranges image regions into column vectors.
CImageDataLayer	The ImageDataLayer loads data from the image files located in the root directory specified. This layer is initialized with the MyCaffe.param.ImageDataParameter.
CInfogainLossLayer	The InforgainLossLayer is a generalization of SoftmaxWithLossLayer that takes an 'information gain' (infogain) matrix specifying the 'value of all label pairs. This layer is initialized with the MyCaffe.param.InfogainLossParameter.
CInnerProductLayer	The InnerProductLayer, also know as a 'fully-connected' layer, computes the inner product with a set of learned weights, and (optionally) adds biases. This layer is initialized with the MyCaffe.param.InnerProductParameter.
CInputLayer	The InputLayer provides data to the Net by assigning top Blobs directly. This layer is initialized with the MyCaffe.param.InputParameter.
CLabelMappingLayer	/b DEPRECIATED (use DataLayer DataLabelMappingParameter instead) The LabelMappingLayer converts original labels to new labels specified by the label mapping. This layer is initialized with the MyCaffe.param.LabelMappingParameter.
CLastBatchLoadedArgs	Specifies the arguments sent to the OnBatchLoad event used when synchronizing between Data Layers.
CLayer	An interface for the units of computation which can be composed into a Net.
CLayerParameterEx	The LayerParameterEx class is used when sharing another Net to conserve GPU memory and extends the LayerParameter with shared Blobs for this purpose.
CLogLayer	The LogLayer computes the log of the input. This layer is initialized with the MyCaffe.param.LogParameter.
CLossLayer	The LossLayer provides an interface for Layer's that take two blobs as input – usually (1) predictions and (2) ground-truth labels – and output a singleton blob representing the loss. This layer is initialized with the MyCaffe.param.LossParameter.
CLRNLayer	The "Local Response Normalization" LRNLayer is used to normalize the input in a local region across or within feature maps. This layer is initialized with the MyCaffe.param.LRNParameter.
CLSTMAttentionLayer	The LSTMAttentionLayer adds attention to the long-short term memory layer and is used in encoder/decoder models. To use attention, just set 'enable_attention'=true. When disabled, this layer operates like a standard LSTM layer where inputs are in the shape T,B,I with T=timesteps, B=batch and I=input
CLSTMLayer	The LSTMLayer processes sequential inputs using a 'Long Short-Term Memory' (LSTM) [1] style recurrent neural network (RNN). Implemented by unrolling the LSTM computation through time. This layer is initialized with the MyCaffe.param.RecurrentParameter.
CLSTMSimpleLayer	[DEPRECIATED - use LSTMAttentionLayer instead with enable_attention = false] The LSTMSimpleLayer is a simpe version of the long-short term memory layer. This layer is initialized with the MyCaffe.param.LSTMSimpleParameter.
CLSTMUnitLayer	The LSTMUnitLayer is a helper for LSTMLayer that computes a single timestep of the non-linearity of the LSTM, producing the updated cell and hidden states.
CMathLayer	The MathLayer which computes various mathematical functions of the input. This layer is initialized with the MyCaffe.param.MathParameter.
CMemoryDataLayer	The MemoryDataLayer provides data to the Net from memory. This layer is initialized with the MyCaffe.param.MemoryDataParameter.
CMemoryDataLayerGetDataArgs	The MemoryDataLayerGetDataArgs class is passed to the OnGetData event.
CMemoryDataLayerPackDataArgs	The MemoryDataLayerPackDataArgs is passed to the OnDataPack event which fires each time the data received in AddDatumVector needs to be packed into a specific ordering as is the case when using an LSTM network.
CMemoryLossLayer	The MemoryLossLayer provides a method of performing a custom loss functionality. Similar to the MemoryDataLayer, the MemoryLossLayer supports an event used to get the loss value. This event is called OnGetLoss, which once retrieved is used for learning on the backward pass.
CMemoryLossLayerGetLossArgs	The MemoryLossLayerGetLossArgs class is passed to the OnGetLoss event.
CMultinomialLogisticLossLayer	The MultinomialLogicistLossLayer computes the multinomial logistc loss for a one-of-many classification task, directly taking a predicted probability distribution as input.
CMVNLayer	The "Mean-Variance Normalization" MVNLayer normalizes the input to have 0-mean and/or unit (1) variance. This layer is initialized with the MyCaffe.param.MVNParameter.
CNeuronLayer	The NeuronLayer is an interface for layers that take one blob as input (x) and produce only equally-sized blob as output (y), where each element of the output depends only on the corresponding input element.
CParameterLayer	The ParameterLayer passes its blob[0] data and diff to the top[0].
CPoolingLayer	The PoolingLayer pools the input image by taking the max, average, etc. within regions. This layer is initialized with the MyCaffe.param.PoolingParameter.
CPowerLayer	The PowerLayer computes the power of the input. This layer is initialized with the MyCaffe.param.PowerParameter.
CPReLULayer	The PReLULayer computes the "Parameterized Rectified Linear Unit" non-linearity. This layer is initialized with the MyCaffe.param.PReLUParameter.
CQuantileLossLayer	The QuantileLossLayer computes the quantile loss for real-valued regression tasks.
CRecurrentLayer	The RecurrentLayer is an abstract class for implementing recurrent behavior inside of an unrolled newtork. This layer type cannot be instantiated – instead, you should use one of teh implementations which defines the recurrent architecture, such as RNNLayer or LSTMLayer. This layer is initialized with the MyCaffe.param.RecurrentParameter.
CReductionLayer	The ReductionLayer computes the '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. This layer is initialized with the MyCaffe.param.ReductionParameter.
CReLULayer	The ReLULayer computes the "Rectifier Linear Unit" ReLULayer non-linearity, a classic for neural networks. This layer is initialized with the MyCaffe.param.ReLUParameter.
CReshapeLayer	The ReshapeLayer reshapes the input Blob into an arbitrary-sized output Blob. This layer is initialized with the MyCaffe.param.ReshapeParameter.
CRNNLayer	The RNNLayer processes time-varying inputs using a simple recurrent neural network (RNN). Implemented as a network unrolling the RNN computation in time. This layer is initialized with the MyCaffe.param.RecurrentParameter.
CScaleLayer	The ScaleLayer 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 later Blob, then computing the elementwise product. Note: for efficiency and convienience this layer can additionally perform a 'broadcast' sum too when 'bias_term: true' This layer is initialized with the MyCaffe.param.ScaleParameter. is set.
CSigmoidCrossEntropyLossLayer	The SigmoidCrossEntropyLayer computes the cross-entropy (logisitic) loss and is often used for predicting targets interpreted as probabilities.
CSigmoidLayer	The SigmoidLayer is a neuron layer that calculates the sigmoid function, a classc choice for neural networks. This layer is initialized with the MyCaffe.param.SigmoidParameter.
CSilenceLayer	The SilenceLayer ignores bottom blobs while producing no top blobs. (This is useuful to suppress output during testing.)
CSliceLayer	The SliceLayer takes a blob and slices it along either the num or channel dimensions outputting multiple sliced blob results. This layer is initialized with the MyCaffe.param.SliceParameter.
CSoftmaxCrossEntropy2LossLayer	The SoftmaxCrossEntropy2Layer computes the cross-entropy (logisitic) loss and is often used for predicting targets interpreted as probabilities.
CSoftmaxCrossEntropyLossLayer	The SoftmaxCrossEntropyLossLayer computes the cross-entropy (logisitic) loss and is often used for predicting targets interpreted as probabilities in reinforcement learning.
CSoftmaxLayer	The SoftmaxLayer computes the softmax function. This layer is initialized with the MyCaffe.param.SoftmaxParameter.
CSoftmaxLossLayer	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.
CSplitLayer	The SplitLayer creates a 'split' path in the network by copying the bottom blob into multiple top blob's to be used by multiple consuming layers.
CSPPLayer	The SPPLayer 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. This layer is initialized with the MyCaffe.param.SPPParameter.
CSwishLayer	The SwishLayer provides a novel activation function that tends to work better than ReLU. This layer is initialized with the MyCaffe.param.SwishParameter.
CTanhLayer	The TanhLayer is a neuron layer that calculates the tanh function, popular with auto-encoders. This layer is initialized with the MyCaffe.param.TanhParameter.
CThresholdLayer	The ThresholdLayer is a neuron layer that tests whether the input exceeds a threshold: outputs 1 for inputs above threshold; 0 otherwise. This layer is initialized with the MyCaffe.param.ThresholdParameter.
CTileLayer	The TileLayer copies a Blob along specified dimensions. This layer is initialized with the MyCaffe.param.TileParameter.
►Nmodel	The MyCaffe.model namespace contains all classes used to programically create new model scripts.
CModelBuilder	The ModelBuilder is an abstract class that is overridden by a base class used to programically build new models.
CMultiBoxHeadInfo	The MultiBoxHeadInfo contains information used to build the multi-box head of layers.
CResNetModelBuilder	The ResNetModelBuilder adds the extra layers to a 'base' model for the ResNet model.
CResNetOctConvModelBuilder	The ResNetOctConvModelBuilder is used to build Octave Convolution based RESNET models.
CSsdPascalModelBuilder	The SsdPascalModelBuilder adds the extra layers to a 'base' model for the Pascal model used with SSD.
►Nparam	The MyCaffe.param namespace contains parameters used to create models.
►Nbeta	The MyCaffe.param.beta parameters are used by the MyCaffe.layer.beta layers.
CDataSequenceParameter	Specifies the parameters for the DataSequenceLayer.
CDecodeParameter	Specifies the parameters for the DecodeLayer and the AccuracyEncodingLayer.
CGatherParameter	Specifies the parameters for the GatherLayer.
CKnnParameter	Specifies the parameters for the KnnLayer.
CMergeParameter	Specifies the parameters for the MergeLayer.
CMishParameter	Stores the parameters used by the MishLayer
CNormalization1Parameter	Specifies the parameters for the Normalization1Layer.
CSerfParameter	Stores the parameters used by the SerfLayer
CSqueezeParameter	Specifies the parameters for the SqueezeLayer.
CTransposeParameter	Specifies the parameters for the TransposeLayer.
CTripletLossParameter	Specifies the parameters for the TripletLossLayer.
CUnPoolingParameter	Specifies the parameters for the UnPoolingLayer.
►Ngpt
CCausalSelfAttentionParameter	Specifies the parameters for the CausalSelfAttentionLayer.
CGeluParameter	Specifies the parameters for the GeluLayer.
CLayerNormParameter	Specifies the parameters for the LayerNormalizationLayer.
CMultiheadAttentionParameter	Specifies the parameters for the MultiheadAttentionLayer.
CNLLLossParameter	Specifies the parameters for the NLLLossLayer.
CPositionalEncoderParameter	Specifies the parameters for the PositionalEncoderLayer.
CTokenizedDataPairsParameter	Specifies the parameters for the TokenizedDataPairsLayer.
CTokenizedDataParameter	Specifies the parameters for the TokenizedDataLayer.
CTransformerBlockParameter	Specifies the parameters for the TransformerBlockLayer.
►Nlnn
CCfcParameter	Specifies the parameters used by the CfcLayer. Note, you must also fill out the CfcUnitParameter.
CCfcUnitParameter	Specifies the parameters for the CfcUnitLayer used by the CfCLayer.
CLtcUnitParameter	Specifies the parameters for the LtcUnitLayer used by the CfCLayer.
►Nnt	The MyCaffe.param.nt namespace defines the parameters used by the Nerual Style Transfer layers.
CGramParameter	Specifies the parameters for the GramLayer
COneHotParameter	Specifies the parameters used by the OneHotLayer
CScalarParameter	Specifies the parameters for the ScalarLayer
CTVLossParameter	Specifies the parameters for the TVLossLayer
►Npython
CPythonParameter	Specifies the parameters for the PythonLayer.
►Nssd	The MyCaffe.param.ssd namespace contains all SSD related parameter objects that correspond to the native C++ Caffe prototxt file.
CAnnotatedDataParameter	Specifies the parameters for the InputLayer.
CBatchSampler	Specifies a sample of batch of bboxes with provided constraints in SSD.
CDetectionEvaluateParameter	Specifies the parameters for the DetectionEvaluateLayer.
CDetectionOutputParameter	Specifies the parameters for the DetectionOutputLayer.
CDistortionParameter	Specifies the parameters for the DistortionParameter used with SSD.
CEmitConstraint	Specifies the parameters for the EmitConstraint used with SSD.
CExpansionParameter	Specifies the parameters for the ExpansionParameter used with SSD.
CLabelMap	Specifies the LabelMap used with SSD.
CLabelMapItem	The LabelMapItem class stores the information for a single label.
CMultiBoxLossParameter	Specifies the parameters for the MultiBoxLossParameter.
CNoiseParameter	Specifies the parameters for the NoiseParameter used with SSD.
CNonMaximumSuppressionParameter	Specifies the parameters for the NonMaximumSuppressionParameter used with SSD.
CNormalization2Parameter	Specifies the parameters for the Normalization2Layer used in SSD.
CPermuteParameter	Specifies the parameters for the PermuteLayer.
CPriorBoxParameter	Specifies the parameters for the PriorBoxParameter.
CResizeParameter	Specifies the parameters for the ResizeParameter for use with SSD.
CSaltPepperParameter	Specifies the parameters for the SaltPepperParameter used with SSD.
CSampler	Specifies the sample of a bbox in the normalized space [0,1] with provided constraints used in SSD.
CSamplerConstraint	Specifies the constratins for selecting sampled bbox used in SSD.
CSaveOutputParameter	Specifies the parameters for the SaveOutputLayer.
CVideoDataParameter	Specifies the parameters for the VideoDataLayer.
►Ntft
CCategoricalTransformationParameter	Specifies the parameters for the NumericInputTransformationLayer.
CDataTemporalParameter	Specifies the parameters for the DataTemporalLayer (used in TFT models).
CGateAddNormParameter	Specifies the parameters for the GetAddNormLayer (Gate Add Norm).
CGluParameter	Specifies the parameters for the GluLayer (Gated Linear Unit).
CGrnParameter	Specifies the parameters for the GrnLayer (Gated Response Network).
CMultiHeadAttentionInterpParameter	Specifies the parameters for the MultiHeadAttentionInterpLayer (Interpretable Multi-Head Attention Layer).
CNumericTransformationParameter	Specifies the parameters for the NumericInputTransformationLayer.
CQuantileAccuracyParameter	Specifies the parameters for the QuantileAccuracyLayer used in TFT models
CQuantileLossParameter	Specifies the parameters for the QuantileLossLayer used in TFT models
CReshapeTemporalParameter	Specifies the parameters for the ReshapeTemporalLayer.
CVarSelNetParameter	Specifies the parameters for the VarSelNetLayer (Variable Selection Network).
►Nui
CCsvConverter	The CsvConverter is used to display string lists on a single line in a property grid.
CDictionaryParamEditor	The DictionaryParamEditor is used to visually edit dictionary based parameters that are stored as a key/value set packed within a string.
CFormProperty	The FormProperty window is used to edit a given key/value pair.
CAccuracyParameter	Specifies the parameters for the AccuracyLayer.
CArgMaxParameter	Specifies the parameters for the ArgMaxLayer
CAttentionParameter	[/b DEPRECIATED, use MultiHeadAttention layers instead.] Specifies the parameters for the AttentionLayer.
CBatchNormParameter	Specifies the parameters for the BatchNormLayer.
CBiasParameter	Specifies the parameters for the BiasLayer
CBlobProto	The BlobProto contains the descripion of a blob.
CBlobProtoCollection	Specifies a collection of BlobProtos.
CBlobShape	Specifies the shape of a Blob.
CClipParameter	Stores the parameters used by the ClipLayer
CConcatParameter	Specifies the parameters for the ConcatLayer
CConstantParameter	Specifies the parameters for the ConstantLayer.
CContrastiveLossParameter	Specifies the parameters for the ContrastiveLossLayer.
CConvolutionOctaveParameter	Specifies the parameters for the ConvolutionOctaveLayer.
CConvolutionParameter	Specifies the parameters for the ConvolutionLayer. The default weight filler is set to the XavierFiller, and the default bias filler is set to ConstantFiller with a value of 0.1.
CCropParameter	Specifies the parameters for the MyCaffe.CropLayer.
CDataDebugParameter	The DataDebugParameter is used by the DataParameter when the 'enable_debugging' = True.
CDataLabelMappingParameter	Specifies the parameters for the DataLabelMappingParameter used to map labels by the DataTransformer.TransformLabel when active.
CDataNoiseParameter	The DataNoiseParameter is used by the DataParameter when the 'enable_noise_for_nonmatch' = True, which is used when 'images_per_blob' > 1.
CDataNormalizerParameter	Specifies the parameter for the data normalizer layer.
CDataParameter	Specifies the parameter for the data layer.
CDebugParameter	Specifies the parameters used by the DebugLayer
CDropoutParameter	Specifies the parameters of the DropoutLayer.
CDummyDataParameter	This layer produces N >= 1 top blobs. DummyDataParameter must specify 1 or shape fields, and 0, 1 or N data fillers. This layer is initialized with the ReLUParameter.
CEltwiseParameter	Specifies the parameters for the EltwiseLayer.
CEluParameter	Specifies the parameters for the EluLayer.
CEmbedParameter	Specifies the parameters used by the EmbedLayer.
CEngineParameter	Specifies whether to use the NVIDIA cuDnn version or Caffe version of a given forward/backward operation.
CExpParameter	Specifies the parameters for the ExpLayer.
CFillerParameter	Specifies the filler parameters used to create each Filler.
CFlattenParameter	Specifies the parameters for the FlattenLayer.
CGradientScaleParameter	Specifies the parameters for the GradientScaleLayer.
CHDF5DataParameter	Specifies the parameter for the HDF5 data layer.
CHingeLossParameter	Specifies the parameters for the HingLossLayer.
CImageDataParameter	Specifies the parameters for the ImageDataLayer
CInfogainLossParameter	Specifies the parameters for the InfogainLossLayer.
CInnerProductParameter	Specifies the parameters for the InnerProductLayer.
CInputParameter	Specifies the parameters for the InputLayer.
CInterpParameter	Specifies the parameters for the InterpLayer.
CKernelParameter	Specifies the basic kernel parameters (used by convolution and pooling)
CLabelMappingParameter	/b DEPRECIATED (use DataLayer DataLabelMappingParameter instead) Specifies the parameters for the LabelMappingLayer.
CLayerParameter	Specifies the base parameter for all layers.
CLayerParameterBase	The LayerParameterBase is the base class for all other layer specific parameters.
CLogParameter	Specifies the parameters for the LogLayer.
CLossParameter	Stores the parameters used by loss layers.
CLRNParameter	Specifies the parameter for the LRNLayer.
CLSTMAttentionParameter	Specifies the parameters for the LSTMAttentionLayer that provides an attention based LSTM layer used for decoding in an encoder/decoder based model.
CLSTMSimpleParameter	[DEPRECIATED - use LSTMAttentionParameter instead with enable_attention = false] Specifies the parameters for the LSTMSimpleLayer.
CMaskParameter	Specifies the parameters for the MaskParameter used to mask portions of the transformed data when active.
CMathParameter	Specifies the parameters for the MathLayer.
CMeanErrorLossParameter	Specifies the parameters for the MeanErrorLossLayerParameter.
CMemoryDataParameter	Specifies the parameters used by the MemoryDataLayer.
CModelDataParameter	Specifies the parameter for the model data layer.
CMVNParameter	Specifies the parameters for the MVNLayer.
CNetParameter	Specifies the parameters use to create a Net
CNetState	Specifies the NetState which includes the phase, level and stage for which a given Net is to run under.
CNetStateRule	Specifies a NetStateRule used to determine whether a Net falls within a given include or exclude pattern.
COptionalParameter	The OptionalParameter is the base class for parameters that are optional such as the MaskParameter, DistorationParameter, ExpansionParameter, NoiseParameter, and ResizeParameter.
CParameterParameter	Specifies the parameters for the ParameterLayer
CParamSpec	Specifies training parameters (multipliers on global learning constants, and the name of other settings used for weight sharing).
CPoolingParameter	Specifies the parameters for the PoolingLayer.
CPowerParameter	Specifies the parameters for the PowerLayer.
CPReLUParameter	Specifies the parameters for the PReLULayer.
CRecurrentParameter	Specifies the parameters used by the RecurrentLayer.
CReductionParameter	Specifies the parameters used by ReductionLayer.
CReLUParameter	Specifies the parameters for the ReLULayer
CReshapeParameter	Specifies the parameters for the ReshapeLayer.
CScaleParameter	Specifies the parameters for the ScaleLayer.
CSigmoidParameter	Specifies the parameters for the SigmoidLayer.
CSliceParameter	Specifies the parameters for the SliceLayer.
CSoftmaxParameter	Specifies the parameters for the SoftmaxLayer
CSolverParameter	The SolverParameter is a parameter for the solver, specifying the train and test networks.
CSolverState	The SolverState specifies the state of a given solver.
CSPPParameter	The SPPParameter specifies the parameters for the SPPLayer.
CSwishParameter	Stores the parameters used by the SwishLayer
CTanhParameter	Specifies the parameters for the TanhLayer
CTextDataParameter	Specifies the parameter for the Text data layer.
CThresholdParameter	Stores the parameters used by the ThresholdLayer
CTileParameter	Specifies the parameters used by the TileLayer
CTransformationParameter	Stores parameters used to apply transformation to the data layer's data.
CVerifyBatchSizeArgs	The VerifyBatchSizeArgs class defines the arguments of the OnVerifyBatchSize event.
►Npreprocessor	The MyCaffe.preprocessor namespace contains all classes of the data preprocessors supported by MyCaffe.
CExtension	The Extension class is used to add new pre-processor extension DLL's to MyCaffe.
CIXMyCaffePreprocessor	The IXPreprocessor interface is used to query pre-processed data from a streaming database.
CMgrPreprocessor	The MgrPreprocessor manages the operations of the data pre-processor.
CMyCaffeDataPreprocessor	The MyCaffeDataPreprocessor handles adding data from a streaming database to the GPU and then pre-processing the data once on the GPU making it ready for use with the Data Gym.
NProperties
►Npython	The MyCaffe.python namespace contains python related classes to help improve interop between C# and Python.
CPythonInterop	The PythonInterop uses PythonNet to execute Python code.
►Nsolvers	The MyCaffe.solvers namespace contains all solver classes, including the base Solver.
CAdaDeltaSolver	Use AdaDelta Solver which has gradient based optimization like SGD.
CAdaGradSolver	Use AdaGrad Solver based optimization like SGD that tries to find rarely seen features.
CAdamSolver	Use Adam Solver which uses gradient based optimization like SGD that includes 'adaptive momentum estimation' and can be thought of as a generalization of AdaGrad.
CAdamWSolver	Use AdamW Solver which uses gradient based optimization like Adam with a decoupled weight decay.
CLBFGSSolver	Optimizes the parameters of a Net using L-BFGS. This implementation is based on minFunc, by Marc Schmidt.
CNesterovSolver	Use Nesterov's accelerated gradient Solver, which is similar to SGD, but the error gradient is computed on the weights with added momentum.
CRmsPropSolver	Use RmsProp Solver which uses gradient based optimization like SGD.
CSGDSolver	Stochastic Gradient Descent solver with momentum updates weights by a linear combination of the negative gradient and the previous weight update.
CSolver	An interface for classes that perform optimization on Nets - this class serves as the base class for all solvers.
►Ntrainers	The MyCaffe.trainers namespace contains all reinforcement and recurrent learning trainers.
►Ncommon
CFileMemoryCollection	The FileMemoryCollection is used during debugging to load from and save to file.
CIMemoryCollection	The IMemoryCollection interface is implemented by all memory collection types.
CMemoryCollection	The memory collection stores a set of memory items.
CMemoryCollectionFactory	The MemoryCollectionFactory is used to create various memory collection types.
CMemoryItem	The MemoryItem stores the information about a given cycle.
CMinSegmentTree	The MinSegmentTree performs a reduction over the array and returns the minimum value.
CPrioritizedMemoryCollection	The PrioritizedMemoryCollection provides a sampling based on prioritizations.
CRandomMemoryCollection	The RandomMemoryCollection is used to randomly sample the collection of items.
CSegmentTree	Segment tree data structure
CSumSegmentTree	The SumSegmentTree provides a sum reduction of the items within the array.
►Ndqn
►Nc51
►Nst
CBrain	The Brain uses the instance of MyCaffe (e.g. the open project) to run new actions and train the network.
CDqnAgent	The DqnAgent both builds episodes from the envrionment and trains on them using the Brain.
CTrainerC51	The TrainerC51 implements the C51-DQN algorithm as described by Bellemare et al., Google Dopamine RainboAgent and 'flyyufelix'
►Nnoisy
►Nsimple
CBrain	The Brain uses the instance of MyCaffe (e.g. the open project) to run new actions and train the network.
CDqnAgent	The DqnAgent both builds episodes from the envrionment and trains on them using the Brain.
CTrainerNoisyDqn	The TrainerNoisyDqn implements the Noisy-DQN algorithm as described by Google Dopamine DNQAgent, Gheshlagi et al. and inspired by 'higgsfield'
►Nst
CBrain	The Brain uses the instance of MyCaffe (e.g. the open project) to run new actions and train the network.
CDqnAgent	The DqnAgent both builds episodes from the envrionment and trains on them using the Brain.
CTrainerNoisyDqn	The TrainerNoisyDqn implements the Noisy-DQN algorithm as described by Google Dopamine DQNAgent, Gheshlagi et al., and inspired by 'Kyushik' and 'higgsfield'
►Npg
►Nmt
CAgent	The Agent both builds episodes from the envrionment and trains on them using the Brain.
CBrain	The Brain uses the instance of MyCaffe (e.g. the open project) to run new actions and train the network.
CMemory	Specifies a single Memory (e.g. an episode).
CMemoryCache	Contains the best memory episodes (best by highest total rewards)
CMemoryItem	The MemoryItem stores the information for one step in an episode.
COptimizer	The Optimizer manages a single thread used to apply updates to the primary instance of MyCaffe. Once applied, the new weights are then copied back to the worker who just applied its gradients to the primary MyCaffe.
CTrainerPG	The TrainerPG implements a simple Policy Gradient trainer inspired by Andrej Karpathy's blog posed referenced.
CWorker	The Worker class provides the base class for both the Environment and Optimizer and provides the basic threading functionality used by both.
CWorkerStartArgs	The WorkerStartArgs provides the arguments used when starting the agent thread.
►Nsimple
CTrainerPG	The TrainerPG implements a simple Policy Gradient trainer inspired by Andrej Karpathy's blog posed referenced.
►Nst
CTrainerPG	The TrainerPG implements a simple Policy Gradient trainer inspired by Andrej Karpathy's blog posed referenced.
►Nrnn
►Nsimple
CTrainerRNN	The TrainerRNN implements a simple RNN trainer inspired by adepierre's GitHub site referenced.
CTrainerRNNSimple	The TrainerRNNSimple implements a very simple RNN trainer inspired by adepierre's GitHub site referenced.
CApplyUpdateArgs	The ApplyUpdateArgs is passed to the OnApplyUpdates event.
CConvertOutputArgs	The ConvertOutputArgs is passed to the OnConvertOutput event.
CGetDataArgs	The GetDataArgs is passed to the OnGetData event to retrieve data.
CGetStatusArgs	The GetStatusArgs is passed to the OnGetStatus event.
CInitializeArgs	The InitializeArgs is passed to the OnInitialize event.
CIXMyCaffeCustomTrainer	The IXMyCaffeCustomTrainer interface is used by the MyCaffeCustomTraininer components that provide various training techniques such as Reinforcement Training.
CIXMyCaffeCustomTrainerCallback	The IXMyCaffeCustomTrainerCallback interface is used to call back to the parent running the custom trainer.
CIXMyCaffeCustomTrainerCallbackRNN	The IXMyCaffeCustomTrainerCallbackRNN interface is used to call back to the parent running the custom RNN trainer.
CIXMyCaffeCustomTrainerRL	The IXMyCaffeCustomTrainer interface is used by the MyCaffeCustomTraininer components that provide various training techniques such as Reinforcement Training.
CIXMyCaffeCustomTrainerRNN	The IXMyCaffeCustomTrainer interface is used by the MyCaffeCustomTraininer components that provide various training techniques such as Reinforcement Training.
CIxTrainer	The IxTrainer interface is implemented by each Trainer.
CIxTrainerCallback	The IxTrainerCallback provides functions used by each trainer to 'call-back' to the parent for information and updates.
CIxTrainerCallbackRNN	The IxTrainerCallbackRNN provides functions used by each trainer to 'call-back' to the parent for information and updates.
CIxTrainerGetDataCallback	The IxTrainerGetDataCallback interface is called right after rendering the output image and just before sending it to the display, thus giving the implementor a chance to 'overlay' information onto the image.
CIxTrainerRL	The IxTrainerRL interface is implemented by each RL Trainer.
CIxTrainerRNN	The IxTrainerRL interface is implemented by each RL Trainer.
CMyCaffeTrainerDual	The MyCaffeTraininerDual is used to perform both reinforcement and recurrent learning training tasks on an instance of the MyCaffeControl.
CMyCaffeTrainerRL	(Depreciated - use MyCaffeTrainerDual instead.) The MyCaffeTraininerRL is used to perform reinforcement learning training tasks on an instance of the MyCaffeControl.
CMyCaffeTrainerRNN	(Depreciated - use MyCaffeTrainerDual instead.) The MyCaffeTrainerRNN is used to perform recurrent neural-network training tasks on an instance of the MyCaffeControl.
COverlayArgs	The OverlayArgs is passed ot the OnOverlay event, optionally fired just before displaying a gym image.
CStateBase	The StateBase is the base class for the state of each observation - this is defined by actual trainer that overrides the MyCaffeCustomTrainer.
CTestAccuracyUpdateArgs	The TestAccuracyUpdateArgs are passed to the OnTestAccuracyUpdate event.
CWaitArgs	The WaitArgs is passed to the OnWait event.
CILayerCreator	The ILayerCreator interface is implemented by each MyCaffe.layers.x layer extension dll and is used to create new instances of the layers supported by each layer extension dll.
CMyCaffeControl	The MyCaffeControl is the main object used to manage all training, testing and running of the MyCaffe system.
▼NPython
►NRuntime
CBooleanType	The BooleanType represents a clr bool type.
CClrFieldInfo	The ClrFieldInfo defines the clr field information.
CClrMemberInfo	The ClrMemberInfo represents clr information.
CClrPropertyInfo	The ClrPropertyInfo specifies the clr property information.
CDoubleType	The DoubleType represents a clr double type.
CFloatType	The FloatType represents a clr float type.
CInt32Type	The Int32Type represents a clr int type.
CInt64Type	The Int64Type represents a clr long type.
CObjectType	Convert between Python object and clr object
CPyClrType	The PyClrType class defines a Python clr type.
CPyClrTypeBase	The PyClrTypeBase is the base class for other types.
CPyConverter	use PyConverter to convert between python object and clr object.
CPyDictType	Specifies a PyDictionType dictionary.
CPyListType	Defines a PyListType of type 'T'
CPyPropetryAttribute	The PyPropertyAttribute represents a Python attribute.
CStringType	The StringType represents a clr string type.
▼NSystem
►NComponentModel
CComponent	The Component class is a standard Microsoft.NET class that implements the IComponent interface and is the base class for all Components. See the Windows .NET Framework for more information.