mpsneuralnetwork

func (Acl_entry_id_t) String ¶

func (e Acl_entry_id_t) String() string

func (Acl_flag_t) String ¶

func (e Acl_flag_t) String() string

func (Acl_perm_t) String ¶

func (e Acl_perm_t) String() string

func (Acl_tag_t) String ¶

func (e Acl_tag_t) String() string

func (Acl_type_t) String ¶

func (e Acl_type_t) String() string

func (Clockid_t) String ¶

func (e Clockid_t) String() string

func (Dispatch_autorelease_frequency_t) String ¶

func (e Dispatch_autorelease_frequency_t) String() string

func (Dispatch_block_flags_t) String ¶

func (e Dispatch_block_flags_t) String() string

func (Filesec_property_t) String ¶

func (e Filesec_property_t) String() string

func (Idtype_t) String ¶

func (e Idtype_t) String() string

func (Ipc_info_object_type_t) String ¶

func (e Ipc_info_object_type_t) String() string

func (Launch_data_type_t) String ¶

func (e Launch_data_type_t) String() string

func (MDLabelDomain) String ¶

func (e MDLabelDomain) String() string

func (MDQueryOptionFlags) String ¶

func (e MDQueryOptionFlags) String() string

func (MDQuerySortOptionFlags) String ¶

func (e MDQuerySortOptionFlags) String() string

func (*MPSCNNAdd) InitWithDevice ¶

func (o *MPSCNNAdd) InitWithDevice(device metal.MTLDevice) *MPSCNNAdd

@abstract Initialize the addition operator. @param device The device the filter will run on. @return A valid MPSCNNAdd object or nil, if failure.

func (*MPSCNNAddGradient) InitWithDeviceIsSecondarySourceFilter ¶

func (o *MPSCNNAddGradient) InitWithDeviceIsSecondarySourceFilter(device metal.MTLDevice, isSecondarySourceFilter bool) *MPSCNNAddGradient

@abstract Initialize the addition gradient operator. @param device The device the filter will run on. @param isSecondarySourceFilter A boolean indicating whether the arithmetic gradient filter is operating on the primary or secondary source image from the forward pass. @return A valid MPSCNNAddGradient object or nil, if failure.

func (*MPSCNNArithmetic) Bias ¶

func (o *MPSCNNArithmetic) Bias() float32

func (*MPSCNNArithmetic) EncodeBatchToCommandBufferPrimaryImagesSecondaryImagesDestinationStatesDestinationImages ¶

func (o *MPSCNNArithmetic) EncodeBatchToCommandBufferPrimaryImagesSecondaryImagesDestinationStatesDestinationImages(commandBuffer metal.MTLCommandBuffer, primaryImages unsafe.Pointer, secondaryImages unsafe.Pointer, destinationStates unsafe.Pointer, destinationImages unsafe.Pointer)

@abstract Encode call that operates on a state for later consumption by a gradient kernel in training @discussion This is the older style of encode which reads the offset, doesn't change it, and ignores the padding method. Multiple images are processed concurrently. All images must have MPSImage.numberOfImages = 1. @param commandBuffer A valid MTLCommandBuffer to receive the encoded filter @param primaryImages An array of MPSImage objects containing the primary source images. @param secondaryImages An array MPSImage objects containing the secondary source images. @param destinationStates An array of MPSCNNArithmeticGradientStateBatch to be consumed by the gradient layer @param destinationImages An array of MPSImage objects to contain the result images. destinationImages may not alias primarySourceImages or secondarySourceImages in any manner.

func (*MPSCNNArithmetic) EncodeToCommandBufferPrimaryImageSecondaryImageDestinationStateDestinationImage ¶

func (o *MPSCNNArithmetic) EncodeToCommandBufferPrimaryImageSecondaryImageDestinationStateDestinationImage(commandBuffer metal.MTLCommandBuffer, primaryImage *mpscore.MPSImage, secondaryImage *mpscore.MPSImage, destinationState *MPSCNNArithmeticGradientState, destinationImage *mpscore.MPSImage)

@abstract Encode call that operates on a state for later consumption by a gradient kernel in training @discussion This is the older style of encode which reads the offset, doesn't change it, and ignores the padding method. @param commandBuffer The command buffer @param primaryImage A MPSImage to use as the source images for the filter. @param secondaryImage A MPSImage to use as the source images for the filter. @param destinationState MPSCNNArithmeticGradientState to be consumed by the gradient layer @param destinationImage A valid MPSImage to be overwritten by result image. destinationImage may not alias primarySourceImage or secondarySourceImage.

func (*MPSCNNArithmetic) MaximumValue ¶

func (o *MPSCNNArithmetic) MaximumValue() float32

@property maximumValue @abstract maximumValue is used to clamp the result of an arithmetic operation: result = clamp(result, minimumValue, maximumValue). The default value of maximumValue is FLT_MAX.

func (*MPSCNNArithmetic) MinimumValue ¶

func (o *MPSCNNArithmetic) MinimumValue() float32

@property minimumValue @abstract minimumValue is to clamp the result of an arithmetic operation: result = clamp(result, minimumValue, maximumValue). The default value of minimumValue is -FLT_MAX.

func (*MPSCNNArithmetic) PrimaryScale ¶

func (o *MPSCNNArithmetic) PrimaryScale() float32

func (*MPSCNNArithmetic) PrimaryStrideInFeatureChannels ¶

func (o *MPSCNNArithmetic) PrimaryStrideInFeatureChannels() uint

@property primaryStrideInPixels @abstract The primarySource stride in the feature channel dimension. The only supported values are 0 or 1. The default value for each dimension is 1.

func (*MPSCNNArithmetic) SecondaryScale ¶

func (o *MPSCNNArithmetic) SecondaryScale() float32

func (*MPSCNNArithmetic) SecondaryStrideInFeatureChannels ¶

func (o *MPSCNNArithmetic) SecondaryStrideInFeatureChannels() uint

@property secondaryStrideInPixels @abstract The secondarySource stride in the feature channel dimension. The only supported values are 0 or 1. The default value for each dimension is 1.

func (*MPSCNNArithmetic) SetBias ¶

func (o *MPSCNNArithmetic) SetBias(bias float32)

func (*MPSCNNArithmetic) SetMaximumValue ¶

func (o *MPSCNNArithmetic) SetMaximumValue(maximumValue float32)

func (*MPSCNNArithmetic) SetMinimumValue ¶

func (o *MPSCNNArithmetic) SetMinimumValue(minimumValue float32)

func (*MPSCNNArithmetic) SetPrimaryScale ¶

func (o *MPSCNNArithmetic) SetPrimaryScale(primaryScale float32)

func (*MPSCNNArithmetic) SetPrimaryStrideInFeatureChannels ¶

func (o *MPSCNNArithmetic) SetPrimaryStrideInFeatureChannels(primaryStrideInFeatureChannels uint)

func (*MPSCNNArithmetic) SetSecondaryScale ¶

func (o *MPSCNNArithmetic) SetSecondaryScale(secondaryScale float32)

func (*MPSCNNArithmetic) SetSecondaryStrideInFeatureChannels ¶

func (o *MPSCNNArithmetic) SetSecondaryStrideInFeatureChannels(secondaryStrideInFeatureChannels uint)

func (*MPSCNNArithmeticGradient) Bias ¶

func (o *MPSCNNArithmeticGradient) Bias() float32

func (*MPSCNNArithmeticGradient) IsSecondarySourceFilter ¶

func (o *MPSCNNArithmeticGradient) IsSecondarySourceFilter() bool

@property isSecondarySourceFilter @abstract The isSecondarySourceFilter property is used to indicate whether the arithmetic gradient filter is operating on the primary or secondary source image from the forward pass.

func (*MPSCNNArithmeticGradient) MaximumValue ¶

func (o *MPSCNNArithmeticGradient) MaximumValue() float32

@property maximumValue @abstract maximumValue is used to clamp the result of an arithmetic operation: result = clamp(result, minimumValue, maximumValue). The default value of maximumValue is FLT_MAX.

func (*MPSCNNArithmeticGradient) MinimumValue ¶

func (o *MPSCNNArithmeticGradient) MinimumValue() float32

@property minimumValue @abstract minimumValue is to clamp the result of an arithmetic operation: result = clamp(result, minimumValue, maximumValue). The default value of minimumValue is -FLT_MAX.

func (*MPSCNNArithmeticGradient) PrimaryScale ¶

func (o *MPSCNNArithmeticGradient) PrimaryScale() float32

func (*MPSCNNArithmeticGradient) SecondaryScale ¶

func (o *MPSCNNArithmeticGradient) SecondaryScale() float32

func (*MPSCNNArithmeticGradient) SecondaryStrideInFeatureChannels ¶

func (o *MPSCNNArithmeticGradient) SecondaryStrideInFeatureChannels() uint

@property secondaryStrideInPixels @abstract The secondarySource stride in the feature channel dimension. The only supported values are 0 or 1. The default value for each dimension is 1.

func (*MPSCNNArithmeticGradient) SetBias ¶

func (o *MPSCNNArithmeticGradient) SetBias(bias float32)

func (*MPSCNNArithmeticGradient) SetMaximumValue ¶

func (o *MPSCNNArithmeticGradient) SetMaximumValue(maximumValue float32)

func (*MPSCNNArithmeticGradient) SetMinimumValue ¶

func (o *MPSCNNArithmeticGradient) SetMinimumValue(minimumValue float32)

func (*MPSCNNArithmeticGradient) SetPrimaryScale ¶

func (o *MPSCNNArithmeticGradient) SetPrimaryScale(primaryScale float32)

func (*MPSCNNArithmeticGradient) SetSecondaryScale ¶

func (o *MPSCNNArithmeticGradient) SetSecondaryScale(secondaryScale float32)

func (*MPSCNNArithmeticGradient) SetSecondaryStrideInFeatureChannels ¶

func (o *MPSCNNArithmeticGradient) SetSecondaryStrideInFeatureChannels(secondaryStrideInFeatureChannels uint)

func (*MPSCNNBatchNormalization) DataSource ¶

func (o *MPSCNNBatchNormalization) DataSource() MPSCNNBatchNormalizationDataSource

@abstract The data source the batch normalization was initialized with

func (*MPSCNNBatchNormalization) EncodeBatchToCommandBufferSourceImagesBatchNormalizationStateDestinationImages ¶

func (o *MPSCNNBatchNormalization) EncodeBatchToCommandBufferSourceImagesBatchNormalizationStateDestinationImages(commandBuffer metal.MTLCommandBuffer, sourceImages unsafe.Pointer, batchNormalizationState *MPSCNNBatchNormalizationState, destinationImages unsafe.Pointer)

@abstract Encode this kernel to a command buffer for a batch of images using a batch normalization state. @param commandBuffer A valid command buffer to receive the kernel. @param sourceImages The batch of source images. @param batchNormalizationState A MPSCNNBatchNormalizationState containing weights and/or statistics to use for the batch normalization. If the state is temporary its read count will be decremented. @param destinationImages The batch of images to contain the normalized and scaled result images.

func (*MPSCNNBatchNormalization) EncodeToCommandBufferSourceImageBatchNormalizationStateDestinationImage ¶

func (o *MPSCNNBatchNormalization) EncodeToCommandBufferSourceImageBatchNormalizationStateDestinationImage(commandBuffer metal.MTLCommandBuffer, sourceImage *mpscore.MPSImage, batchNormalizationState *MPSCNNBatchNormalizationState, destinationImage *mpscore.MPSImage)

@abstract Encode this kernel to a command buffer for a single image using a batch normalization state. @param commandBuffer A valid command buffer to receive the kernel. @param sourceImage The source MPSImage. @param batchNormalizationState A MPSCNNBatchNormalizationState containing weights and/or statistics to use for the batch normalization. If the state is temporary its read count will be decremented. @param destinationImage An MPSImage to contain the resulting normalized and scaled image.

func (*MPSCNNBatchNormalization) Epsilon ¶

func (o *MPSCNNBatchNormalization) Epsilon() float32

@property epsilon @abstract The epsilon value used in the batch normalization formula to bias the variance when normalizing.

func (*MPSCNNBatchNormalization) InitWithCoderDevice ¶

func (o *MPSCNNBatchNormalization) InitWithCoderDevice(aDecoder *foundation.NSCoder, device metal.MTLDevice) *MPSCNNBatchNormalization

@abstract NSSecureCoding compatability @discussion While the standard NSSecureCoding/NSCoding method -initWithCoder: should work, since the file can't know which device your data is allocated on, we have to guess and may guess incorrectly. To avoid that problem, use a subclass of NSCoder that implements the <MPSDeviceProvider> protocol to tell MPS the MTLDevice to use. @param aDecoder The NSCoder subclass with your serialized MPSKernel @param device The MTLDevice on which to make the MPSKernel @return A new MPSCNNBatchNormalization object, or nil if failure.

func (*MPSCNNBatchNormalization) InitWithDeviceDataSource ¶

func (o *MPSCNNBatchNormalization) InitWithDeviceDataSource(device metal.MTLDevice, dataSource MPSCNNBatchNormalizationDataSource) *MPSCNNBatchNormalization

@abstract Initializes a batch normalization kernel using a data source. @param device The MTLDevice on which this filter will be used @param dataSource A pointer to a object that conforms to the MPSCNNBatchNormalizationDataSource protocol. The data source provides filter weights and bias terms and, optionally, image statistics which may be used to perform the normalization. @return A valid MPSCNNBatchNormalization object or nil, if failure.

func (*MPSCNNBatchNormalization) InitWithDeviceDataSourceFusedNeuronDescriptor ¶

func (o *MPSCNNBatchNormalization) InitWithDeviceDataSourceFusedNeuronDescriptor(device metal.MTLDevice, dataSource MPSCNNBatchNormalizationDataSource, fusedNeuronDescriptor *MPSNNNeuronDescriptor) *MPSCNNBatchNormalization

@abstract Initializes a batch normalization kernel using a data source and a neuron descriptor. @param device The MTLDevice on which this filter will be used @param dataSource A pointer to a object that conforms to the MPSCNNBatchNormalizationDataSource protocol. The data source provides filter weights and bias terms and, optionally, image statistics which may be used to perform the normalization. @param fusedNeuronDescriptor A MPSNNNeuronDescriptor object which specifies a neuron activation function to be applied to the result of the batch normalization. @return A valid MPSCNNBatchNormalization object or nil, if failure.

func (*MPSCNNBatchNormalization) NumberOfFeatureChannels ¶

func (o *MPSCNNBatchNormalization) NumberOfFeatureChannels() uint

@property numberOfFeatureChannels @abstract The number of feature channels in an image to be normalized.

func (*MPSCNNBatchNormalization) ReloadDataSource ¶

func (o *MPSCNNBatchNormalization) ReloadDataSource(dataSource MPSCNNBatchNormalizationDataSource)

@abstract Reinitialize the filter using a data source. @param dataSource The data source which will provide the weights and, optionally, the image batch statistics with which to normalize.

func (*MPSCNNBatchNormalization) ReloadGammaAndBetaFromDataSource ¶

func (o *MPSCNNBatchNormalization) ReloadGammaAndBetaFromDataSource()

@abstract Reinitialize the filter's gamma and beta values using the data source provided at kernel initialization.

func (*MPSCNNBatchNormalization) ReloadGammaAndBetaWithCommandBufferGammaAndBetaState ¶

func (o *MPSCNNBatchNormalization) ReloadGammaAndBetaWithCommandBufferGammaAndBetaState(commandBuffer metal.MTLCommandBuffer, gammaAndBetaState *MPSCNNNormalizationGammaAndBetaState)

@abstract Reload data using new gamma and beta terms contained within an MPSCNNNormalizationGammaAndBetaState object. @param commandBuffer The command buffer on which to encode the reload. @param gammaAndBetaState The state containing the updated weights which are to be reloaded.

func (*MPSCNNBatchNormalization) ReloadMeanAndVarianceFromDataSource ¶

func (o *MPSCNNBatchNormalization) ReloadMeanAndVarianceFromDataSource()

@abstract Reinitialize the filter's mean and variance values using the data source provided at kernel initialization.

func (*MPSCNNBatchNormalization) ReloadMeanAndVarianceWithCommandBufferMeanAndVarianceState ¶

func (o *MPSCNNBatchNormalization) ReloadMeanAndVarianceWithCommandBufferMeanAndVarianceState(commandBuffer metal.MTLCommandBuffer, meanAndVarianceState *MPSCNNNormalizationMeanAndVarianceState)

@abstract Reload data using new mean and variance terms contained within an MPSCNNNormalizationMeanAndVarianceState object. @param commandBuffer The command buffer on which to encode the reload. @param meanAndVarianceState The state containing the updated statistics which are to be reloaded.

func (*MPSCNNBatchNormalization) SetEpsilon ¶

func (o *MPSCNNBatchNormalization) SetEpsilon(epsilon float32)

func (MPSCNNBatchNormalizationFlags) String ¶

func (e MPSCNNBatchNormalizationFlags) String() string

func (*MPSCNNBatchNormalizationGradient) EncodeBatchToCommandBufferSourceGradientsSourceImagesBatchNormalizationState ¶

func (o *MPSCNNBatchNormalizationGradient) EncodeBatchToCommandBufferSourceGradientsSourceImagesBatchNormalizationState(commandBuffer metal.MTLCommandBuffer, sourceGradients unsafe.Pointer, sourceImages unsafe.Pointer, batchNormalizationState *MPSCNNBatchNormalizationState) unsafe.Pointer

@abstract Encode this operation to a command buffer. Create an MPSImageBatch to contain the result and return it. See encodeBatchToCommandBuffer:sourceGradients:sourceImages:batchNormalizationState:destinationGradients for further details.

func (*MPSCNNBatchNormalizationGradient) EncodeBatchToCommandBufferSourceGradientsSourceImagesBatchNormalizationStateDestinationGradients ¶

func (o *MPSCNNBatchNormalizationGradient) EncodeBatchToCommandBufferSourceGradientsSourceImagesBatchNormalizationStateDestinationGradients(commandBuffer metal.MTLCommandBuffer, sourceGradients unsafe.Pointer, sourceImages unsafe.Pointer, batchNormalizationState *MPSCNNBatchNormalizationState, destinationGradients unsafe.Pointer)

@abstract Encode this operation to a command buffer. @param commandBuffer The command buffer. @param sourceGradients An MPSImageBatch containing the gradient of the loss function with respect to the results of batch normalization on the source images. @param sourceImages An MPSImageBatch containing the source images for batch normalization. @param batchNormalizationState A valid MPSCNNBatchNormalizationState object which has been previously updated using a MPSCNNBatchNormalizationStatisticsGradient kernel and the source images. If the state is temporary its read count will be decremented. @param destinationGradients An MPSImageBatch whose images will contain the gradient of the loss function with respect to the source images.

func (*MPSCNNBatchNormalizationGradient) EncodeToCommandBufferSourceGradientSourceImageBatchNormalizationState ¶

func (o *MPSCNNBatchNormalizationGradient) EncodeToCommandBufferSourceGradientSourceImageBatchNormalizationState(commandBuffer metal.MTLCommandBuffer, sourceGradient *mpscore.MPSImage, sourceImage *mpscore.MPSImage, batchNormalizationState *MPSCNNBatchNormalizationState) *mpscore.MPSImage

@abstract Encode this operation to a command buffer. Create an MPSImage to contain the result and return it. See encodeToCommandBuffer:sourceImage:sourceGradient:sourceImage:batchNormalizationState:destinationGradient for further details.

func (*MPSCNNBatchNormalizationGradient) EncodeToCommandBufferSourceGradientSourceImageBatchNormalizationStateDestinationGradient ¶

func (o *MPSCNNBatchNormalizationGradient) EncodeToCommandBufferSourceGradientSourceImageBatchNormalizationStateDestinationGradient(commandBuffer metal.MTLCommandBuffer, sourceGradient *mpscore.MPSImage, sourceImage *mpscore.MPSImage, batchNormalizationState *MPSCNNBatchNormalizationState, destinationGradient *mpscore.MPSImage)

@abstract Encode this operation to a command buffer for a single image. @param commandBuffer The command buffer. @param sourceGradient An MPSImage containing the gradient of the loss function with respect to the results of batch normalization on the source image. @param sourceImage An MPSImage containing the source image for batch normalization. @param batchNormalizationState A valid MPSCNNBatchNormalizationState object which has been previously updated using a MPSCNNBatchNormalizationStatisticsGradient kernel and the source images. If the state is temporary its read count will be decremented. @param destinationGradient An MPSImage which contains the gradient of the loss function with respect to the source image.

func (*MPSCNNBatchNormalizationGradient) InitWithCoderDevice ¶

func (o *MPSCNNBatchNormalizationGradient) InitWithCoderDevice(aDecoder *foundation.NSCoder, device metal.MTLDevice) *MPSCNNBatchNormalizationGradient

@abstract NSSecureCoding compatability @discussion While the standard NSSecureCoding/NSCoding method -initWithCoder: should work, since the file can't know which device your data is allocated on, we have to guess and may guess incorrectly. To avoid that problem, use a subclass of NSCoder that implements the <MPSDeviceProvider> protocol to tell MPS the MTLDevice to use. @param aDecoder The NSCoder subclass with your serialized MPSKernel @param device The MTLDevice on which to make the MPSKernel @return A new MPSCNNBatchNormalizationGradient object, or nil if failure.

func (*MPSCNNBatchNormalizationGradient) InitWithDeviceFusedNeuronDescriptor ¶

func (o *MPSCNNBatchNormalizationGradient) InitWithDeviceFusedNeuronDescriptor(device metal.MTLDevice, fusedNeuronDescriptor *MPSNNNeuronDescriptor) *MPSCNNBatchNormalizationGradient

@abstract Initializes a batch normalization gradient kernel using a device and neuron descriptor. @param device The MTLDevice on which this filter will be used @param fusedNeuronDescriptor A MPSNNNeuronDescriptor object which specifies a neuron activation function whose gradient should be applied prior to computing the resulting gradient. This neuron descriptor should match that used in the corresponding forward batch normalization kernel as well as the preceeding batch normalization statistics gradient kernel. @return A valid MPSCNNBatchNormalizationGradient object or nil, if failure.

func (*MPSCNNBatchNormalizationGradientNode) InitWithSourceGradientSourceImageGradientState ¶

func (o *MPSCNNBatchNormalizationGradientNode) InitWithSourceGradientSourceImageGradientState(sourceGradient *MPSNNImageNode, sourceImage *MPSNNImageNode, gradientState *MPSNNGradientStateNode) *MPSCNNBatchNormalizationGradientNode

func (*MPSCNNBatchNormalizationNode) Flags ¶

func (o *MPSCNNBatchNormalizationNode) Flags() MPSCNNBatchNormalizationFlags

@abstract Options controlling how batch normalization is calculated @discussion Default: MPSCNNBatchNormalizationFlagsDefault

func (*MPSCNNBatchNormalizationNode) InitWithSourceDataSource ¶

func (o *MPSCNNBatchNormalizationNode) InitWithSourceDataSource(source *MPSNNImageNode, dataSource MPSCNNBatchNormalizationDataSource) *MPSCNNBatchNormalizationNode

func (*MPSCNNBatchNormalizationNode) SetFlags ¶

func (o *MPSCNNBatchNormalizationNode) SetFlags(flags MPSCNNBatchNormalizationFlags)

func (*MPSCNNBatchNormalizationNode) SetTrainingStyle ¶

func (o *MPSCNNBatchNormalizationNode) SetTrainingStyle(trainingStyle MPSNNTrainingStyle)

@abstract The training style of the forward node will be propagated to gradient nodes made from it

func (*MPSCNNBatchNormalizationNode) TrainingStyle ¶

func (o *MPSCNNBatchNormalizationNode) TrainingStyle() MPSNNTrainingStyle

@abstract The training style of the forward node will be propagated to gradient nodes made from it

func (*MPSCNNBatchNormalizationState) BatchNormalization ¶

func (o *MPSCNNBatchNormalizationState) BatchNormalization() *MPSCNNBatchNormalization

func (*MPSCNNBatchNormalizationState) Beta ¶

func (o *MPSCNNBatchNormalizationState) Beta() metal.MTLBuffer

@abstract Return an MTLBuffer object with the state's current beta values..

func (*MPSCNNBatchNormalizationState) Gamma ¶

func (o *MPSCNNBatchNormalizationState) Gamma() metal.MTLBuffer

@abstract Return an MTLBuffer object with the state's current gamma values.

func (*MPSCNNBatchNormalizationState) GradientForBeta ¶

func (o *MPSCNNBatchNormalizationState) GradientForBeta() metal.MTLBuffer

@abstract Return an MTLBuffer object containing the values of the gradient of the loss function with respect to the bias terms. If a MPSCNNBatchNormalizationGradient kernel has not successfully generated these values nil will be returned.

func (*MPSCNNBatchNormalizationState) GradientForGamma ¶

func (o *MPSCNNBatchNormalizationState) GradientForGamma() metal.MTLBuffer

@abstract Return an MTLBuffer object containing the values of the gradient of the loss function with respect to the scale factors. If a MPSCNNBatchNormalizationGradient kernel has not successfully generated these values nil will be returned.

func (*MPSCNNBatchNormalizationState) Mean ¶

func (o *MPSCNNBatchNormalizationState) Mean() metal.MTLBuffer

@abstract Return an MTLBuffer object with the most recently computed batch mean values.

func (*MPSCNNBatchNormalizationState) Reset ¶

func (o *MPSCNNBatchNormalizationState) Reset()

@abstract Reset any accumulated state data to its initial values.

func (*MPSCNNBatchNormalizationState) Variance ¶

func (o *MPSCNNBatchNormalizationState) Variance() metal.MTLBuffer

@abstract Return an MTLBuffer object with the most recently computed batch variance values.

func (*MPSCNNBatchNormalizationStatistics) EncodeBatchToCommandBufferSourceImagesBatchNormalizationState ¶

func (o *MPSCNNBatchNormalizationStatistics) EncodeBatchToCommandBufferSourceImagesBatchNormalizationState(commandBuffer metal.MTLCommandBuffer, sourceImages unsafe.Pointer, batchNormalizationState *MPSCNNBatchNormalizationState)

@abstract Encode this operation to a command buffer. @param commandBuffer The command buffer. @param sourceImages An MPSImageBatch containing the source images. @param batchNormalizationState A valid MPSCNNBatchNormalizationState object which will be updated with the image batch statistics.

func (*MPSCNNBatchNormalizationStatistics) InitWithCoderDevice ¶

func (o *MPSCNNBatchNormalizationStatistics) InitWithCoderDevice(aDecoder *foundation.NSCoder, device metal.MTLDevice) *MPSCNNBatchNormalizationStatistics

@abstract NSSecureCoding compatability @discussion While the standard NSSecureCoding/NSCoding method -initWithCoder: should work, since the file can't know which device your data is allocated on, we have to guess and may guess incorrectly. To avoid that problem, use initWithCoder:device instead. @param aDecoder The NSCoder subclass with your serialized MPSKernel @param device The MTLDevice on which to make the MPSKernel @return A new MPSCNNBatchNormalizationStatistics object, or nil if failure.

func (*MPSCNNBatchNormalizationStatistics) InitWithDevice ¶

func (o *MPSCNNBatchNormalizationStatistics) InitWithDevice(device metal.MTLDevice) *MPSCNNBatchNormalizationStatistics

@abstract Initialize this kernel on a device. @param device The MTLDevice on which to initialize the kernel.

func (*MPSCNNBatchNormalizationStatisticsGradient) EncodeBatchToCommandBufferSourceGradientsSourceImagesBatchNormalizationState ¶

func (o *MPSCNNBatchNormalizationStatisticsGradient) EncodeBatchToCommandBufferSourceGradientsSourceImagesBatchNormalizationState(commandBuffer metal.MTLCommandBuffer, sourceGradients unsafe.Pointer, sourceImages unsafe.Pointer, batchNormalizationState *MPSCNNBatchNormalizationState)

@abstract Encode this operation to a command buffer. @param commandBuffer The command buffer. @param sourceGradients An MPSImageBatch containing the gradient of the loss function with respect to the results of batch normalization on the source images. @param sourceImages An MPSImageBatch containing the source images for batch normalization. @param batchNormalizationState A valid MPSCNNBatchNormalizationState object which has been previously updated using a MPSCNNBatchNormalizationStatistics kernel and the source images. Upon completion of the command buffer, will contain the (possibly partially updated) gradients for the loss function with respect to the scale and bias parameters used to compute the batch normalization. The state will be considered to be completely updated when all MPSImages in the training batch have been processed. If the state is temporary its read count will be decremented.

func (*MPSCNNBatchNormalizationStatisticsGradient) InitWithCoderDevice ¶

func (o *MPSCNNBatchNormalizationStatisticsGradient) InitWithCoderDevice(aDecoder *foundation.NSCoder, device metal.MTLDevice) *MPSCNNBatchNormalizationStatisticsGradient

@abstract NSSecureCoding compatability @discussion While the standard NSSecureCoding/NSCoding method -initWithCoder: should work, since the file can't know which device your data is allocated on, we have to guess and may guess incorrectly. To avoid that problem, use a subclass of NSCoder that implements the <MPSDeviceProvider> protocol to tell MPS the MTLDevice to use. @param aDecoder The NSCoder subclass with your serialized MPSKernel @param device The MTLDevice on which to make the MPSKernel @return A new MPSCNNBatchNormalizationStatisticsGradient object, or nil if failure.

func (*MPSCNNBatchNormalizationStatisticsGradient) InitWithDeviceFusedNeuronDescriptor ¶

func (o *MPSCNNBatchNormalizationStatisticsGradient) InitWithDeviceFusedNeuronDescriptor(device metal.MTLDevice, fusedNeuronDescriptor *MPSNNNeuronDescriptor) *MPSCNNBatchNormalizationStatisticsGradient

@abstract Initializes a batch normalization statistics gradient kernel using a device and neuron descriptor. @param device The MTLDevice on which this filter will be used @param fusedNeuronDescriptor A MPSNNNeuronDescriptor object which specifies a neuron activation function whose gradient should be applied prior to computing the statistics of the input gradient. This neuron descriptor should match that used in the corresponding forward batch normalization kernel. @return A valid MPSCNNBatchNormalizationStatisticsGradient object or nil, if failure.

func (*MPSCNNBinaryConvolution) InitWithCoderDevice ¶

func (o *MPSCNNBinaryConvolution) InitWithCoderDevice(aDecoder *foundation.NSCoder, device metal.MTLDevice) *MPSCNNBinaryConvolution

@abstract NSSecureCoding compatability @discussion While the standard NSSecureCoding/NSCoding method -initWithCoder: should work, since the file can't know which device your data is allocated on, we have to guess and may guess incorrectly. To avoid that problem, use initWithCoder:device instead. @param aDecoder The NSCoder subclass with your serialized MPSKernel @param device The MTLDevice on which to make the MPSKernel @return A new MPSKernel object, or nil if failure.

func (*MPSCNNBinaryConvolution) InitWithDeviceConvolutionDataOutputBiasTermsOutputScaleTermsInputBiasTermsInputScaleTermsTypeFlags ¶

func (o *MPSCNNBinaryConvolution) InitWithDeviceConvolutionDataOutputBiasTermsOutputScaleTermsInputBiasTermsInputScaleTermsTypeFlags(device metal.MTLDevice, convolutionData MPSCNNConvolutionDataSource, outputBiasTerms *float32, outputScaleTerms *float32, inputBiasTerms *float32, inputScaleTerms *float32, type_ MPSCNNBinaryConvolutionType, flags MPSCNNBinaryConvolutionFlags) *MPSCNNBinaryConvolution

@abstract Initializes a binary convolution kernel with binary weights as well as both pre and post scaling terms. @param device The MTLDevice on which this MPSCNNBinaryConvolution filter will be used @param convolutionData A pointer to a object that conforms to the MPSCNNConvolutionDataSource protocol. The MPSCNNConvolutionDataSource protocol declares the methods that an instance of MPSCNNBinaryConvolution uses to obtain the weights and the convolution descriptor. Each entry in the convolutionData:weights array is a 32-bit unsigned integer value and each bit represents one filter weight (given in machine byte order). The featurechannel indices increase from the least significant bit within the 32-bits. The number of entries is = ceil( inputFeatureChannels/32.0 ) * outputFeatureChannels * kernelHeight * kernelWidth The layout of filter weight is so that it can be reinterpreted as a 4D tensor (array) weight[ outputChannels ][ kernelHeight ][ kernelWidth ][ ceil( inputChannels / 32.0 ) ] (The ordering of the reduction from 4D tensor to 1D is per C convention. The index based on inputchannels varies most rapidly, followed by kernelWidth, then kernelHeight and finally outputChannels varies least rapidly.) @param outputBiasTerms A pointer to bias terms to be applied to the convolution output. Each entry is a float value. The number of entries is = numberOfOutputFeatureMaps. If nil then 0.0 is used for bias. The values stored in the pointer are copied in and the array can be freed after this function returns. @param outputScaleTerms A pointer to scale terms to be applied to binary convolution results per output feature channel. Each entry is a float value. The number of entries is = numberOfOutputFeatureMaps. If nil then 1.0 is used. The values stored in the pointer are copied in and the array can be freed after this function returns. @param inputBiasTerms A pointer to offset terms to be applied to the input before convolution and before input scaling. Each entry is a float value. The number of entries is 'inputFeatureChannels'. If NULL then 0.0 is used for bias. The values stored in the pointer are copied in and the array can be freed after this function returns. @param inputScaleTerms A pointer to scale terms to be applied to the input before convolution, but after input biasing. Each entry is a float value. The number of entries is 'inputFeatureChannels'. If nil then 1.0 is used. The values stored in the pointer are copied in and the array can be freed after this function returns. @param type What kind of binarization strategy is to be used. @param flags See documentation above and documentation of MPSCNNBinaryConvolutionFlags. @return A valid MPSCNNBinaryConvolution object or nil, if failure.

func (*MPSCNNBinaryConvolution) InitWithDeviceConvolutionDataScaleValueTypeFlags ¶

func (o *MPSCNNBinaryConvolution) InitWithDeviceConvolutionDataScaleValueTypeFlags(device metal.MTLDevice, convolutionData MPSCNNConvolutionDataSource, scaleValue float32, type_ MPSCNNBinaryConvolutionType, flags MPSCNNBinaryConvolutionFlags) *MPSCNNBinaryConvolution

@abstract Initializes a binary convolution kernel with binary weights and a single scaling term. @param device The MTLDevice on which this MPSCNNBinaryConvolution filter will be used @param convolutionData A pointer to a object that conforms to the MPSCNNConvolutionDataSource protocol. The MPSCNNConvolutionDataSource protocol declares the methods that an instance of MPSCNNBinaryConvolution uses to obtain the weights and bias terms as well as the convolution descriptor. Each entry in the convolutionData:weights array is a 32-bit unsigned integer value and each bit represents one filter weight (given in machine byte order). The featurechannel indices increase from the least significant bit within the 32-bits. The number of entries is = ceil( inputFeatureChannels/32.0 ) * outputFeatureChannels * kernelHeight * kernelWidth The layout of filter weight is so that it can be reinterpreted as a 4D tensor (array) weight[ outputChannels ][ kernelHeight ][ kernelWidth ][ ceil( inputChannels / 32.0 ) ] (The ordering of the reduction from 4D tensor to 1D is per C convention. The index based on inputchannels varies most rapidly, followed by kernelWidth, then kernelHeight and finally outputChannels varies least rapidly.) @param scaleValue A floating point value used to scale the entire convolution. @param type What kind of binarization strategy is to be used. @param flags See documentation above and documentation of MPSCNNBinaryConvolutionFlags. @return A valid MPSCNNBinaryConvolution object or nil, if failure.

func (*MPSCNNBinaryConvolution) InputFeatureChannels ¶

func (o *MPSCNNBinaryConvolution) InputFeatureChannels() uint

func (*MPSCNNBinaryConvolution) OutputFeatureChannels ¶

func (o *MPSCNNBinaryConvolution) OutputFeatureChannels() uint

@property outputFeatureChannels @abstract The number of feature channels per pixel in the output image.

func (MPSCNNBinaryConvolutionFlags) String ¶

func (e MPSCNNBinaryConvolutionFlags) String() string

func (*MPSCNNBinaryConvolutionNode) InitWithSourceWeightsOutputBiasTermsOutputScaleTermsInputBiasTermsInputScaleTermsTypeFlags ¶

func (o *MPSCNNBinaryConvolutionNode) InitWithSourceWeightsOutputBiasTermsOutputScaleTermsInputBiasTermsInputScaleTermsTypeFlags(sourceNode *MPSNNImageNode, weights MPSCNNConvolutionDataSource, outputBiasTerms *float32, outputScaleTerms *float32, inputBiasTerms *float32, inputScaleTerms *float32, type_ MPSCNNBinaryConvolutionType, flags MPSCNNBinaryConvolutionFlags) *MPSCNNBinaryConvolutionNode

@abstract Init a node representing a MPSCNNBinaryConvolution kernel @param sourceNode The MPSNNImageNode representing the source MPSImage for the filter @param weights A pointer to a valid object conforming to the MPSCNNConvolutionDataSource protocol. This object is provided by you to encapsulate storage for convolution weights and biases. @param outputBiasTerms A pointer to bias terms to be applied to the convolution output. See MPSCNNBinaryConvolution for more details. @param outputScaleTerms A pointer to scale terms to be applied to binary convolution results per output feature channel. See MPSCNNBinaryConvolution for more details. @param inputBiasTerms A pointer to offset terms to be applied to the input before convolution and before input scaling. See MPSCNNBinaryConvolution for more details. @param inputScaleTerms A pointer to scale terms to be applied to the input before convolution, but after input biasing. See MPSCNNBinaryConvolution for more details. @param type What kind of binarization strategy is to be used. @param flags See documentation of MPSCNNBinaryConvolutionFlags. @return A new MPSNNFilter node for a MPSCNNBinaryConvolution kernel.

func (*MPSCNNBinaryConvolutionNode) InitWithSourceWeightsScaleValueTypeFlags ¶

func (o *MPSCNNBinaryConvolutionNode) InitWithSourceWeightsScaleValueTypeFlags(sourceNode *MPSNNImageNode, weights MPSCNNConvolutionDataSource, scaleValue float32, type_ MPSCNNBinaryConvolutionType, flags MPSCNNBinaryConvolutionFlags) *MPSCNNBinaryConvolutionNode

@abstract Init a node representing a MPSCNNBinaryConvolution kernel @param sourceNode The MPSNNImageNode representing the source MPSImage for the filter @param weights A pointer to a valid object conforming to the MPSCNNConvolutionDataSource protocol. This object is provided by you to encapsulate storage for convolution weights and biases. @param scaleValue A floating point value used to scale the entire convolution. @param type What kind of binarization strategy is to be used. @param flags See documentation of MPSCNNBinaryConvolutionFlags. @return A new MPSNNFilter node for a MPSCNNBinaryConvolution kernel.

func (MPSCNNBinaryConvolutionType) String ¶

func (e MPSCNNBinaryConvolutionType) String() string

func (*MPSCNNBinaryFullyConnected) InitWithCoderDevice ¶

func (o *MPSCNNBinaryFullyConnected) InitWithCoderDevice(aDecoder *foundation.NSCoder, device metal.MTLDevice) *MPSCNNBinaryFullyConnected

@abstract NSSecureCoding compatability @discussion While the standard NSSecureCoding/NSCoding method -initWithCoder: should work, since the file can't know which device your data is allocated on, we have to guess and may guess incorrectly. To avoid that problem, use initWithCoder:device instead. @param aDecoder The NSCoder subclass with your serialized MPSKernel @param device The MTLDevice on which to make the MPSKernel @return A new MPSKernel object, or nil if failure.

func (*MPSCNNBinaryFullyConnected) InitWithDeviceConvolutionDataOutputBiasTermsOutputScaleTermsInputBiasTermsInputScaleTermsTypeFlags ¶

func (o *MPSCNNBinaryFullyConnected) InitWithDeviceConvolutionDataOutputBiasTermsOutputScaleTermsInputBiasTermsInputScaleTermsTypeFlags(device metal.MTLDevice, convolutionData MPSCNNConvolutionDataSource, outputBiasTerms *float32, outputScaleTerms *float32, inputBiasTerms *float32, inputScaleTerms *float32, type_ MPSCNNBinaryConvolutionType, flags MPSCNNBinaryConvolutionFlags) *MPSCNNBinaryFullyConnected

@abstract Initializes a binary fully connected kernel with binary weights as well as both pre and post scaling terms. @param device The MTLDevice on which this MPSCNNBinaryFullyConnected filter will be used @param convolutionData A pointer to a object that conforms to the MPSCNNConvolutionDataSource protocol. The MPSCNNConvolutionDataSource protocol declares the methods that an instance of MPSCNNBinaryFullyConnected uses to obtain the weights and the convolution descriptor. Each entry in the convolutionData:weights array is a 32-bit unsigned integer value and each bit represents one filter weight (given in machine byte order). The featurechannel indices increase from the least significant bit within the 32-bits. The number of entries is = ceil( inputFeatureChannels/32.0 ) * outputFeatureChannels * kernelHeight * kernelWidth The layout of filter weight is so that it can be reinterpreted as a 4D tensor (array) weight[ outputChannels ][ kernelHeight ][ kernelWidth ][ ceil( inputChannels / 32.0 ) ] (The ordering of the reduction from 4D tensor to 1D is per C convention. The index based on inputchannels varies most rapidly, followed by kernelWidth, then kernelHeight and finally outputChannels varies least rapidly.) @param outputBiasTerms A pointer to bias terms to be applied to the convolution output. Each entry is a float value. The number of entries is = numberOfOutputFeatureMaps. If nil then 0.0 is used for bias. The values stored in the pointer are copied in and the array can be freed after this function returns. @param outputScaleTerms A pointer to scale terms to be applied to binary convolution results per output feature channel. Each entry is a float value. The number of entries is = numberOfOutputFeatureMaps. If nil then 1.0 is used. The values stored in the pointer are copied in and the array can be freed after this function returns. @param inputBiasTerms A pointer to offset terms to be applied to the input before convolution and before input scaling. Each entry is a float value. The number of entries is 'inputFeatureChannels'. If NULL then 0.0 is used for bias. The values stored in the pointer are copied in and the array can be freed after this function returns. @param inputScaleTerms A pointer to scale terms to be applied to the input before convolution, but after input biasing. Each entry is a float value. The number of entries is 'inputFeatureChannels'. If nil then 1.0 is used. The values stored in the pointer are copied in and the array can be freed after this function returns. @param type What kind of binarization strategy is to be used. @param flags See documentation above and documentation of MPSCNNBinaryConvolutionFlags. @return A valid MPSCNNBinaryFullyConnected object or nil, if failure.

func (*MPSCNNBinaryFullyConnected) InitWithDeviceConvolutionDataScaleValueTypeFlags ¶

func (o *MPSCNNBinaryFullyConnected) InitWithDeviceConvolutionDataScaleValueTypeFlags(device metal.MTLDevice, convolutionData MPSCNNConvolutionDataSource, scaleValue float32, type_ MPSCNNBinaryConvolutionType, flags MPSCNNBinaryConvolutionFlags) *MPSCNNBinaryFullyConnected

@abstract Initializes a binary fully connected kernel with binary weights and a single scaling term. @param device The MTLDevice on which this MPSCNNBinaryFullyConnected filter will be used @param convolutionData A pointer to a object that conforms to the MPSCNNConvolutionDataSource protocol. The MPSCNNConvolutionDataSource protocol declares the methods that an instance of MPSCNNBinaryFullyConnected uses to obtain the weights and bias terms as well as the convolution descriptor. Each entry in the convolutionData:weights array is a 32-bit unsigned integer value and each bit represents one filter weight (given in machine byte order). The featurechannel indices increase from the least significant bit within the 32-bits. The number of entries is = ceil( inputFeatureChannels/32.0 ) * outputFeatureChannels * kernelHeight * kernelWidth The layout of filter weight is so that it can be reinterpreted as a 4D tensor (array) weight[ outputChannels ][ kernelHeight ][ kernelWidth ][ ceil( inputChannels / 32.0 ) ] (The ordering of the reduction from 4D tensor to 1D is per C convention. The index based on inputchannels varies most rapidly, followed by kernelWidth, then kernelHeight and finally outputChannels varies least rapidly.) @param scaleValue A single floating point value used to scale the entire convolution. Each entry is a float value. The number of entries is 'inputFeatureChannels'. If nil then 1.0 is used. @param type What kind of binarization strategy is to be used. @param flags See documentation above and documentation of MPSCNNBinaryConvolutionFlags. @return A valid MPSCNNBinaryFullyConnected object or nil, if failure.

func (*MPSCNNBinaryFullyConnectedNode) InitWithSourceWeightsOutputBiasTermsOutputScaleTermsInputBiasTermsInputScaleTermsTypeFlags ¶

func (o *MPSCNNBinaryFullyConnectedNode) InitWithSourceWeightsOutputBiasTermsOutputScaleTermsInputBiasTermsInputScaleTermsTypeFlags(sourceNode *MPSNNImageNode, weights MPSCNNConvolutionDataSource, outputBiasTerms *float32, outputScaleTerms *float32, inputBiasTerms *float32, inputScaleTerms *float32, type_ MPSCNNBinaryConvolutionType, flags MPSCNNBinaryConvolutionFlags) *MPSCNNBinaryFullyConnectedNode

@abstract Init a node representing a MPSCNNBinaryFullyConnected kernel @param sourceNode The MPSNNImageNode representing the source MPSImage for the filter @param weights A pointer to a valid object conforming to the MPSCNNConvolutionDataSource protocol. This object is provided by you to encapsulate storage for convolution weights and biases. @param outputBiasTerms A pointer to bias terms to be applied to the convolution output. See MPSCNNBinaryConvolution for more details. @param outputScaleTerms A pointer to scale terms to be applied to binary convolution results per output feature channel. See MPSCNNBinaryConvolution for more details. @param inputBiasTerms A pointer to offset terms to be applied to the input before convolution and before input scaling. See MPSCNNBinaryConvolution for more details. @param inputScaleTerms A pointer to scale terms to be applied to the input before convolution, but after input biasing. See MPSCNNBinaryConvolution for more details. @param type What kind of binarization strategy is to be used. @param flags See documentation of MPSCNNBinaryConvolutionFlags. @return A new MPSNNFilter node for a MPSCNNBinaryFullyConnected kernel.

func (*MPSCNNBinaryFullyConnectedNode) InitWithSourceWeightsScaleValueTypeFlags ¶

func (o *MPSCNNBinaryFullyConnectedNode) InitWithSourceWeightsScaleValueTypeFlags(sourceNode *MPSNNImageNode, weights MPSCNNConvolutionDataSource, scaleValue float32, type_ MPSCNNBinaryConvolutionType, flags MPSCNNBinaryConvolutionFlags) *MPSCNNBinaryFullyConnectedNode

@abstract Init a node representing a MPSCNNBinaryFullyConnected kernel @param sourceNode The MPSNNImageNode representing the source MPSImage for the filter @param weights A pointer to a valid object conforming to the MPSCNNConvolutionDataSource protocol. This object is provided by you to encapsulate storage for convolution weights and biases. @param scaleValue A floating point value used to scale the entire convolution. @param type What kind of binarization strategy is to be used. @param flags See documentation of MPSCNNBinaryConvolutionFlags. @return A new MPSNNFilter node for a MPSCNNBinaryFullyConnected kernel.

func (*MPSCNNBinaryKernel) AppendBatchBarrier ¶

func (o *MPSCNNBinaryKernel) AppendBatchBarrier() bool

@abstract Returns YES if the filter must be run over the entire batch before its results may be considered complete @discussion The MPSNNGraph may split batches into sub-batches to save memory. However, some filters, like batch statistics calculations, need to operate over the entire batch to calculate a valid result, in this case, the mean and variance per channel over the set of images. In such cases, the accumulated result is commonly stored in a MPSState containing a MTLBuffer. (MTLTextures may not be able to be read from and written to in the same filter on some devices.) -isResultStateReusedAcrossBatch is set to YES, so that the state is allocated once and passed in for each sub-batch and the filter accumulates its results into it, one sub-batch at a time. Note that sub-batches may frequently be as small as 1. Default: NO

func (*MPSCNNBinaryKernel) BatchEncodingStorageSizeForPrimaryImageSecondaryImageSourceStatesDestinationImage ¶

func (o *MPSCNNBinaryKernel) BatchEncodingStorageSizeForPrimaryImageSecondaryImageSourceStatesDestinationImage(primaryImage unsafe.Pointer, secondaryImage unsafe.Pointer, sourceStates *foundation.NSArray[objc.ID], destinationImage unsafe.Pointer) uint

@abstract The size of extra MPS heap storage allocated while the kernel is encoding a batch @discussion This is best effort and just describes things that are likely to end up on the MPS heap. It does not describe all allocation done by the -encode call. It is intended for use with high water calculations for MTLHeap sizing. Allocations are typically for temporary storage needed for multipass algorithms. This interface should not be used to detect multipass algorithms.

func (*MPSCNNBinaryKernel) ClipRect ¶

func (o *MPSCNNBinaryKernel) ClipRect() metal.MTLRegion

@property clipRect @abstract An optional clip rectangle to use when writing data. Only the pixels in the rectangle will be overwritten. @discussion A MTLRegion that indicates which part of the destination to overwrite. If the clipRect does not lie completely within the destination image, the intersection between clip rectangle and destination bounds is used. Default: MPSRectNoClip (MPSKernel::MPSRectNoClip) indicating the entire image. clipRect.origin.z is the index of starting destination image in batch processing mode. clipRect.size.depth is the number of images to process in batch processing mode. See Also: @ref subsubsection_clipRect

func (*MPSCNNBinaryKernel) DestinationFeatureChannelOffset ¶

func (o *MPSCNNBinaryKernel) DestinationFeatureChannelOffset() uint

@property destinationFeatureChannelOffset @abstract The number of channels in the destination MPSImage to skip before writing output. @discussion This is the starting offset into the destination image in the feature channel dimension at which destination data is written. This allows an application to pass a subset of all the channels in MPSImage as output of MPSKernel. E.g. Suppose MPSImage has 24 channels and a MPSKernel outputs 8 channels. If we want channels 8 to 15 of this MPSImage to be used as output, we can set destinationFeatureChannelOffset = 8. Note that this offset applies independently to each image when the MPSImage is a container for multiple images and the MPSCNNKernel is processing multiple images (clipRect.size.depth > 1). The default value is 0 and any value specifed shall be a multiple of 4. If MPSKernel outputs N channels, destination image MUST have at least destinationFeatureChannelOffset + N channels. Using a destination image with insufficient number of feature channels result in an error. E.g. if the MPSCNNConvolution outputs 32 channels, and destination has 64 channels, then it is an error to set destinationFeatureChannelOffset > 32.

func (*MPSCNNBinaryKernel) DestinationImageAllocator ¶

func (o *MPSCNNBinaryKernel) DestinationImageAllocator() mpscore.MPSImageAllocator

@abstract Method to allocate the result image for -encodeToCommandBuffer:sourceImage: @discussion Default: MPSTemporaryImage.defaultAllocator

func (*MPSCNNBinaryKernel) DestinationImageDescriptorForSourceImagesSourceStates ¶

func (o *MPSCNNBinaryKernel) DestinationImageDescriptorForSourceImagesSourceStates(sourceImages *foundation.NSArray[*mpscore.MPSImage], sourceStates *foundation.NSArray[*mpscore.MPSState]) *mpscore.MPSImageDescriptor

@abstract Get a suggested destination image descriptor for a source image @discussion Your application is certainly free to pass in any destinationImage it likes to encodeToCommandBuffer:sourceImage:destinationImage, within reason. This is the basic design for iOS 10. This method is therefore not required. However, calculating the MPSImage size and MPSCNNBinaryKernel properties for each filter can be tedious and complicated work, so this method is made available to automate the process. The application may modify the properties of the descriptor before a MPSImage is made from it, so long as the choice is sensible for the kernel in question. Please see individual kernel descriptions for restrictions. The expected timeline for use is as follows: 1) This method is called: a) The default MPS padding calculation is applied. It uses the MPSNNPaddingMethod of the .padding property to provide a consistent addressing scheme over the graph. It creates the MPSImageDescriptor and adjusts the .offset property of the MPSNNKernel. When using a MPSNNGraph, the padding is set using the MPSNNFilterNode as a proxy. b) This method may be overridden by MPSCNNBinaryKernel subclass to achieve any customization appropriate to the object type. c) Source states are then applied in order. These may modify the descriptor and may update other object properties. See: -destinationImageDescriptorForSourceImages:sourceStates: forKernel:suggestedDescriptor: This is the typical way in which MPS may attempt to influence the operation of its kernels. d) If the .padding property has a custom padding policy method of the same name, it is called. Similarly, it may also adjust the descriptor and any MPSCNNBinaryKernel properties. This is the typical way in which your application may attempt to influence the operation of the MPS kernels. 2) A result is returned from this method and the caller may further adjust the descriptor and kernel properties directly. 3) The caller uses the descriptor to make a new MPSImage to use as the destination image for the -encode call in step 5. 4) The caller calls -resultStateForSourceImage:sourceStates:destinationImage: to make any result states needed for the kernel. If there isn't one, it will return nil. A variant is available to return a temporary state instead. 5) a -encode method is called to encode the kernel. The entire process 1-5 is more simply achieved by just calling an -encode... method that returns a MPSImage out the left hand sid of the method. Simpler still, use the MPSNNGraph to coordinate the entire process from end to end. Opportunities to influence the process are of course reduced, as (2) is no longer possible with either method. Your application may opt to use the five step method if it requires greater customization as described, or if it would like to estimate storage in advance based on the sum of MPSImageDescriptors before processing a graph. Storage estimation is done by using the MPSImageDescriptor to create a MPSImage (without passing it a texture), and then call -resourceSize. As long as the MPSImage is not used in an encode call and the .texture property is not invoked, the underlying MTLTexture is not created. No destination state or destination image is provided as an argument to this function because it is expected they will be made / configured after this is called. This method is expected to auto-configure important object properties that may be needed in the ensuing destination image and state creation steps. @param sourceImages A array of source images that will be passed into the -encode call Since MPSCNNBinaryKernel is a binary kernel, it is an array of length 2. @param sourceStates An optional array of source states that will be passed into the -encode call @return an image descriptor allocated on the autorelease pool

func (*MPSCNNBinaryKernel) EncodeBatchToCommandBufferPrimaryImagesSecondaryImages ¶

func (o *MPSCNNBinaryKernel) EncodeBatchToCommandBufferPrimaryImagesSecondaryImages(commandBuffer metal.MTLCommandBuffer, primaryImage unsafe.Pointer, secondaryImage unsafe.Pointer) unsafe.Pointer

@abstract Encode a MPSCNNKernel into a command Buffer. Create textures to hold the results and return them. @discussion In the first iteration on this method, encodeBatchToCommandBuffer:sourceImage:destinationImage: some work was left for the developer to do in the form of correctly setting the offset property and sizing the result buffer. With the introduction of the padding policy (see padding property) the filter can do this work itself. If you would like to have some input into what sort of MPSImage (e.g. temporary vs. regular) or what size it is or where it is allocated, you may set the destinationImageAllocator to allocate the image yourself. This method uses the MPSNNPadding padding property to figure out how to size the result image and to set the offset property. See discussion in MPSNeuralNetworkTypes.h. All images in a batch must have MPSImage.numberOfImages = 1. @param commandBuffer The command buffer @param primaryImage A MPSImages to use as the primary source images for the filter. @param secondaryImage A MPSImages to use as the secondary source images for the filter. @result A MPSImage or MPSTemporaryImage allocated per the destinationImageAllocator containing the output of the graph. The returned image will be automatically released when the command buffer completes. If you want to keep it around for longer, retain the image. (ARC will do this for you if you use it later.)

func (*MPSCNNBinaryKernel) EncodeBatchToCommandBufferPrimaryImagesSecondaryImagesDestinationImages ¶

func (o *MPSCNNBinaryKernel) EncodeBatchToCommandBufferPrimaryImagesSecondaryImagesDestinationImages(commandBuffer metal.MTLCommandBuffer, primaryImages unsafe.Pointer, secondaryImages unsafe.Pointer, destinationImages unsafe.Pointer)

@abstract Encode a MPSCNNKernel into a command Buffer. The operation shall proceed out-of-place. @discussion This is the older style of encode which reads the offset, doesn't change it, and ignores the padding method. Multiple images are processed concurrently. All images must have MPSImage.numberOfImages = 1. @param commandBuffer A valid MTLCommandBuffer to receive the encoded filter @param primaryImages An array of MPSImage objects containing the primary source images. @param secondaryImages An array MPSImage objects containing the secondary source images. @param destinationImages An array of MPSImage objects to contain the result images. destinationImages may not alias primarySourceImages or secondarySourceImages in any manner.

func (*MPSCNNBinaryKernel) EncodeBatchToCommandBufferPrimaryImagesSecondaryImagesDestinationStatesDestinationStateIsTemporary ¶

func (o *MPSCNNBinaryKernel) EncodeBatchToCommandBufferPrimaryImagesSecondaryImagesDestinationStatesDestinationStateIsTemporary(commandBuffer metal.MTLCommandBuffer, primaryImages unsafe.Pointer, secondaryImages unsafe.Pointer, outState unsafe.Pointer, isTemporary bool) unsafe.Pointer

@abstract Encode a MPSCNNKernel into a command Buffer. Create a texture and state to hold the results and return them. @discussion In the first iteration on this method, encodeToCommandBuffer:sourceImage:destinationState:destinationImage: some work was left for the developer to do in the form of correctly setting the offset property and sizing the result buffer. With the introduction of the padding policy (see padding property) the filter can do this work itself. If you would like to have some input into what sort of MPSImage (e.g. temporary vs. regular) or what size it is or where it is allocated, you may set the destinationImageAllocator to allocate the image yourself. This method uses the MPSNNPadding padding property to figure out how to size the result image and to set the offset property. See discussion in MPSNeuralNetworkTypes.h. All images in a batch must have MPSImage.numberOfImages = 1. @param commandBuffer The command buffer @param primaryImages A MPSImage to use as the source images for the filter. @param secondaryImages A MPSImage to use as the source images for the filter. @param outState A new state object is returned here. @param isTemporary YES if the outState should be a temporary object @result A MPSImage or MPSTemporaryImage allocated per the destinationImageAllocator containing the output of the graph. The offset property will be adjusted to reflect the offset used during the encode. The returned image will be automatically released when the command buffer completes. If you want to keep it around for longer, retain the image. (ARC will do this for you if you use it later.)

func (*MPSCNNBinaryKernel) EncodeToCommandBufferPrimaryImageSecondaryImage ¶

func (o *MPSCNNBinaryKernel) EncodeToCommandBufferPrimaryImageSecondaryImage(commandBuffer metal.MTLCommandBuffer, primaryImage *mpscore.MPSImage, secondaryImage *mpscore.MPSImage) *mpscore.MPSImage

@abstract Encode a MPSCNNKernel into a command Buffer. Create a texture to hold the result and return it. @discussion In the first iteration on this method, encodeToCommandBuffer:sourceImage:destinationImage: some work was left for the developer to do in the form of correctly setting the offset property and sizing the result buffer. With the introduction of the padding policy (see padding property) the filter can do this work itself. If you would like to have some input into what sort of MPSImage (e.g. temporary vs. regular) or what size it is or where it is allocated, you may set the destinationImageAllocator to allocate the image yourself. This method uses the MPSNNPadding padding property to figure out how to size the result image and to set the offset property. See discussion in MPSNeuralNetworkTypes.h. @param commandBuffer The command buffer @param primaryImage A MPSImages to use as the primary source images for the filter. @param secondaryImage A MPSImages to use as the secondary source images for the filter. @result A MPSImage or MPSTemporaryImage allocated per the destinationImageAllocator containing the output of the graph. The returned image will be automatically released when the command buffer completes. If you want to keep it around for longer, retain the image. (ARC will do this for you if you use it later.)

func (*MPSCNNBinaryKernel) EncodeToCommandBufferPrimaryImageSecondaryImageDestinationImage ¶

func (o *MPSCNNBinaryKernel) EncodeToCommandBufferPrimaryImageSecondaryImageDestinationImage(commandBuffer metal.MTLCommandBuffer, primaryImage *mpscore.MPSImage, secondaryImage *mpscore.MPSImage, destinationImage *mpscore.MPSImage)

@abstract Encode a MPSCNNKernel into a command Buffer. The operation shall proceed out-of-place. @discussion This is the older style of encode which reads the offset, doesn't change it, and ignores the padding method. @param commandBuffer A valid MTLCommandBuffer to receive the encoded filter @param primaryImage A valid MPSImage object containing the primary source image. @param secondaryImage A valid MPSImage object containing the secondary source image. @param destinationImage A valid MPSImage to be overwritten by result image. destinationImage may not alias primarySourceImage or secondarySourceImage.

func (*MPSCNNBinaryKernel) EncodeToCommandBufferPrimaryImageSecondaryImageDestinationStateDestinationStateIsTemporary ¶

func (o *MPSCNNBinaryKernel) EncodeToCommandBufferPrimaryImageSecondaryImageDestinationStateDestinationStateIsTemporary(commandBuffer metal.MTLCommandBuffer, primaryImage *mpscore.MPSImage, secondaryImage *mpscore.MPSImage, outState *mpscore.MPSState, isTemporary bool) *mpscore.MPSImage

@abstract Encode a MPSCNNKernel into a command Buffer. Create a texture and state to hold the results and return them. @discussion In the first iteration on this method, encodeToCommandBuffer:sourceImage:destinationState:destinationImage: some work was left for the developer to do in the form of correctly setting the offset property and sizing the result buffer. With the introduction of the padding policy (see padding property) the filter can do this work itself. If you would like to have some input into what sort of MPSImage (e.g. temporary vs. regular) or what size it is or where it is allocated, you may set the destinationImageAllocator to allocate the image yourself. This method uses the MPSNNPadding padding property to figure out how to size the result image and to set the offset property. See discussion in MPSNeuralNetworkTypes.h. All images in a batch must have MPSImage.numberOfImages = 1. @param commandBuffer The command buffer @param primaryImage A MPSImage to use as the source images for the filter. @param secondaryImage A MPSImage to use as the source images for the filter. @param outState The address of location to write the pointer to the result state of the operation @param isTemporary YES if the outState should be a temporary object @result A MPSImage or MPSTemporaryImage allocated per the destinationImageAllocator containing the output of the graph. The offset property will be adjusted to reflect the offset used during the encode. The returned image will be automatically released when the command buffer completes. If you want to keep it around for longer, retain the image. (ARC will do this for you if you use it later.)

func (*MPSCNNBinaryKernel) EncodingStorageSizeForPrimaryImageSecondaryImageSourceStatesDestinationImage ¶

func (o *MPSCNNBinaryKernel) EncodingStorageSizeForPrimaryImageSecondaryImageSourceStatesDestinationImage(primaryImage *mpscore.MPSImage, secondaryImage *mpscore.MPSImage, sourceStates *foundation.NSArray[*mpscore.MPSState], destinationImage *mpscore.MPSImage) uint

@abstract The size of extra MPS heap storage allocated while the kernel is encoding @discussion This is best effort and just describes things that are likely to end up on the MPS heap. It does not describe all allocation done by the -encode call. It is intended for use with high water calculations for MTLHeap sizing. Allocations are typically for temporary storage needed for multipass algorithms. This interface should not be used to detect multipass algorithms.

func (*MPSCNNBinaryKernel) InitWithCoderDevice ¶

func (o *MPSCNNBinaryKernel) InitWithCoderDevice(aDecoder *foundation.NSCoder, device metal.MTLDevice) *MPSCNNBinaryKernel

@abstract NSSecureCoding compatability @discussion While the standard NSSecureCoding/NSCoding method -initWithCoder: should work, since the file can't know which device your data is allocated on, we have to guess and may guess incorrectly. To avoid that problem, use initWithCoder:device instead. @param aDecoder The NSCoder subclass with your serialized MPSKernel @param device The MTLDevice on which to make the MPSKernel @return A new MPSKernel object, or nil if failure.

func (*MPSCNNBinaryKernel) InitWithDevice ¶

func (o *MPSCNNBinaryKernel) InitWithDevice(device metal.MTLDevice) *MPSCNNBinaryKernel

@abstract Standard init with default properties per filter type @param device The device that the filter will be used on. May not be NULL. @result A pointer to the newly initialized object. This will fail, returning nil if the device is not supported. Devices must be MTLFeatureSet_iOS_GPUFamily2_v1 or later.

func (*MPSCNNBinaryKernel) IsBackwards ¶

func (o *MPSCNNBinaryKernel) IsBackwards() bool

@property isBackwards @abstract YES if the filter operates backwards. @discussion This influences how strideInPixelsX/Y should be interpreted.

func (*MPSCNNBinaryKernel) IsResultStateReusedAcrossBatch ¶

func (o *MPSCNNBinaryKernel) IsResultStateReusedAcrossBatch() bool

@abstract Returns YES if the same state is used for every operation in a batch @discussion If NO, then each image in a MPSImageBatch will need a corresponding (and different) state to go with it. Set to YES to avoid allocating redundant state in the case when the same state is used all the time. Default: NO

func (*MPSCNNBinaryKernel) IsStateModified ¶

func (o *MPSCNNBinaryKernel) IsStateModified() bool

@abstract Returns true if the -encode call modifies the state object it accepts.

func (*MPSCNNBinaryKernel) Padding ¶

func (o *MPSCNNBinaryKernel) Padding() MPSNNPadding

@property padding @abstract The padding method used by the filter @discussion This influences how strideInPixelsX/Y should be interpreted. Default: MPSNNPaddingMethodAlignCentered | MPSNNPaddingMethodAddRemainderToTopLeft | MPSNNPaddingMethodSizeSame Some object types (e.g. MPSCNNFullyConnected) may override this default with something appropriate to its operation.

func (*MPSCNNBinaryKernel) PrimaryDilationRateX ¶

func (o *MPSCNNBinaryKernel) PrimaryDilationRateX() uint

@property dilationRateX @abstract Stride in source coordinates from one kernel tap to the next in the X dimension.

func (*MPSCNNBinaryKernel) PrimaryDilationRateY ¶

func (o *MPSCNNBinaryKernel) PrimaryDilationRateY() uint

@property dilationRate @abstract Stride in source coordinates from one kernel tap to the next in the Y dimension.

func (*MPSCNNBinaryKernel) PrimaryEdgeMode ¶

func (o *MPSCNNBinaryKernel) PrimaryEdgeMode() mpscore.MPSImageEdgeMode

@property primaryEdgeMode @abstract The MPSImageEdgeMode to use when texture reads stray off the edge of the primary source image @discussion Most MPSKernel objects can read off the edge of the source image. This can happen because of a negative offset property, because the offset + clipRect.size is larger than the source image or because the filter looks at neighboring pixels, such as a Convolution filter. Default: MPSImageEdgeModeZero. See Also: @ref subsubsection_edgemode

func (*MPSCNNBinaryKernel) PrimaryKernelHeight ¶