Class Hierarchy

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

[detail level 123456]

CMyCaffe.basecode.Annotation	The Annotation class is used by annotations attached to SimpleDatum's and used in SSD.
CMyCaffe.basecode.AnnotationGroup	The AnnoationGroup class manages a group of annotations.
►CAttribute
CPython.Runtime.PyPropetryAttribute	The PyPropertyAttribute represents a Python attribute.
►CMyCaffe.basecode.descriptors.BaseDescriptor	The BaseDescriptor is the base class for all other descriptors, where descriptors are used to describe various items stored within the database.
CMyCaffe.basecode.descriptors.DatasetDescriptor	The DatasetDescriptor class describes a dataset which contains both a training data source and testing data source.
CMyCaffe.basecode.descriptors.GroupDescriptor	The GroupDescriptor class defines a group.
CMyCaffe.basecode.descriptors.ProjectDescriptor	The ProjectDescriptor class contains all information describing a project, such as its: dataset, group, settings, solver description, model description, and parmeters.
CMyCaffe.basecode.descriptors.ResultDescriptor	The ResultDescriptor class describes the results of a run.
CMyCaffe.basecode.descriptors.SourceDescriptor	The SourceDescriptor class contains all information describing a data source.
CMyCaffe.basecode.descriptors.StateDescriptor	The StateDescriptor class contains the information related to the state of a project incuding the solver state and weights.
CMyCaffe.basecode.descriptors.ValueDescriptor	The ValueDescriptor class contains the description of a single value.
►CMyCaffe.basecode.BaseParameter	The BaseParameter class is the base class for all other parameter classes.
CMyCaffe.param.BlobProto	The BlobProto contains the descripion of a blob.
CMyCaffe.param.BlobShape	Specifies the shape of a Blob.
CMyCaffe.param.FillerParameter	Specifies the filler parameters used to create each Filler.
►CMyCaffe.param.LayerParameter	Specifies the base parameter for all layers.
CMyCaffe.layers.LayerParameterEx< T >	The LayerParameterEx class is used when sharing another Net to conserve GPU memory and extends the LayerParameter with shared Blobs for this purpose.
►CMyCaffe.param.LayerParameterBase	The LayerParameterBase is the base class for all other layer specific parameters.
CMyCaffe.param.AccuracyParameter	Specifies the parameters for the AccuracyLayer.
CMyCaffe.param.ArgMaxParameter	Specifies the parameters for the ArgMaxLayer
CMyCaffe.param.AttentionParameter	[/b DEPRECIATED, use MultiHeadAttention layers instead.] Specifies the parameters for the AttentionLayer.
►CMyCaffe.param.BiasParameter	Specifies the parameters for the BiasLayer
CMyCaffe.param.ScaleParameter	Specifies the parameters for the ScaleLayer.
CMyCaffe.param.ClipParameter	Stores the parameters used by the ClipLayer
CMyCaffe.param.ConcatParameter	Specifies the parameters for the ConcatLayer
CMyCaffe.param.ConstantParameter	Specifies the parameters for the ConstantLayer.
CMyCaffe.param.ContrastiveLossParameter	Specifies the parameters for the ContrastiveLossLayer.
CMyCaffe.param.ConvolutionOctaveParameter	Specifies the parameters for the ConvolutionOctaveLayer.
CMyCaffe.param.CropParameter	Specifies the parameters for the MyCaffe.CropLayer.
CMyCaffe.param.DataNormalizerParameter	Specifies the parameter for the data normalizer layer.
CMyCaffe.param.DataParameter	Specifies the parameter for the data layer.
CMyCaffe.param.DebugParameter	Specifies the parameters used by the DebugLayer
CMyCaffe.param.DummyDataParameter	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.
CMyCaffe.param.EltwiseParameter	Specifies the parameters for the EltwiseLayer.
CMyCaffe.param.EmbedParameter	Specifies the parameters used by the EmbedLayer.
►CMyCaffe.param.EngineParameter	Specifies whether to use the NVIDIA cuDnn version or Caffe version of a given forward/backward operation.
CMyCaffe.param.BatchNormParameter	Specifies the parameters for the BatchNormLayer.
CMyCaffe.param.DropoutParameter	Specifies the parameters of the DropoutLayer.
CMyCaffe.param.EluParameter	Specifies the parameters for the EluLayer.
►CMyCaffe.param.KernelParameter	Specifies the basic kernel parameters (used by convolution and pooling)
CMyCaffe.param.ConvolutionParameter	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.
►CMyCaffe.param.PoolingParameter	Specifies the parameters for the PoolingLayer.
CMyCaffe.param.beta.UnPoolingParameter	Specifies the parameters for the UnPoolingLayer.
CMyCaffe.param.LRNParameter	Specifies the parameter for the LRNLayer.
CMyCaffe.param.ReLUParameter	Specifies the parameters for the ReLULayer
CMyCaffe.param.RecurrentParameter	Specifies the parameters used by the RecurrentLayer.
CMyCaffe.param.SPPParameter	The SPPParameter specifies the parameters for the SPPLayer.
CMyCaffe.param.SigmoidParameter	Specifies the parameters for the SigmoidLayer.
CMyCaffe.param.SoftmaxParameter	Specifies the parameters for the SoftmaxLayer
CMyCaffe.param.SwishParameter	Stores the parameters used by the SwishLayer
CMyCaffe.param.TanhParameter	Specifies the parameters for the TanhLayer
CMyCaffe.param.beta.MishParameter	Stores the parameters used by the MishLayer
CMyCaffe.param.beta.SerfParameter	Stores the parameters used by the SerfLayer
CMyCaffe.param.ExpParameter	Specifies the parameters for the ExpLayer.
CMyCaffe.param.FlattenParameter	Specifies the parameters for the FlattenLayer.
CMyCaffe.param.GradientScaleParameter	Specifies the parameters for the GradientScaleLayer.
CMyCaffe.param.HDF5DataParameter	Specifies the parameter for the HDF5 data layer.
CMyCaffe.param.HingeLossParameter	Specifies the parameters for the HingLossLayer.
CMyCaffe.param.ImageDataParameter	Specifies the parameters for the ImageDataLayer
CMyCaffe.param.InfogainLossParameter	Specifies the parameters for the InfogainLossLayer.
CMyCaffe.param.InnerProductParameter	Specifies the parameters for the InnerProductLayer.
CMyCaffe.param.InputParameter	Specifies the parameters for the InputLayer.
CMyCaffe.param.InterpParameter	Specifies the parameters for the InterpLayer.
CMyCaffe.param.LSTMAttentionParameter	Specifies the parameters for the LSTMAttentionLayer that provides an attention based LSTM layer used for decoding in an encoder/decoder based model.
CMyCaffe.param.LSTMSimpleParameter	[DEPRECIATED - use LSTMAttentionParameter instead with enable_attention = false] Specifies the parameters for the LSTMSimpleLayer.
CMyCaffe.param.LabelMappingParameter	/b DEPRECIATED (use DataLayer DataLabelMappingParameter instead) Specifies the parameters for the LabelMappingLayer.
CMyCaffe.param.LogParameter	Specifies the parameters for the LogLayer.
CMyCaffe.param.LossParameter	Stores the parameters used by loss layers.
CMyCaffe.param.MVNParameter	Specifies the parameters for the MVNLayer.
CMyCaffe.param.MathParameter	Specifies the parameters for the MathLayer.
CMyCaffe.param.MeanErrorLossParameter	Specifies the parameters for the MeanErrorLossLayerParameter.
CMyCaffe.param.MemoryDataParameter	Specifies the parameters used by the MemoryDataLayer.
CMyCaffe.param.ModelDataParameter	Specifies the parameter for the model data layer.
CMyCaffe.param.PReLUParameter	Specifies the parameters for the PReLULayer.
CMyCaffe.param.ParameterParameter	Specifies the parameters for the ParameterLayer
CMyCaffe.param.PowerParameter	Specifies the parameters for the PowerLayer.
CMyCaffe.param.ReductionParameter	Specifies the parameters used by ReductionLayer.
CMyCaffe.param.ReshapeParameter	Specifies the parameters for the ReshapeLayer.
CMyCaffe.param.SliceParameter	Specifies the parameters for the SliceLayer.
CMyCaffe.param.TextDataParameter	Specifies the parameter for the Text data layer.
CMyCaffe.param.ThresholdParameter	Stores the parameters used by the ThresholdLayer
CMyCaffe.param.TileParameter	Specifies the parameters used by the TileLayer
CMyCaffe.param.TransformationParameter	Stores parameters used to apply transformation to the data layer's data.
CMyCaffe.param.beta.DataSequenceParameter	Specifies the parameters for the DataSequenceLayer.
CMyCaffe.param.beta.DecodeParameter	Specifies the parameters for the DecodeLayer and the AccuracyEncodingLayer.
CMyCaffe.param.beta.GatherParameter	Specifies the parameters for the GatherLayer.
CMyCaffe.param.beta.KnnParameter	Specifies the parameters for the KnnLayer.
CMyCaffe.param.beta.MergeParameter	Specifies the parameters for the MergeLayer.
CMyCaffe.param.beta.Normalization1Parameter	Specifies the parameters for the Normalization1Layer.
CMyCaffe.param.beta.SqueezeParameter	Specifies the parameters for the SqueezeLayer.
CMyCaffe.param.beta.TransposeParameter	Specifies the parameters for the TransposeLayer.
CMyCaffe.param.beta.TripletLossParameter	Specifies the parameters for the TripletLossLayer.
CMyCaffe.param.gpt.CausalSelfAttentionParameter	Specifies the parameters for the CausalSelfAttentionLayer.
CMyCaffe.param.gpt.GeluParameter	Specifies the parameters for the GeluLayer.
CMyCaffe.param.gpt.LayerNormParameter	Specifies the parameters for the LayerNormalizationLayer.
CMyCaffe.param.gpt.MultiheadAttentionParameter	Specifies the parameters for the MultiheadAttentionLayer.
CMyCaffe.param.gpt.NLLLossParameter	Specifies the parameters for the NLLLossLayer.
CMyCaffe.param.gpt.PositionalEncoderParameter	Specifies the parameters for the PositionalEncoderLayer.
►CMyCaffe.param.gpt.TokenizedDataParameter	Specifies the parameters for the TokenizedDataLayer.
CMyCaffe.param.gpt.TokenizedDataPairsParameter	Specifies the parameters for the TokenizedDataPairsLayer.
CMyCaffe.param.gpt.TransformerBlockParameter	Specifies the parameters for the TransformerBlockLayer.
CMyCaffe.param.lnn.CfcParameter	Specifies the parameters used by the CfcLayer. Note, you must also fill out the CfcUnitParameter.
CMyCaffe.param.lnn.CfcUnitParameter	Specifies the parameters for the CfcUnitLayer used by the CfCLayer.
CMyCaffe.param.lnn.LtcUnitParameter	Specifies the parameters for the LtcUnitLayer used by the CfCLayer.
CMyCaffe.param.nt.GramParameter	Specifies the parameters for the GramLayer
CMyCaffe.param.nt.OneHotParameter	Specifies the parameters used by the OneHotLayer
CMyCaffe.param.nt.ScalarParameter	Specifies the parameters for the ScalarLayer
CMyCaffe.param.nt.TVLossParameter	Specifies the parameters for the TVLossLayer
CMyCaffe.param.python.PythonParameter	Specifies the parameters for the PythonLayer.
CMyCaffe.param.ssd.AnnotatedDataParameter	Specifies the parameters for the InputLayer.
CMyCaffe.param.ssd.DetectionEvaluateParameter	Specifies the parameters for the DetectionEvaluateLayer.
CMyCaffe.param.ssd.DetectionOutputParameter	Specifies the parameters for the DetectionOutputLayer.
CMyCaffe.param.ssd.MultiBoxLossParameter	Specifies the parameters for the MultiBoxLossParameter.
CMyCaffe.param.ssd.Normalization2Parameter	Specifies the parameters for the Normalization2Layer used in SSD.
CMyCaffe.param.ssd.PermuteParameter	Specifies the parameters for the PermuteLayer.
CMyCaffe.param.ssd.PriorBoxParameter	Specifies the parameters for the PriorBoxParameter.
CMyCaffe.param.ssd.VideoDataParameter	Specifies the parameters for the VideoDataLayer.
CMyCaffe.param.tft.CategoricalTransformationParameter	Specifies the parameters for the NumericInputTransformationLayer.
CMyCaffe.param.tft.DataTemporalParameter	Specifies the parameters for the DataTemporalLayer (used in TFT models).
CMyCaffe.param.tft.GateAddNormParameter	Specifies the parameters for the GetAddNormLayer (Gate Add Norm).
CMyCaffe.param.tft.GluParameter	Specifies the parameters for the GluLayer (Gated Linear Unit).
CMyCaffe.param.tft.GrnParameter	Specifies the parameters for the GrnLayer (Gated Response Network).
CMyCaffe.param.tft.MultiHeadAttentionInterpParameter	Specifies the parameters for the MultiHeadAttentionInterpLayer (Interpretable Multi-Head Attention Layer).
CMyCaffe.param.tft.NumericTransformationParameter	Specifies the parameters for the NumericInputTransformationLayer.
CMyCaffe.param.tft.QuantileAccuracyParameter	Specifies the parameters for the QuantileAccuracyLayer used in TFT models
CMyCaffe.param.tft.QuantileLossParameter	Specifies the parameters for the QuantileLossLayer used in TFT models
CMyCaffe.param.tft.ReshapeTemporalParameter	Specifies the parameters for the ReshapeTemporalLayer.
CMyCaffe.param.tft.VarSelNetParameter	Specifies the parameters for the VarSelNetLayer (Variable Selection Network).
CMyCaffe.param.NetParameter	Specifies the parameters use to create a Net
CMyCaffe.param.NetState	Specifies the NetState which includes the phase, level and stage for which a given Net is to run under.
CMyCaffe.param.NetStateRule	Specifies a NetStateRule used to determine whether a Net falls within a given include or exclude pattern.
CMyCaffe.param.ParamSpec	Specifies training parameters (multipliers on global learning constants, and the name of other settings used for weight sharing).
CMyCaffe.param.SolverParameter	The SolverParameter is a parameter for the solver, specifying the train and test networks.
CMyCaffe.param.ssd.BatchSampler	Specifies a sample of batch of bboxes with provided constraints in SSD.
CMyCaffe.param.ssd.Sampler	Specifies the sample of a bbox in the normalized space [0,1] with provided constraints used in SSD.
CMyCaffe.param.ssd.SamplerConstraint	Specifies the constratins for selecting sampled bbox used in SSD.
CMyCaffe.common.BatchInput	The BatchInput class stores the mini-batch index and input data.
CMyCaffe.common.BeamSearch< T >	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.
CMyCaffe.basecode.BinaryData	The BinaryData class is used to pack and unpack DataCriteria binary data, optionally stored within each SimpleDatum.
►CBinaryReader
CMyCaffe.db.stream.WAVReader	The WAVReader is an extension of the BinaryReader and is used to read WAV files.
►CBinaryWriter
CMyCaffe.db.stream.WAVWriter	The WAVWriter is a special BinaryWriter used to write WAV files.
CMyCaffe.common.BlobDebugInformation< T >	The BlobDebugInformation describes debug information relating to a given Blob in a given Layer.
CMyCaffe.common.BlobName	The BlobName class is used to build unique blob names.
CMyCaffe.basecode.Bucket	The Bucket class contains the information describing a single range of values within a BucketCollection.
CMyCaffe.basecode.Bytemap	The Bytemap operates similar to a bitmap but is actually just an array of bytes.
CMyCaffe.data.CiFar10DataLoader	The CiFar10DataLoader is used to create the CIFAR-10 dataset and load it into the database managed by the MyCaffe Image Database.
CMyCaffe.data.CiFar10DataParameters	Contains the dataset parameters used to create the CIFAR-10 dataset.
►CPython.Runtime.ClrMemberInfo	The ClrMemberInfo represents clr information.
CPython.Runtime.ClrFieldInfo	The ClrFieldInfo defines the clr field information.
CPython.Runtime.ClrPropertyInfo	The ClrPropertyInfo specifies the clr property information.
CMyCaffe.basecode.ColorMapper	The ColorMapper maps a value within a number range, to a Color within a color scheme.
►CComponent
CMyCaffe.converter.pytorch.MyCaffeConversionControl< T >	The MyCaffeConversionControl is used to convert a MyCaffe model to a PyTorch model.
CMyCaffe.db.image.MyCaffeImageDatabase	The MyCaffeImageDatabase provides an enhanced in-memory image database used for quick image retrieval.
CMyCaffe.db.image.MyCaffeImageDatabase2	[V2 Image Database] The MyCaffeImageDatabase2 provides an enhanced in-memory image database used for quick image retrieval.
CMyCaffe.trainers.MyCaffeTrainerDual	The MyCaffeTraininerDual is used to perform both reinforcement and recurrent learning training tasks on an instance of the MyCaffeControl.
CMyCaffe.trainers.MyCaffeTrainerRL	(Depreciated - use MyCaffeTrainerDual instead.) The MyCaffeTraininerRL is used to perform reinforcement learning training tasks on an instance of the MyCaffeControl.
CMyCaffe.trainers.MyCaffeTrainerRNN	(Depreciated - use MyCaffeTrainerDual instead.) The MyCaffeTrainerRNN is used to perform recurrent neural-network training tasks on an instance of the MyCaffeControl.
►CSystem.ComponentModel.Component	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.
CMyCaffe.MyCaffeControl< T >	The MyCaffeControl is the main object used to manage all training, testing and running of the MyCaffe system.
CMyCaffe.converter.onnx.MyCaffeConversionControl< T >	The MyCaffeConversionControl handles converting between MyCaffe and ONNX formats. The OnnxControl is used to read and write ONNX files.
CMyCaffe.db.stream.MyCaffeStreamDatabase	The MyCaffeStreamDatabase provides a streaming data input source to MyCaffe gyms used as input for dynamic, reinforcement learning.
CMyCaffe.db.temporal.MyCaffeTemporalDatabase	[Temporal Database] The MyCaffeTemporalDatabase provides an enhanced in-memory temporal database used for quick temporal data retrieval.
CMyCaffe.preprocessor.MyCaffeDataPreprocessor< T >	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.
CMyCaffe.basecode.ConnectInfo	The ConnectInfo class specifies the server, database and username/password used to connect to a database.
CMyCaffe.common.CudaDnnMemoryTracker< T >	The CudaDnnMemoryTracker is used for diagnostics in that it helps estimate the amount of memory that a Net will use.
CMyCaffe.gym.python.CurrentState	The State contains the current state of the gym.
CMyCaffe.data.Cursor< T >	The Cursor is used to traverse through a given data source within the database.
CMyCaffe.db.stream.CustomQueryCollection	The CustomQueryCollection manages the external Custom Queries placed in the
CMyCaffe.db.image.DatabaseInstanceQuery	The DatabaseInstanceQuery class is used to find all installed instances of SQL on a given machine.
CMyCaffe.db.temporal.DatabaseLoader	The DatasetLoader is used to load descriptors from the database.
CMyCaffe.db.image.DatabaseManagement	The DatabaseManagement class is used to create the image database.
CMyCaffe.param.DataDebugParameter	The DataDebugParameter is used by the DataParameter when the 'enable_debugging' = True.
CMyCaffe.db.stream.DataItem	The DataItem manages one synchronized data item where the first element is the sync field.
CMyCaffe.db.stream.DataItemCollection	The DataItemCollection contains the collection of synchronized data items collected from all custom queries.
CMyCaffe.param.DataNoiseParameter	The DataNoiseParameter is used by the DataParameter when the 'enable_noise_for_nonmatch' = True, which is used when 'images_per_blob' > 1.
CMyCaffe.gym.DataPoint	The DataPoint contains the data used when training.
CMyCaffe.layers.tft.DataSchema	The DataSchema class is used by the DataTemporalLayer to load the data schema describing the NPY files containing the dataset.
CMyCaffe.db.temporal.DataSet	The DataSet class loads the training and testing data.
CMyCaffe.data.DB< T >	A generic database class used to connect to the underlying database and create a Cursor that traverses through it.
►CDbConfiguration
CMyCaffe.db.image.DNNConfiguration	The DNNConfiguration class used to define the connection strategy.
CMyCaffe.db.image.DbItem	Specifies a database item used when querying boosted items.
CMyCaffe.db.image.DNNEntities	The DNNEntities class defines the entities used to connecto the database via Entity Frameworks.
CMyCaffe.db.temporal.DNNEntitiesTemporal	The DNNEntities class defines the entities used to connecto the database via Entity Frameworks.
►CDuplexClientBase
CMyCaffe.gym.MyCaffeGymUiProxy	The MyCaffeGymUiProxy is used to interact with the MyCaffeGymUiService.
►CMyCaffe.db.image.EntitiesConnection	The EntitiesConnection class defines how to connect to the database via Entity Frameworks.
CMyCaffe.db.temporal.EntitiesConnectionTemporal	The EntitiesConnection class defines how to connect to the database via Entity Frameworks.
►CEventArgs
CMyCaffe.basecode.CalculateImageMeanArgs	The CalculateImageMeanArgs is passed as an argument to the MyCaffeImageDatabase::OnCalculateImageMean event.
►CMyCaffe.basecode.LogProgressArg	The LogProgressArg is passed as an argument to the Log::OnProgress event.
CMyCaffe.basecode.LogArg	The LogArg is passed as an argument to the Log::OnWriteLine event.
CMyCaffe.basecode.LossArgs	The LossArgs contains the loss values for a given batch.
CMyCaffe.basecode.OverrideProjectArgs	The OverrideProjectArgs is passed as an argument to the OnOverrideModel and OnOverrideSolver events fired by the ProjectEx class.
CMyCaffe.common.ActionStateArgs< T >	The ActionStateArgs are sent to the DoWork event when fired from the InternalThreadEntry.
CMyCaffe.common.CustomForwardBackArgs< T >	The CustomForwardBackArgs provide the arguments to the OnCustomForwardBack event within the Solver Step function.
CMyCaffe.common.GetBytesArgs	The GetBytesArgs is passed along to the SnapshotArgs::OnGetWeights and SnapshotArgs::OnGetState events.
CMyCaffe.common.GetConversionBlobArgs< T >	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.
CMyCaffe.common.GetIterationArgs	The GetIterationArgs is sent bubbled up to the solver when a layer needs to know the curret training iteration.
CMyCaffe.common.GetWorkBlobArgs< T >	The GetWorkBlobArgs are passed to the Layer::OnGetWorkBlob event which is supported for debugging only.
CMyCaffe.common.GradientsReadyArgs	The GradientsReadyArgs is sent to the Solver::OnGradientsReady event which fires at the end of each Solver::Step.
CMyCaffe.common.SnapshotArgs	The SnapshotArgs is sent to the Solver::OnSnapshot event which fires each time the Solver::Snapshot method is called.
CMyCaffe.common.TestArgs	The TestArgs are passed to the Solver::OnTest event.
CMyCaffe.common.TestResultArgs< T >	The TestResultArgs are passed to the Solver::OnTestResults event.
►CMyCaffe.common.TestingIterationArgs< T >	Specifies the TestingIterationArgs sent to the Solver::OnTestingIteration, which is called at the end of a testing cycle.
CMyCaffe.common.TrainingIterationArgs< T >	The TrainingIterationArgs is sent to the Solver::OnTrainingIteration event that fires at the end of a training cycle.
CMyCaffe.common.WorkspaceArgs	The WorkspaceArgs are passed to both the Layer::OnSetWorkspace and Layer::OnGetWorkspace events.
CMyCaffe.data.ProgressArgs	Defines the arguments sent to the OnProgress and OnError events.
CMyCaffe.extras.NeuralStyleIntermediateOutputArgs	The NeuralStyleIntermediateOutputArgs contains the arguments sent to the OnIntermediateOutput event.
CMyCaffe.layers.LastBatchLoadedArgs	Specifies the arguments sent to the OnBatchLoad event used when synchronizing between Data Layers.
CMyCaffe.layers.MemoryDataLayerGetDataArgs	The MemoryDataLayerGetDataArgs class is passed to the OnGetData event.
CMyCaffe.layers.MemoryDataLayerPackDataArgs< T >	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.
CMyCaffe.layers.MemoryLossLayerGetLossArgs< T >	The MemoryLossLayerGetLossArgs class is passed to the OnGetLoss event.
CMyCaffe.layers.beta.ModelData.OnGetDataArgs	Defines the arguments passed to the OnGetData event.
CMyCaffe.layers.beta.TextData.OnGetDataArgs	Defines the arguments passed to the OnGetData event.
CMyCaffe.param.VerifyBatchSizeArgs	The VerifyBatchSizeArgs class defines the arguments of the OnVerifyBatchSize event.
CMyCaffe.trainers.ApplyUpdateArgs< T >	The ApplyUpdateArgs is passed to the OnApplyUpdates event.
CMyCaffe.trainers.ConvertOutputArgs	The ConvertOutputArgs is passed to the OnConvertOutput event.
CMyCaffe.trainers.GetDataArgs	The GetDataArgs is passed to the OnGetData event to retrieve data.
CMyCaffe.trainers.GetStatusArgs	The GetStatusArgs is passed to the OnGetStatus event.
CMyCaffe.trainers.InitializeArgs	The InitializeArgs is passed to the OnInitialize event.
CMyCaffe.trainers.OverlayArgs	The OverlayArgs is passed ot the OnOverlay event, optionally fired just before displaying a gym image.
CMyCaffe.trainers.TestAccuracyUpdateArgs	The TestAccuracyUpdateArgs are passed to the OnTestAccuracyUpdate event.
CMyCaffe.trainers.WaitArgs	The WaitArgs is passed to the OnWait event.
CMyCaffe.layers.tft.Field	The Field class manages a single field.
►CMyCaffe.fillers.Filler< T >	Abstract Filler class used to fill blobs with values.
CMyCaffe.fillers.BilinearFiller< T >	Fills a Blob with coefficients for bilinear interpolation.
CMyCaffe.fillers.ConstantFiller< T >	Fills a Blob with constant values x = c.
CMyCaffe.fillers.GaussianFiller< T >	Fills a Blob with Gaussian-distributed values .
CMyCaffe.fillers.MsraFiller< T >	Fills a Blob with values where is set inversely proportionla to number of incomming nodes, outgoing nodes, or their average.
CMyCaffe.fillers.PositiveUnitballFiller< T >	Fills a Blob with values such that .
CMyCaffe.fillers.SequenceFiller< T >	Fills a Blob with a sequence of values x0 = c; x1 = c + 0.01...
CMyCaffe.fillers.UniformFiller< T >	Fills a Blob with uniformly distributed values
CMyCaffe.fillers.XavierFiller< T >	Fills a Blob with values where is set inversely proportional to number of incoming nodes, outgoing nodes, or their average.
►CForm
CMyCaffe.gym.FormActionImage	The FormActionImage displays the action image (if one exists)
CMyCaffe.gym.FormGym	The FormGym displays the gym visualization.
CMyCaffe.gym.FormGyms	The FormGyms dialog displays the available gyms.
CMyCaffe.param.ui.FormProperty	The FormProperty window is used to edit a given key/value pair.
►CMyCaffe.common.ForwardArgs< T >	The ForwardArgs are passed to the OnForward event of the EventLayer.
CMyCaffe.common.BackwardArgs< T >	The BackwardArgs are passed to the OnBackward event of the EventLayer.
►CMyCaffe.basecode.GenericList< DataQuery >
CMyCaffe.db.stream.DataQueryCollection	The DataQueryCollection manages all active data queries.
CMyCaffe.basecode.GenericList< MemoryItem >
►CMyCaffe.gym.GeomObj	The GoomObj is the base class for all other gometric objects used to draw Gym objects.
CMyCaffe.gym.GeomEllipse	The GeomEllipse object is used to render an ellipse.
CMyCaffe.gym.GeomLine	The GeomLine object is used to render a line.
CMyCaffe.gym.GeomPolyLine	The GeomPolyLine object is used to render an spline.
CMyCaffe.gym.GeomPolygon	The GeomPolygon object is used to render an polygon.
CMyCaffe.gym.GeomRectangle	The GeomEllipse object is used to render an rectangle.
CMyCaffe.gym.GeomView	The GeomView manages and renders a collection of Geometric objects.
►CMyCaffe.basecode.IBinaryPersist	The IBinaryPersist interface provides generic save and load functionality.
CMyCaffe.param.BlobProto	The BlobProto contains the descripion of a blob.
CMyCaffe.param.BlobShape	Specifies the shape of a Blob.
CMyCaffe.param.LayerParameter	Specifies the base parameter for all layers.
CMyCaffe.param.LayerParameterBase	The LayerParameterBase is the base class for all other layer specific parameters.
CMyCaffe.param.NetStateRule	Specifies a NetStateRule used to determine whether a Net falls within a given include or exclude pattern.
CMyCaffe.param.ParamSpec	Specifies training parameters (multipliers on global learning constants, and the name of other settings used for weight sharing).
CMyCaffe.param.ssd.BatchSampler	Specifies a sample of batch of bboxes with provided constraints in SSD.
CMyCaffe.param.ssd.Sampler	Specifies the sample of a bbox in the normalized space [0,1] with provided constraints used in SSD.
CMyCaffe.param.ssd.SamplerConstraint	Specifies the constratins for selecting sampled bbox used in SSD.
►CICloneable
CMyCaffe.param.BlobProto	The BlobProto contains the descripion of a blob.
CMyCaffe.param.BlobShape	Specifies the shape of a Blob.
CMyCaffe.param.FillerParameter	Specifies the filler parameters used to create each Filler.
CMyCaffe.param.LayerParameter	Specifies the base parameter for all layers.
CMyCaffe.param.NetState	Specifies the NetState which includes the phase, level and stage for which a given Net is to run under.
CMyCaffe.param.NetStateRule	Specifies a NetStateRule used to determine whether a Net falls within a given include or exclude pattern.
CMyCaffe.param.ParamSpec	Specifies training parameters (multipliers on global learning constants, and the name of other settings used for weight sharing).
CMyCaffe.param.ssd.BatchSampler	Specifies a sample of batch of bboxes with provided constraints in SSD.
CMyCaffe.param.ssd.Sampler	Specifies the sample of a bbox in the normalized space [0,1] with provided constraints used in SSD.
CMyCaffe.param.ssd.SamplerConstraint	Specifies the constratins for selecting sampled bbox used in SSD.
►CIComparable
CMyCaffe.param.BlobProto	The BlobProto contains the descripion of a blob.
CMyCaffe.param.BlobShape	Specifies the shape of a Blob.
CMyCaffe.param.LayerParameter	Specifies the base parameter for all layers.
CMyCaffe.param.NetState	Specifies the NetState which includes the phase, level and stage for which a given Net is to run under.
CMyCaffe.param.NetStateRule	Specifies a NetStateRule used to determine whether a Net falls within a given include or exclude pattern.
CMyCaffe.param.ssd.BatchSampler	Specifies a sample of batch of bboxes with provided constraints in SSD.
CMyCaffe.param.ssd.Sampler	Specifies the sample of a bbox in the normalized space [0,1] with provided constraints used in SSD.
CMyCaffe.param.ssd.SamplerConstraint	Specifies the constratins for selecting sampled bbox used in SSD.
CMyCaffe.layers.gpt.ICustomTokenInput	The ICustomTokenInput interface specifies the interface that all custom token inputs implement.
►CIDisposable
CMyCaffe.MyCaffeControl< T >	The MyCaffeControl is the main object used to manage all training, testing and running of the MyCaffe system.
CMyCaffe.basecode.CancelEvent	The CancelEvent provides an extension to the manual cancel event that allows for overriding the manual cancel event.
CMyCaffe.basecode.DirectBitmap	The DirectBitmap class provides an efficient bitmap creating class.
CMyCaffe.common.BBoxUtility< T >	The BBox class processes the NormalizedBBox data used with SSD.
CMyCaffe.common.Blob< T >	The Blob is the main holder of data that moves through the Layers of the Net.
CMyCaffe.common.BlobCollection< T >	The BlobCollection contains a list of Blobs.
CMyCaffe.common.BlockingQueue< T >	The BlockingQueue is used for synchronized Queue operations.
CMyCaffe.common.Cache< T >	The Cache class is used to cache blobs over time.
CMyCaffe.common.ComputeGraph< T >	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.
CMyCaffe.common.CudaDnn< T >	The CudaDnn object is the main interface to the Low-Level Cuda C++ DLL.
CMyCaffe.common.DebugInformation< T >	The DebugInformation contains information used to help debug the Layers of a Net while it is training.
►CMyCaffe.common.GPUParams< T >	The GPUParams contains the connection to the low-level Cuda, and the stream associated with this instance.
CMyCaffe.common.NCCL< T >	The NCCL class manages the multi-GPU operations using the low-level NCCL functionality provided by the low-level Cuda Dnn DLL.
CMyCaffe.common.HostBuffer< T >	The HostBuffer helps manage host memory, often used when implementing CPU versions of a function or layer.
►CMyCaffe.common.InternalThread< T >	The InternalThread manages an internal thread used for Parallel and data collection operations.
CMyCaffe.common.Worker< T >	The Worker manages each 'non' root sover running, where each Worker operates on a different GPU.
CMyCaffe.common.NCCL< T >	The NCCL class manages the multi-GPU operations using the low-level NCCL functionality provided by the low-level Cuda Dnn DLL.
CMyCaffe.common.Net< T >	Connects Layer's together into a direct acrylic graph (DAG) specified by a NetParameter
CMyCaffe.common.NumpyFile< T >	The NumpyFile reads data from a numpy file in the base type specified.
CMyCaffe.common.SsdSampler< T >	The SsdSampler is used by the SSD algorithm to sample BBoxes.
CMyCaffe.common.SyncedMemory< T >	The SyncedMemory manages the low-level connection between the GPU and host memory.
CMyCaffe.data.BinaryFile	The BinaryFile class is used to manage binary files used by the MNIST dataset creator.
CMyCaffe.data.DataTransformer< T >	Applies common transformations to the input data, such as scaling, mirroring, subtracting the image mean...
►CMyCaffe.db.image.Database	The Database class manages the actual connection to the physical database using Entity Framworks from Microsoft.
CMyCaffe.db.temporal.DatabaseTemporal	The DatabaseTemporal is used to manage all temporal specific database objects.
CMyCaffe.db.image.DatasetEx	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.
CMyCaffe.db.image.DatasetEx2	[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.
CMyCaffe.db.image.DatasetExCollection	The DatasetExCollection contains a list of DatasetEx objects.
CMyCaffe.db.image.DatasetExCollection2	[V2 Image Database] The DatasetExCollection2 contains a list of DatasetEx2 objects.
CMyCaffe.db.image.DatasetFactory	The DatasetFactory manages the connection to the Database object.
CMyCaffe.db.image.ImageSet	The ImageSet class contains the list of image for a data source as well as a list of LabelSets that map into it.
CMyCaffe.db.image.ImageSet2	[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).
►CMyCaffe.db.image.ImageSetBase	The ImageSetBase class contains the list of image for a data source as well as a list of LabelSets that map into it.
CMyCaffe.db.image.ImageSet2	[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).
CMyCaffe.db.image.LabelSet	The LabelSet 'points' into the main image list via references objects that are already created in the main image list of the ImageSet.
►CMyCaffe.db.image.MasterIndexes	The MasterIndexes stores the indexes that define the index structure of the data source data.
CMyCaffe.db.image.QueryState	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.
CMyCaffe.db.image.MasterList	The MasterList is responsible for loading and managing access to the master list of images for a data source.
CMyCaffe.db.image.QueryStateCollection	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.
CMyCaffe.db.stream.DataQuery	The DataQuery manages a custom query interface and queues data from the custom query via an internal query thread.
CMyCaffe.db.stream.DataQueryCollection	The DataQueryCollection manages all active data queries.
CMyCaffe.db.temporal.DatasetCollection	The DatasetCollection manages a set of datasets.
CMyCaffe.db.temporal.TemporalSet	The TemporalSet manages a set of temporal data for a given data source.
CMyCaffe.extras.DeepDraw< T >	The DeepDraw class implements both deep drawing and deep dream as originally introduced by Google.
CMyCaffe.extras.NeuralStyleTransfer< T >	The NeuralStyleTransfer object uses the GramLayer, TVLossLayer and LBFGSSolver to perform the neural style transfer algorithm.
CMyCaffe.extras.Octaves	The Octave class defines the setting sused when images are generated.
CMyCaffe.gym.AtariGym	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).
CMyCaffe.gym.CurveGym	The Curve Gym provides a simulation of continuous curve such as Sin or Cos.
CMyCaffe.gym.DataGeneralGym	The DataGeneral Gym provides access to the MyCaffe Streaming Database with GENERAL query types.
CMyCaffe.gym.ModelGym	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.
CMyCaffe.gym.python.MyCaffePythonGym	The MyCaffePythonGym class provides a simple interface that can easily be used from within Python.
CMyCaffe.layers.Batch< T >	The Batch contains both the data and label Blobs of the batch.
►CMyCaffe.layers.Layer< T >	An interface for the units of computation which can be composed into a Net.
CMyCaffe.layers.AccuracyLayer< T >	The AccuracyLayer computes the classification accuracy for a one-of-many classification task. This layer is initialized with the MyCaffe.param.AccuracyParameter.
CMyCaffe.layers.ArgMaxLayer< T >	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.
CMyCaffe.layers.AttentionLayer< T >	[DEPRECIATED] The AttentionLayer provides focus for LSTM based encoder/decoder models.
►CMyCaffe.layers.BaseConvolutionLayer< T >	The BaseConvolutionLayer is an abstract base class that factors out BLAS code common to ConvolutionLayer and DeconvolutionLayer
CMyCaffe.layers.ConvolutionLayer< T >	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.
CMyCaffe.layers.DeconvolutionLayer< T >	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
►CMyCaffe.layers.BaseDataLayer< T >	The BaseDataLayer is the base class for data Layers that feed Blobs of data into the Net.
►CMyCaffe.layers.BasePrefetchingDataLayer< T >	The BasePrefetchingDataLayer is the base class for data Layers that pre-fetch data before feeding the Blobs of data into the Net.
CMyCaffe.layers.DataLayer< T >	The DataLayer loads data from the IXImageDatabase database. This layer is initialized with the MyCaffe.param.DataParameter.
CMyCaffe.layers.ImageDataLayer< T >	The ImageDataLayer loads data from the image files located in the root directory specified. This layer is initialized with the MyCaffe.param.ImageDataParameter.
CMyCaffe.layers.ssd.AnnotatedDataLayer< T >	The AnnotatedDataLayer provides annotated data to the Net by assigning top Blobs directly. This layer is initialized with the MyCaffe.param.AnnotatedDataParameter.
CMyCaffe.layers.ssd.VideoDataLayer< T >	The VideoDataLayer provides data to the Net from a WebCam or Video file. This layer is initialized with the MyCaffe.param.VideoDataParameter.
CMyCaffe.layers.MemoryDataLayer< T >	The MemoryDataLayer provides data to the Net from memory. This layer is initialized with the MyCaffe.param.MemoryDataParameter.
CMyCaffe.layers.BatchNormLayer< T >	The BatchNormLayer normalizes the input to have 0-mean and/or unit (1) variance across the batch. This layer is initialized with the BatchNormParameter.
CMyCaffe.layers.BatchReindexLayer< T >	The BatchReindexLayer provides an index into the input blob along its first axis.
CMyCaffe.layers.BiasLayer< T >	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.
CMyCaffe.layers.ConcatLayer< T >	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.
CMyCaffe.layers.ConstantLayer< T >	The ConstantLayer provides a layer that just outputs a constant value. This layer is initialized with the MyCaffe.param.ConstantParameter.
CMyCaffe.layers.CopyLayer< T >	The CopyLayer copies the src bottom to the dst bottom. The layer has no output.
CMyCaffe.layers.CropLayer< T >	The CropLayer takes a Blob and crops it to the shape specified by the second input Blob, across all dimensions after the specified axis
CMyCaffe.layers.DataNormalizerLayer< T >	The DataNormalizerLayer normalizes the input data (and optionally label) based on the normalization operations specified in the layer parameter.
CMyCaffe.layers.DebugLayer< T >	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.
CMyCaffe.layers.DummyDataLayer< T >	The DummyDataLayer provides data to the Net generated by a Filler. This layer is initialized with the MyCaffe.param.DummyDataParameter.
CMyCaffe.layers.EltwiseLayer< T >	The EltwiseLayer computes elementwise oeprations, such as product and sum, along multiple input blobs. This layer is initialized with the MyCaffe.param.EltwiseParameter.
CMyCaffe.layers.EmbedLayer< T >	The EmbedLayer is a layer for learning 'embeddings' of one-hot vector input. This layer is initialized with the MyCaffe.param.EmbedParameter.
CMyCaffe.layers.FilterLayer< T >	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).
CMyCaffe.layers.FlattenLayer< T >	The FlattenLayer reshapes the input Blob into flat vectors This layer is initialized with the MyCaffe.param.FlattenParameter.
CMyCaffe.layers.Im2colLayer< T >	The Im2ColLayer is a helper layer for image operations that rearranges image regions into column vectors.
CMyCaffe.layers.InnerProductLayer< T >	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.
CMyCaffe.layers.InputLayer< T >	The InputLayer provides data to the Net by assigning top Blobs directly. This layer is initialized with the MyCaffe.param.InputParameter.
CMyCaffe.layers.LRNLayer< T >	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.
CMyCaffe.layers.LSTMAttentionLayer< T >	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
CMyCaffe.layers.LSTMSimpleLayer< T >	[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.
CMyCaffe.layers.LSTMUnitLayer< T >	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.
►CMyCaffe.layers.LossLayer< T >	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.
CMyCaffe.layers.ContrastiveLossLayer< T >	The ContrastiveLossLayer computes the contrastive loss where . This layer is initialized with the MyCaffe.param.ContrastiveLossParameter.
CMyCaffe.layers.EuclideanLossLayer< T >	The EuclideanLossLayer computes the Euclidean (L2) loss for real-valued regression tasks.
CMyCaffe.layers.HingeLossLayer< T >	The HingeLossLayer computes the hinge loss for a one-of-many classification task. This layer is initialized with the MyCaffe.param.HingeLossParameter.
CMyCaffe.layers.InfogainLossLayer< T >	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.
CMyCaffe.layers.MemoryLossLayer< T >	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.
CMyCaffe.layers.MultinomialLogisticLossLayer< T >	The MultinomialLogicistLossLayer computes the multinomial logistc loss for a one-of-many classification task, directly taking a predicted probability distribution as input.
CMyCaffe.layers.QuantileLossLayer< T >	The QuantileLossLayer computes the quantile loss for real-valued regression tasks.
CMyCaffe.layers.SigmoidCrossEntropyLossLayer< T >	The SigmoidCrossEntropyLayer computes the cross-entropy (logisitic) loss and is often used for predicting targets interpreted as probabilities.
CMyCaffe.layers.SoftmaxCrossEntropy2LossLayer< T >	The SoftmaxCrossEntropy2Layer computes the cross-entropy (logisitic) loss and is often used for predicting targets interpreted as probabilities.
CMyCaffe.layers.SoftmaxCrossEntropyLossLayer< T >	The SoftmaxCrossEntropyLossLayer computes the cross-entropy (logisitic) loss and is often used for predicting targets interpreted as probabilities in reinforcement learning.
CMyCaffe.layers.SoftmaxLossLayer< T >	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.
CMyCaffe.layers.beta.MeanErrorLossLayer< T >	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
CMyCaffe.layers.beta.TripletLossLayer< T >	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)
CMyCaffe.layers.gpt.NLLLossLayer< T >	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.
CMyCaffe.layers.nt.TVLossLayer< T >	The TVLossLayer computes total variation loss as described by 'Mahendran' et al., and used in Neural Style.
CMyCaffe.layers.ssd.MultiBoxLossLayer< T >	The MultiBoxLossLayer performs multibox operations including the following:
CMyCaffe.layers.ssd.SmoothL1LossLayer< T >	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
CMyCaffe.layers.MVNLayer< T >	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.
►CMyCaffe.layers.NeuronLayer< T >	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.
CMyCaffe.layers.AbsValLayer< T >	The AbsValLayer computes the absolute value of the input.
CMyCaffe.layers.BNLLLayer< T >	The Binomial Normal Log Liklihod Layer.
CMyCaffe.layers.ClipLayer< T >	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.
CMyCaffe.layers.DropoutLayer< T >	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.
CMyCaffe.layers.ELULayer< T >	The ELULayer computes exponential linear unit non-linearity . This layer is initialized with the MyCaffe.param.EluParameter.
CMyCaffe.layers.ExpLayer< T >	The ExpLayer which computes the exponential of the input. This layer is initialized with the MyCaffe.param.ExpParameter.
CMyCaffe.layers.GradientScaleLayer< T >	The GradientScaleLayer which scales the deltas during the backpropagation. This layer is initialized with the MyCaffe.param.GradientScaleParameter.
CMyCaffe.layers.LabelMappingLayer< T >	/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.
CMyCaffe.layers.LogLayer< T >	The LogLayer computes the log of the input. This layer is initialized with the MyCaffe.param.LogParameter.
CMyCaffe.layers.MathLayer< T >	The MathLayer which computes various mathematical functions of the input. This layer is initialized with the MyCaffe.param.MathParameter.
CMyCaffe.layers.PReLULayer< T >	The PReLULayer computes the "Parameterized Rectified Linear Unit" non-linearity. This layer is initialized with the MyCaffe.param.PReLUParameter.
CMyCaffe.layers.ParameterLayer< T >	The ParameterLayer passes its blob[0] data and diff to the top[0].
CMyCaffe.layers.PowerLayer< T >	The PowerLayer computes the power of the input. This layer is initialized with the MyCaffe.param.PowerParameter.
CMyCaffe.layers.ReLULayer< T >	The ReLULayer computes the "Rectifier Linear Unit" ReLULayer non-linearity, a classic for neural networks. This layer is initialized with the MyCaffe.param.ReLUParameter.
CMyCaffe.layers.SigmoidLayer< T >	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.
CMyCaffe.layers.SwishLayer< T >	The SwishLayer provides a novel activation function that tends to work better than ReLU. This layer is initialized with the MyCaffe.param.SwishParameter.
CMyCaffe.layers.TanhLayer< T >	The TanhLayer is a neuron layer that calculates the tanh function, popular with auto-encoders. This layer is initialized with the MyCaffe.param.TanhParameter.
CMyCaffe.layers.ThresholdLayer< T >	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.
CMyCaffe.layers.beta.MishLayer< T >	The MishLayer provides a novel activation function that tends to work better than ReLU. This layer is initialized with the MyCaffe.param.MishParameter.
CMyCaffe.layers.beta.SerfLayer< T >	The SerfLayer provides a novel activation function that tends to work better than ReLU.
CMyCaffe.layers.gpt.GeluLayer< T >	The GeluLayer implements the New GELU activation function currently in Google BERT repo (same as OpenAI GPT)
CMyCaffe.layers.lnn.LeCunLayer< T >	The LeCunLayer performs the LeCun's Tanh function
CMyCaffe.layers.lnn.SiLULayer< T >	The SiLULayer implements the Sigmoid-weighted Linear Unit (SiLU) activation function
CMyCaffe.layers.lnn.SoftPlusLayer< T >	The SoftPlusLayer implements the Softplus function, a smooth approximation of the ReLU function
CMyCaffe.layers.nt.ScalarLayer< T >	The ScalarLayer computes the operation with the value on the input.
CMyCaffe.layers.PoolingLayer< T >	The PoolingLayer pools the input image by taking the max, average, etc. within regions. This layer is initialized with the MyCaffe.param.PoolingParameter.
►CMyCaffe.layers.RecurrentLayer< T >	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.
CMyCaffe.layers.LSTMLayer< T >	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.
CMyCaffe.layers.RNNLayer< T >	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.
CMyCaffe.layers.ReductionLayer< T >	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.
CMyCaffe.layers.ReshapeLayer< T >	The ReshapeLayer reshapes the input Blob into an arbitrary-sized output Blob. This layer is initialized with the MyCaffe.param.ReshapeParameter.
CMyCaffe.layers.SPPLayer< T >	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.
CMyCaffe.layers.ScaleLayer< T >	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.
CMyCaffe.layers.SilenceLayer< T >	The SilenceLayer ignores bottom blobs while producing no top blobs. (This is useuful to suppress output during testing.)
CMyCaffe.layers.SliceLayer< T >	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.
CMyCaffe.layers.SoftmaxLayer< T >	The SoftmaxLayer computes the softmax function. This layer is initialized with the MyCaffe.param.SoftmaxParameter.
CMyCaffe.layers.SplitLayer< T >	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.
CMyCaffe.layers.TileLayer< T >	The TileLayer copies a Blob along specified dimensions. This layer is initialized with the MyCaffe.param.TileParameter.
CMyCaffe.layers.beta.AccuracyDecodeLayer< T >	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.
CMyCaffe.layers.beta.AccuracyEncodingLayer< T >	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.
CMyCaffe.layers.beta.ConvolutionOctaveLayer< T >	The ConvolutionOctaveLayer processes high and low frequency portions of images using convolution.
CMyCaffe.layers.beta.DataSequenceLayer< T >	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
CMyCaffe.layers.beta.DecodeLayer< T >	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.
CMyCaffe.layers.beta.GatherLayer< T >	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.
CMyCaffe.layers.beta.GlobResNormLayer< T >	The GRNLayer performs an L2 normalization over the input data.
CMyCaffe.layers.beta.InterpLayer< T >	The InterpLayer changes the spatial resolution by bi-linear interpolation.
CMyCaffe.layers.beta.KnnLayer< T >
CMyCaffe.layers.beta.MergeLayer< T >	The MergeLayer merges two bottom blobs with a specified copy pattern and outputs a single blob result.
CMyCaffe.layers.beta.ModelDataLayer< T >	The ModelDataLayer loads data from RawImageResults table for an encoder/decoder type model.
CMyCaffe.layers.beta.Normalization1Layer< T >	The Normalization1Layer performs an L2 normalization over the input data. This layer is initialized with the MyCaffe.param.Normalization1Parameter.
CMyCaffe.layers.beta.SqueezeLayer< T >	The SqueezeLayer performs a squeeze operation where all single dimensions are removed.
CMyCaffe.layers.beta.TextDataLayer< T >	The TextDataLayer loads data from text data files for an encoder/decoder type model. This layer is initialized with the MyCaffe.param.TextDataParameter.
CMyCaffe.layers.beta.TransposeLayer< T >	The TransposeLayer performs a permute and transpose operation similar to numpy.transpose.
CMyCaffe.layers.beta.UnPoolingLayer1< T >
CMyCaffe.layers.beta.UnPoolingLayer< T >
CMyCaffe.layers.beta.UnsqueezeLayer< T >	The UnsqueezeLayer performs an unsqueeze operation where a single dimension is inserted at each index specified.
CMyCaffe.layers.gpt.CausalSelfAttentionLayer2< T >	The CausalSelfAttention provides a vanilla multi-head self-attention layer with projection at the end.
CMyCaffe.layers.gpt.CausalSelfAttentionLayer< T >	The CausalSelfAttention provides a vanilla multi-head self-attention layer with projection at the end.
CMyCaffe.layers.gpt.LayerNormLayer< T >	The LayerNormalizationLayer performs layer normalization similar to the PyTorch LayerNorm layer.
CMyCaffe.layers.gpt.MultiheadAttentionLayer< T >	The MultiheadAttention provides a vanilla multi-head layer.
CMyCaffe.layers.gpt.PositionalEncodingLayer< T >	The PositionalEncodingLayer is a neuron layer that adds positional encoding to the input.
CMyCaffe.layers.gpt.TokenizedDataLayer< T >	The TokenizedDataLayer loads and tokenizes data for a transformer model where data is loaded in the form: data, pos, target(optional)
CMyCaffe.layers.gpt.TokenizedDataPairsLayer< T >	The TokenizedDataPairsLayer loads and tokenizes data for a transformer model where data is loaded in the form: data, pos, target(optional)
CMyCaffe.layers.gpt.TransformerBlockLayer< T >	The TransformerBlock provides a generic transformer block
CMyCaffe.layers.hdf5.HDF5DataLayer< T >	The HDF5DataLayer loads data from files in the HDF5 data format. This layer is initialized with the MyCaffe.param.HDF5DataParameter.
CMyCaffe.layers.lnn.CfcLayer< T >	The CfcLayer implements the Closed form Continuous layer.
►CMyCaffe.layers.lnn.LnnUnitLayer< T >	The LnnUnitLayer implements the base class to the Cfc and Ltc Unit layers.
CMyCaffe.layers.lnn.CfcUnitLayer< T >	The CfcUnitLayer implements the Closed form Continuous Cell (CfcCell) layer.
CMyCaffe.layers.lnn.LtcUnitLayer< T >	The LtcUnitLayer implements the liquid time constant with ODE solver (LTCCell) layer.
CMyCaffe.layers.nt.EventLayer< T >	The EventLayer provides an event that fires on the forward pass and another that fires on the backward pass.
CMyCaffe.layers.nt.GramLayer< T >	The GramLayer computes the Gram matrix used in Neural Style.
CMyCaffe.layers.nt.OneHotLayer< T >	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.
CMyCaffe.layers.ssd.DetectionEvaluateLayer< T >	The DetectionEvaluateLayer generates the detection evaluation based on the DetectionOutputLayer and ground truth bounding box labels.
CMyCaffe.layers.ssd.DetectionOutputLayer< T >	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.
CMyCaffe.layers.ssd.Normalization2Layer< T >	The Normalization2Layer performs normalization used by the SSD algorithm. This layer is initialized with the MyCaffe.param.Normalization2Parameter.
CMyCaffe.layers.ssd.PermuteLayer< T >	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.
CMyCaffe.layers.ssd.PriorBoxLayer< T >	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.
CMyCaffe.layers.tft.CategoricalTransformationLayer< T >	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.
CMyCaffe.layers.tft.ChannelEmbeddingLayer< T >	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
CMyCaffe.layers.tft.DataTemporalLayer< T >	The DataTemporalLayer implements the data layer used to load the temporal data into the model.
CMyCaffe.layers.tft.GateAddNormLayer< T >	The GateAddNormLayer implements the Dropout, Gated Linear Unit layer, LayerNorm while adding in the residual.
CMyCaffe.layers.tft.GluLayer< T >	The GluLayer implements the Gated Linear Unit layer.
CMyCaffe.layers.tft.GrnLayer< T >	The GrnLayer implements the Gated Linear Unit layer.
CMyCaffe.layers.tft.MultiHeadAttentionInterpLayer< T >	The MultiHeadAttentionInterpLayer implements the Multi-head Attention Interpretive Layer
CMyCaffe.layers.tft.NumericTransformationLayer< T >	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.
CMyCaffe.layers.tft.QuantileAccuracyLayer< T >	The QuantileAccuracyLayer implements the Quantile Accuracy Layer used in TFT models.
CMyCaffe.layers.tft.ReshapeTemporalLayer< T >	The ReshapeTemporalLayer implements the Variable Selection Network
CMyCaffe.layers.tft.VarSetNetLayer< T >	The VarSetNetLayer implements the Variable Selection Network
CMyCaffe.layers.hdf5.HDF5< T >	The HDF5 object provides HDF5 dataset support to the HDF5DataLayer.
CMyCaffe.preprocessor.Extension< T >	The Extension class is used to add new pre-processor extension DLL's to MyCaffe.
CMyCaffe.preprocessor.MgrPreprocessor< T >	The MgrPreprocessor manages the operations of the data pre-processor.
CMyCaffe.python.PythonInterop	The PythonInterop uses PythonNet to execute Python code.
►CMyCaffe.solvers.Solver< T >	An interface for classes that perform optimization on Nets - this class serves as the base class for all solvers.
CMyCaffe.solvers.LBFGSSolver< T >	Optimizes the parameters of a Net using L-BFGS. This implementation is based on minFunc, by Marc Schmidt.
►CMyCaffe.solvers.SGDSolver< T >	Stochastic Gradient Descent solver with momentum updates weights by a linear combination of the negative gradient and the previous weight update.
CMyCaffe.solvers.AdaDeltaSolver< T >	Use AdaDelta Solver which has gradient based optimization like SGD.
CMyCaffe.solvers.AdaGradSolver< T >	Use AdaGrad Solver based optimization like SGD that tries to find rarely seen features.
CMyCaffe.solvers.AdamSolver< T >	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.
CMyCaffe.solvers.AdamWSolver< T >	Use AdamW Solver which uses gradient based optimization like Adam with a decoupled weight decay.
CMyCaffe.solvers.NesterovSolver< T >	Use Nesterov's accelerated gradient Solver, which is similar to SGD, but the error gradient is computed on the weights with added momentum.
CMyCaffe.solvers.RmsPropSolver< T >	Use RmsProp Solver which uses gradient based optimization like SGD.
CMyCaffe.trainers.dqn.c51.st.Brain< T >	The Brain uses the instance of MyCaffe (e.g. the open project) to run new actions and train the network.
CMyCaffe.trainers.dqn.c51.st.DqnAgent< T >	The DqnAgent both builds episodes from the envrionment and trains on them using the Brain.
CMyCaffe.trainers.dqn.c51.st.TrainerC51< T >	The TrainerC51 implements the C51-DQN algorithm as described by Bellemare et al., Google Dopamine RainboAgent and 'flyyufelix'
CMyCaffe.trainers.dqn.noisy.simple.Brain< T >	The Brain uses the instance of MyCaffe (e.g. the open project) to run new actions and train the network.
CMyCaffe.trainers.dqn.noisy.simple.DqnAgent< T >	The DqnAgent both builds episodes from the envrionment and trains on them using the Brain.
CMyCaffe.trainers.dqn.noisy.simple.TrainerNoisyDqn< T >	The TrainerNoisyDqn implements the Noisy-DQN algorithm as described by Google Dopamine DNQAgent, Gheshlagi et al. and inspired by 'higgsfield'
CMyCaffe.trainers.dqn.noisy.st.Brain< T >	The Brain uses the instance of MyCaffe (e.g. the open project) to run new actions and train the network.
CMyCaffe.trainers.dqn.noisy.st.DqnAgent< T >	The DqnAgent both builds episodes from the envrionment and trains on them using the Brain.
CMyCaffe.trainers.dqn.noisy.st.TrainerNoisyDqn< T >	The TrainerNoisyDqn implements the Noisy-DQN algorithm as described by Google Dopamine DQNAgent, Gheshlagi et al., and inspired by 'Kyushik' and 'higgsfield'
CMyCaffe.trainers.pg.mt.Agent< T >	The Agent both builds episodes from the envrionment and trains on them using the Brain.
CMyCaffe.trainers.pg.mt.Brain< T >	The Brain uses the instance of MyCaffe (e.g. the open project) to run new actions and train the network.
CMyCaffe.trainers.pg.mt.Optimizer< T >	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.
CMyCaffe.trainers.pg.mt.TrainerPG< T >	The TrainerPG implements a simple Policy Gradient trainer inspired by Andrej Karpathy's blog posed referenced.
CMyCaffe.trainers.pg.simple.TrainerPG< T >	The TrainerPG implements a simple Policy Gradient trainer inspired by Andrej Karpathy's blog posed referenced.
CMyCaffe.trainers.pg.st.TrainerPG< T >	The TrainerPG implements a simple Policy Gradient trainer inspired by Andrej Karpathy's blog posed referenced.
CMyCaffe.trainers.rnn.simple.TrainerRNN< T >	The TrainerRNN implements a simple RNN trainer inspired by adepierre's GitHub site referenced.
CMyCaffe.trainers.rnn.simple.TrainerRNNSimple< T >	The TrainerRNNSimple implements a very simple RNN trainer inspired by adepierre's GitHub site referenced.
►CIEnumerable
CMyCaffe.basecode.AnnotationGroupCollection	Defines a collection of AnnotationGroups.
CMyCaffe.basecode.BucketCollection	The BucketCollection contains a set of Buckets.
CMyCaffe.basecode.GenericList< T >	The GenericList provides a base used to implement a generic list by only implementing the minimum amount of the list functionality.
CMyCaffe.basecode.LabelMappingCollection	The LabelMappingCollection manages a collection of LabelMapping's.
CMyCaffe.basecode.PropertySet	Specifies a key-value pair of properties.
CMyCaffe.basecode.RawProtoCollection	The RawProtoCollection class is a list of RawProto objects.
CMyCaffe.basecode.SimpleDatumCollection	The SimpleDatumCollection holds a named array of SimpleDatums
CMyCaffe.basecode.descriptors.ParameterDescriptorCollection	The ParameterDescriptorCollection class contains a list of ParameterDescriptor's.
CMyCaffe.basecode.descriptors.ValueDescriptorCollection	The ValueDescriptorCollection class contains a list of ValueDescriptor's.
CMyCaffe.common.BlobCollection< T >	The BlobCollection contains a list of Blobs.
CMyCaffe.db.image.DatasetExCollection	The DatasetExCollection contains a list of DatasetEx objects.
CMyCaffe.db.image.DatasetExCollection2	[V2 Image Database] The DatasetExCollection2 contains a list of DatasetEx2 objects.
CMyCaffe.db.temporal.RawValueDataCollection	The RawValueDataCollection class is used to hold a collection of RawValueData items.
CMyCaffe.extras.DeepDraw< T >	The DeepDraw class implements both deep drawing and deep dream as originally introduced by Google.
CMyCaffe.extras.OctavesCollection	The OctavesCollection manages a list of Octaves.
CMyCaffe.gym.GymCollection	The GymCollection contains the available Gyms.
CMyCaffe.layers.tft.FieldCollection	The FieldCollection manages a collection of fields.
CMyCaffe.param.BlobProtoCollection	Specifies a collection of BlobProtos.
CMyCaffe.trainers.pg.mt.MemoryCache	Contains the best memory episodes (best by highest total rewards)
►CMyCaffe.layers.hdf5.IHDF5Load< T >	The HDF5Load interface is used to load weights into objects like a Net.
CMyCaffe.layers.hdf5.HDF5< T >	The HDF5 object provides HDF5 dataset support to the HDF5DataLayer.
►CMyCaffe.ILayerCreator	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.
CMyCaffe.layers.alpha.LayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.ssd namespace.
CMyCaffe.layers.beta.LayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.ssd namespace.
CMyCaffe.layers.gpt.LayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.gpt namespace.
CMyCaffe.layers.hdf5.LayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.ssd namespace.
CMyCaffe.layers.lnn.LayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.tft namespace.
CMyCaffe.layers.nt.LayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.ssd namespace.
CMyCaffe.layers.ssd.LayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.ssd namespace.
CMyCaffe.layers.tft.LayerFactory	The LayerFactor is responsible for creating all layers implemented in the MyCaffe.layers.tft namespace.
CMyCaffe.basecode.ImageData	The ImageData class is a helper class used to convert between Datum, other raw data, and Images such as a Bitmap.
CMyCaffe.basecode.descriptors.ImageDescriptor	The ImageDescriptor class describes a single image in the database.
CMyCaffe.basecode.ImageTools	The ImageTools class is a helper class used to manipulate image data.
CMyCaffe.data.ImageTransforms< T >	The ImageTransforms class provides several useful image transformation function used with SSD.
►CMyCaffe.trainers.common.IMemoryCollection	The IMemoryCollection interface is implemented by all memory collection types.
CMyCaffe.trainers.common.FileMemoryCollection	The FileMemoryCollection is used during debugging to load from and save to file.
CMyCaffe.trainers.common.PrioritizedMemoryCollection	The PrioritizedMemoryCollection provides a sampling based on prioritizations.
CMyCaffe.trainers.common.RandomMemoryCollection	The RandomMemoryCollection is used to randomly sample the collection of items.
►CMyCaffe.layers.gpt.InputData	The InputData is an abstract class used to get training data and tokenize input data.
CMyCaffe.layers.gpt.CustomListData	The CustomData supports external data input via an external Assembly DLL that supports the ICustomTokenInput interface.
CMyCaffe.layers.gpt.TextInputData	The TextInputData manages character data read in from a text file. Data is tokenized into indexes that reference each character within the vocabulary.
CMyCaffe.layers.gpt.TextListData	The TextListData manages parallel lists of data where the first list contains the encoder input data and the second the decoder input/target data.
►CISerializable
CMyCaffe.basecode.SettingsCaffe	The SettingsCaffe defines the settings used by the MyCaffe CaffeControl.
CMyCaffe.db.temporal.ItemSet	The ItemSet manages the data for a single item (e.g., customer, station, stock symbol, etc.) and its associated streams.
CMyCaffe.layers.beta.ModelData.IterationInfo	The IterationInfo class contains information about each iteration.
CMyCaffe.layers.beta.TextData.IterationInfo	The IterationInfo class contains information about each iteration.
CMyCaffe.basecode.ITestKnownFailures	Defines the ITest interface used by the Test module to return its known failures.
►CMyCaffe.layers.gpt.IVocabulary	The IVocabulary interface specifies the interface that all Vocabularies implement.
CMyCaffe.layers.gpt.VocabularyCharacter	The VocabularyCharacters class manages the data vocabulary of characters.
CMyCaffe.layers.gpt.VocabularySentencePiece	The VocabularySentencePieces class manages the data vocabulary of words.
CMyCaffe.layers.gpt.VocabularyWord	The VocabularyWords class manages the data vocabulary of words.
►CMyCaffe.db.stream.IXCustomQuery	The custom query interface defines the functions implemented by each Custom Query object used to specifically query the tables of the underlying database.
CMyCaffe.db.stream.StandardQueryTextFile	The StandardQueryTextFile provides queries that read text (*.txt) files residing in a given directory.
CMyCaffe.db.stream.StandardQueryWAVFile	The StandardQueryWAVFile provides queries that read sound frequencies from (*.WAV) files residing in a given directory.
►CMyCaffe.basecode.IXDatabaseBase	The IXDatabaseBase interface defines the general interface to the in-memory database.
►CMyCaffe.basecode.IXImageDatabaseBase	The IXImageDatabaseBase interface defines the general interface to the in-memory image database.
CMyCaffe.basecode.IXImageDatabase1	The IXImageDatabase interface defines the eneral interface to the in-memory image database.
CMyCaffe.basecode.IXImageDatabase2	The IXImageDatabase2 interface defines the general interface to the in-memory image database (v2).
►CMyCaffe.basecode.IXTemporalDatabaseBase	Teh IXTemporalDatabaseBase interface defines the general interface to the in-memory temporal database.
CMyCaffe.db.temporal.MyCaffeTemporalDatabase	[Temporal Database] The MyCaffeTemporalDatabase provides an enhanced in-memory temporal database used for quick temporal data retrieval.
►CMyCaffe.common.IXDebugData< T >	The IXDebugData interface is implemented by the DebugLayer to give access to the debug information managed by the layer.
CMyCaffe.layers.DebugLayer< T >	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.
►CIXImageDatabase1
CMyCaffe.db.image.MyCaffeImageDatabase	The MyCaffeImageDatabase provides an enhanced in-memory image database used for quick image retrieval.
►CIXImageDatabase2
CMyCaffe.db.image.MyCaffeImageDatabase2	[V2 Image Database] The MyCaffeImageDatabase2 provides an enhanced in-memory image database used for quick image retrieval.
►CMyCaffe.common.IXMyCaffe< T >	The IXMyCaffe interface contains functions used to perform MyCaffe operations that work with the MyCaffeImageDatabase.
CMyCaffe.MyCaffeControl< T >	The MyCaffeControl is the main object used to manage all training, testing and running of the MyCaffe system.
►CMyCaffe.trainers.IXMyCaffeCustomTrainer	The IXMyCaffeCustomTrainer interface is used by the MyCaffeCustomTraininer components that provide various training techniques such as Reinforcement Training.
►CMyCaffe.trainers.IXMyCaffeCustomTrainerRL	The IXMyCaffeCustomTrainer interface is used by the MyCaffeCustomTraininer components that provide various training techniques such as Reinforcement Training.
CMyCaffe.trainers.MyCaffeTrainerDual	The MyCaffeTraininerDual is used to perform both reinforcement and recurrent learning training tasks on an instance of the MyCaffeControl.
CMyCaffe.trainers.MyCaffeTrainerRL	(Depreciated - use MyCaffeTrainerDual instead.) The MyCaffeTraininerRL is used to perform reinforcement learning training tasks on an instance of the MyCaffeControl.
►CMyCaffe.trainers.IXMyCaffeCustomTrainerRNN	The IXMyCaffeCustomTrainer interface is used by the MyCaffeCustomTraininer components that provide various training techniques such as Reinforcement Training.
CMyCaffe.trainers.MyCaffeTrainerDual	The MyCaffeTraininerDual is used to perform both reinforcement and recurrent learning training tasks on an instance of the MyCaffeControl.
CMyCaffe.trainers.MyCaffeTrainerRNN	(Depreciated - use MyCaffeTrainerDual instead.) The MyCaffeTrainerRNN is used to perform recurrent neural-network training tasks on an instance of the MyCaffeControl.
►CMyCaffe.trainers.IXMyCaffeCustomTrainerCallback	The IXMyCaffeCustomTrainerCallback interface is used to call back to the parent running the custom trainer.
CMyCaffe.trainers.IXMyCaffeCustomTrainerCallbackRNN	The IXMyCaffeCustomTrainerCallbackRNN interface is used to call back to the parent running the custom RNN trainer.
►CMyCaffe.common.IXMyCaffeExtension< T >	The IXMyCaffeExtension interface allows for easy extension management of the low-level software that interacts directly with CUDA.
CMyCaffe.MyCaffeControl< T >	The MyCaffeControl is the main object used to manage all training, testing and running of the MyCaffe system.
►CMyCaffe.gym.IXMyCaffeGym	The IXMyCaffeGym interface is used to interact with each Gym.
CMyCaffe.gym.AtariGym	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).
CMyCaffe.gym.CartPoleGym	The CartPole Gym provides a simulation of a cart with a balancing pole standing on top of it.
CMyCaffe.gym.CurveGym	The Curve Gym provides a simulation of continuous curve such as Sin or Cos.
►CMyCaffe.gym.IXMyCaffeGymData	The IXMyCaffeGym interface is used to interact with each Gym.
CMyCaffe.gym.DataGeneralGym	The DataGeneral Gym provides access to the MyCaffe Streaming Database with GENERAL query types.
CMyCaffe.gym.ModelGym	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.
CMyCaffe.gym.IXMyCaffeGymRange	The IXMyCaffeGymRange interface is used to query the data range for the vocabulary.
►CMyCaffe.gym.IXMyCaffeGymUiCallback	The IXMyCaffeGymUiCallback is used to interact with the user of the IXMyCaffeGymUiService interface.
CMyCaffe.gym.python.MyCaffePythonGym	The MyCaffePythonGym class provides a simple interface that can easily be used from within Python.
►CMyCaffe.gym.IXMyCaffeGymUiService	The IXMYCaffeGymUiService interface provides access to the MyCaffeGymUiService used to display the visualizations of each Gym as they run.
CMyCaffe.gym.MyCaffeGymUiService	The MyCaffeGymUiService provides the service used to show the Gym visualizations.
►CMyCaffe.common.IXMyCaffeNoDb< T >	The IXMyCaffeNoDb interface contains functions used to perform MyCaffe operations that run in a light-weight manner without the MyCaffeImageDatabase.
CMyCaffe.MyCaffeControl< T >	The MyCaffeControl is the main object used to manage all training, testing and running of the MyCaffe system.
►CMyCaffe.preprocessor.IXMyCaffePreprocessor< T >	The IXPreprocessor interface is used to query pre-processed data from a streaming database.
CMyCaffe.preprocessor.MyCaffeDataPreprocessor< T >	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.
►CMyCaffe.common.IXMyCaffeState< T >	The IXMyCaffeState interface contains functions related to the MyCaffeComponent state.
CMyCaffe.MyCaffeControl< T >	The MyCaffeControl is the main object used to manage all training, testing and running of the MyCaffe system.
►CMyCaffe.common.IXPersist< T >	The IXPersist interface is used by the CaffeControl to load and save weights.
CMyCaffe.common.PersistCaffe< T >	The PersistCaffe class is used to load and save weight files in the .caffemodel format.
►CMyCaffe.db.stream.IXStreamDatabase	The IXStreamDatabase interface is the main interface to the MyCaffe Streaing Database.
CMyCaffe.db.stream.MyCaffeStreamDatabase	The MyCaffeStreamDatabase provides a streaming data input source to MyCaffe gyms used as input for dynamic, reinforcement learning.
►CMyCaffe.trainers.IxTrainer	The IxTrainer interface is implemented by each Trainer.
►CMyCaffe.trainers.IxTrainerRL	The IxTrainerRL interface is implemented by each RL Trainer.
CMyCaffe.trainers.dqn.c51.st.TrainerC51< T >	The TrainerC51 implements the C51-DQN algorithm as described by Bellemare et al., Google Dopamine RainboAgent and 'flyyufelix'
CMyCaffe.trainers.dqn.noisy.simple.TrainerNoisyDqn< T >	The TrainerNoisyDqn implements the Noisy-DQN algorithm as described by Google Dopamine DNQAgent, Gheshlagi et al. and inspired by 'higgsfield'
CMyCaffe.trainers.dqn.noisy.st.TrainerNoisyDqn< T >	The TrainerNoisyDqn implements the Noisy-DQN algorithm as described by Google Dopamine DQNAgent, Gheshlagi et al., and inspired by 'Kyushik' and 'higgsfield'
CMyCaffe.trainers.pg.mt.TrainerPG< T >	The TrainerPG implements a simple Policy Gradient trainer inspired by Andrej Karpathy's blog posed referenced.
CMyCaffe.trainers.pg.simple.TrainerPG< T >	The TrainerPG implements a simple Policy Gradient trainer inspired by Andrej Karpathy's blog posed referenced.
CMyCaffe.trainers.pg.st.TrainerPG< T >	The TrainerPG implements a simple Policy Gradient trainer inspired by Andrej Karpathy's blog posed referenced.
►CMyCaffe.trainers.IxTrainerRNN	The IxTrainerRL interface is implemented by each RL Trainer.
CMyCaffe.trainers.rnn.simple.TrainerRNN< T >	The TrainerRNN implements a simple RNN trainer inspired by adepierre's GitHub site referenced.
CMyCaffe.trainers.rnn.simple.TrainerRNNSimple< T >	The TrainerRNNSimple implements a very simple RNN trainer inspired by adepierre's GitHub site referenced.
►CMyCaffe.trainers.IxTrainerCallback	The IxTrainerCallback provides functions used by each trainer to 'call-back' to the parent for information and updates.
►CMyCaffe.trainers.IxTrainerCallbackRNN	The IxTrainerCallbackRNN provides functions used by each trainer to 'call-back' to the parent for information and updates.
CMyCaffe.trainers.MyCaffeTrainerDual	The MyCaffeTraininerDual is used to perform both reinforcement and recurrent learning training tasks on an instance of the MyCaffeControl.
CMyCaffe.trainers.MyCaffeTrainerRNN	(Depreciated - use MyCaffeTrainerDual instead.) The MyCaffeTrainerRNN is used to perform recurrent neural-network training tasks on an instance of the MyCaffeControl.
CMyCaffe.trainers.MyCaffeTrainerRL	(Depreciated - use MyCaffeTrainerDual instead.) The MyCaffeTraininerRL is used to perform reinforcement learning training tasks on an instance of the MyCaffeControl.
►CMyCaffe.trainers.IxTrainerGetDataCallback	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.
CMyCaffe.trainers.dqn.c51.st.Brain< T >	The Brain uses the instance of MyCaffe (e.g. the open project) to run new actions and train the network.
CMyCaffe.trainers.dqn.noisy.simple.Brain< T >	The Brain uses the instance of MyCaffe (e.g. the open project) to run new actions and train the network.
CMyCaffe.trainers.dqn.noisy.st.Brain< T >	The Brain uses the instance of MyCaffe (e.g. the open project) to run new actions and train the network.
CMyCaffe.basecode.LabelBBox	The LabelBBox manages a bounding box used in SSD.
CMyCaffe.db.image.LabelBoostDescriptor	The LabelBoostDescriptor class describes a label boost.
CMyCaffe.basecode.descriptors.LabelDescriptor	The LabelDescriptor class describes a single label.
CMyCaffe.param.ssd.LabelMap	Specifies the LabelMap used with SSD.
CMyCaffe.param.ssd.LabelMapItem	The LabelMapItem class stores the information for a single label.
CMyCaffe.basecode.LabelMapping	The LabelMapping class represents a single label mapping.
CMyCaffe.common.LayerDebugInformation< T >	The LayerDebugInformation describes debug information relating to a given Layer in the Net.
CMyCaffe.basecode.LockBitmap	The LockBitmap class provides very efficient SetPixel and GetPixel functionality of a bitmap by using LockBits to directly access the bitmap data.
CMyCaffe.basecode.Log	The Log class provides general output in text form.
CMyCaffe.layers.tft.Lookup	The Lookup class is used to manage a single lookup table.
CMyCaffe.layers.tft.LookupCollection	The LookupCollection class contains a collection of Lookup objects.
CMyCaffe.layers.tft.LookupItem	The lookup item manages a single lookup item used to map a name to an ID.
CMyCaffe.trainers.pg.mt.Memory	Specifies a single Memory (e.g. an episode).
CMyCaffe.trainers.common.MemoryCollection	The memory collection stores a set of memory items.
CMyCaffe.trainers.common.MemoryCollectionFactory	The MemoryCollectionFactory is used to create various memory collection types.
CMyCaffe.trainers.common.MemoryItem	The MemoryItem stores the information about a given cycle.
CMyCaffe.trainers.pg.mt.MemoryItem	The MemoryItem stores the information for one step in an episode.
CMyCaffe.db.stream.MgrQueryGeneral	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.
CMyCaffe.db.stream.MgrQueryTime	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.
CMyCaffe.data.MnistDataLoader	The MnistDataLoader is used to create the MNIST dataset and load it into the database managed by the MyCaffe Image Database.
CMyCaffe.data.MnistDataLoaderLite	The MnistDataLoader is used to extrac the MNIST dataset to disk and load the data into the training proces.
CMyCaffe.data.MnistDataParameters	Contains the dataset parameters used to create the MNIST dataset.
►CMyCaffe.model.ModelBuilder	The ModelBuilder is an abstract class that is overridden by a base class used to programically build new models.
CMyCaffe.model.ResNetModelBuilder	The ResNetModelBuilder adds the extra layers to a 'base' model for the ResNet model.
CMyCaffe.model.ResNetOctConvModelBuilder	The ResNetOctConvModelBuilder is used to build Octave Convolution based RESNET models.
CMyCaffe.model.SsdPascalModelBuilder	The SsdPascalModelBuilder adds the extra layers to a 'base' model for the Pascal model used with SSD.
CMyCaffe.model.MultiBoxHeadInfo	The MultiBoxHeadInfo contains information used to build the multi-box head of layers.
CMyCaffe.basecode.MyCaffeModelData	The MyCaffeModelData object contains the model descriptor, model weights and optionally the image mean.
CMyCaffe.basecode.NormalizedBBox	The NormalizedBBox manages a bounding box used in SSD.
CMyCaffe.gym.Observation	The Observation contains data describing the Gym as it runs.
►CMyCaffe.param.OptionalParameter	The OptionalParameter is the base class for parameters that are optional such as the MaskParameter, DistorationParameter, ExpansionParameter, NoiseParameter, and ResizeParameter.
CMyCaffe.param.DataLabelMappingParameter	Specifies the parameters for the DataLabelMappingParameter used to map labels by the DataTransformer.TransformLabel when active.
CMyCaffe.param.MaskParameter	Specifies the parameters for the MaskParameter used to mask portions of the transformed data when active.
CMyCaffe.param.ssd.DistortionParameter	Specifies the parameters for the DistortionParameter used with SSD.
CMyCaffe.param.ssd.EmitConstraint	Specifies the parameters for the EmitConstraint used with SSD.
CMyCaffe.param.ssd.ExpansionParameter	Specifies the parameters for the ExpansionParameter used with SSD.
CMyCaffe.param.ssd.NoiseParameter	Specifies the parameters for the NoiseParameter used with SSD.
CMyCaffe.param.ssd.NonMaximumSuppressionParameter	Specifies the parameters for the NonMaximumSuppressionParameter used with SSD.
CMyCaffe.param.ssd.ResizeParameter	Specifies the parameters for the ResizeParameter for use with SSD.
CMyCaffe.param.ssd.SaltPepperParameter	Specifies the parameters for the SaltPepperParameter used with SSD.
CMyCaffe.param.ssd.SaveOutputParameter	Specifies the parameters for the SaveOutputLayer.
CMyCaffe.basecode.descriptors.OrderedValueStreamDescriptorSet	The ordered value stream descriptor set is used to order the value stream descriptors by class and value type.
CMyCaffe.db.image.ParameterData	The ParameterData class is used to save and retrieve parameter data.
CMyCaffe.basecode.descriptors.ParameterDescriptor	The ParameterDescriptor class describes a parameter in the database.
CMyCaffe.db.stream.ParamPacker	The ParamPacker is use to pack and unpack parameters sent to each custom query.
►CMyCaffe.common.Params< T >	The Params contains the base parameters used in multi-GPU training.
CMyCaffe.common.GPUParams< T >	The GPUParams contains the connection to the low-level Cuda, and the stream associated with this instance.
CMyCaffe.data.ProgressInfo	The ProgressInfo is used when reporting the overall progress of creating a dataset.
CMyCaffe.basecode.ProjectEx	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.
CMyCaffe.common.Property	The Property class stores both a numeric and text value.
CMyCaffe.common.PropertyTree	The PropertyTree class implements a simple property tree similar to the ptree in Boost.
►CPython.Runtime.PyClrTypeBase	The PyClrTypeBase is the base class for other types.
CPython.Runtime.BooleanType	The BooleanType represents a clr bool type.
CPython.Runtime.DoubleType	The DoubleType represents a clr double type.
CPython.Runtime.FloatType	The FloatType represents a clr float type.
CPython.Runtime.Int32Type	The Int32Type represents a clr int type.
CPython.Runtime.Int64Type	The Int64Type represents a clr long type.
CPython.Runtime.ObjectType< T >	Convert between Python object and clr object
CPython.Runtime.PyClrType	The PyClrType class defines a Python clr type.
CPython.Runtime.PyDictType< K, V >	Specifies a PyDictionType dictionary.
CPython.Runtime.PyListType< T >	Defines a PyListType of type 'T'
CPython.Runtime.StringType	The StringType represents a clr string type.
CPython.Runtime.PyConverter	use PyConverter to convert between python object and clr object.
►CRandomNumberGenerator
CMyCaffe.basecode.CryptoRandom	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.
►CMyCaffe.layers.tft.RawData< T >	The RawData class is the base class for all raw data types.
CMyCaffe.layers.tft.RawFileData< T >	The RawFileData object is used to load raw NPY file data.
CMyCaffe.layers.tft.RawSqlData< T >	The RawSqlData class loads data from a database.
CMyCaffe.basecode.RawProto	The RawProto class is used to parse and output Google prototxt file data.
CMyCaffe.basecode.RawProtoFile	The RawProtoFile class writes and reads prototxt to and from a file.
CMyCaffe.db.temporal.RawValueData	The RawValueData class contains a single raw value item.
CMyCaffe.db.temporal.RawValueSet	The RawValueData class is used to hold the data values for an ItemID.
CMyCaffe.basecode.Result	The Result class contains a single result.
CMyCaffe.common.ResultCollection	The ResultCollection contains the result of a given CaffeControl::Run.
►CMyCaffe.trainers.common.SegmentTree	Segment tree data structure
CMyCaffe.trainers.common.MinSegmentTree	The MinSegmentTree performs a reduction over the array and returns the minimum value.
CMyCaffe.trainers.common.SumSegmentTree	The SumSegmentTree provides a sum reduction of the items within the array.
►CServiceHost
CMyCaffe.gym.MyCaffeGymUiServiceHost	The MyCaffeGymUiServiceHost provides the hosting service that listens for users of the user interface service.
►CMyCaffe.basecode.SimpleDatum	The SimpleDatum class holds a data input within host memory.
CMyCaffe.basecode.Datum	The Datum class is a simple wrapper to the SimpleDatum class to ensure compatibility with the original C++ Caffe code.
CMyCaffe.basecode.SimpleDictionary	The SimpleDictionary is a dictionary used to store a set of key/value pairs, primarily as the DICTIONARY Data Criteria type.
CMyCaffe.basecode.SimpleResult	The SimpleResult class holds the result data stored in the RawImageResults table.
CMyCaffe.basecode.SimpleTemporalDatum	The SimpleTemporalDatum is used to return temporal data
CMyCaffe.basecode.SimpleTemporalDatumCollection	The SimpleTemporalDatumCollection manages a collection of SimpleTemporalDatum objects.
CMyCaffe.common.SolverInfo< T >	The SolverInfo defines the user supplied arguments passed to each Worker.
CMyCaffe.param.SolverState	The SolverState specifies the state of a given solver.
CMyCaffe.gym.State	The State class defines an abstract base class for the state information and gym data.
CMyCaffe.trainers.StateBase	The StateBase is the base class for the state of each observation - this is defined by actual trainer that overrides the MyCaffeCustomTrainer.
CMyCaffe.basecode.TarFile	The TarFile functions are used to expand tar files.
CMyCaffe.basecode.descriptors.TemporalDescriptor	The TemporalDescriptor is used to describe a temporal aspects of the data source.
CMyCaffe.common.TransferInput	The TransferInput class is used to transfer get and set input data.
►CTypeConverter
CMyCaffe.param.ui.CsvConverter	The CsvConverter is used to display string lists on a single line in a property grid.
►CUITypeEditor
CMyCaffe.param.ui.DictionaryParamEditor	The DictionaryParamEditor is used to visually edit dictionary based parameters that are stored as a key/value set packed within a string.
►CUserControl
CMyCaffe.gym.MyCaffeGymControl	The MyCaffeGymControl displays the actual Gym visualizations.
CMyCaffe.basecode.Utility	The Utility class provides general utility funtions.
CMyCaffe.basecode.descriptors.ValueItemDescriptor	The ValueItemDescriptor describes each value item (e.g., customer, station or stock)
CMyCaffe.basecode.Valuemap	The Realmap operates similar to a bitmap but is actually just an array of doubles.
CMyCaffe.basecode.descriptors.ValueStreamDescriptor	The value stream descriptor describes a single value stream within a value item.
CMyCaffe.layers.beta.TextData.Vocabulary	The Vocabulary object manages the overall word dictionary and word to index and index to word mappings.
CMyCaffe.data.VOCDataLoader	The VOCDataLoader is used to create the VOC0712 (VOC2007 and VOC2012) dataset and load it into the database managed by the MyCaffe Image Database.
CMyCaffe.data.VOCDataParameters	Contains the dataset parameters used to create the VOC0712 dataset.
CMyCaffe.db.stream.WaveFormat	The WaveFormat structure describes the header information of a WAV file.
CMyCaffe.db.stream.WaveFormatExtensible	The WaveFormatExtensible structure describes the extended set of information of a WAV file.
CMyCaffe.db.stream.WAVProcessor	The WAVProcessor is used to process WAV files and perform tasks such as downsampling.
CMyCaffe.common.WeightInfo< T >	The WeightInfo class describes the weights of a given weight set including the blob names and sizes of the weights.
►CMyCaffe.trainers.pg.mt.Worker	The Worker class provides the base class for both the Environment and Optimizer and provides the basic threading functionality used by both.
CMyCaffe.trainers.pg.mt.Agent< T >	The Agent both builds episodes from the envrionment and trains on them using the Brain.
CMyCaffe.trainers.pg.mt.Optimizer< T >	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.
CMyCaffe.trainers.pg.mt.WorkerStartArgs	The WorkerStartArgs provides the arguments used when starting the agent thread.