Package apple.metalperformanceshaders

Class MPSNNOptimizerStochasticGradientDescent

  • All Implemented Interfaces:
    NSCoding, NSCopying, NSSecureCoding, NSObject
    public class MPSNNOptimizerStochasticGradientDescent
extends MPSNNOptimizer
    MPSNNOptimizerStochasticGradientDescent The MPSNNOptimizerStochasticGradientDescent performs a gradient descent with an optional momentum Update RMSProp is also known as root mean square propagation. useNesterov == NO: m[t] = momentumScale * m[t-1] + learningRate * g variable = variable - m[t] useNesterov == YES: m[t] = momentumScale * m[t-1] + g variable = variable - (learningRate * (g + m[t] * momentumScale)) where, g is gradient of error wrt variable m[t] is momentum of gradients it is a state we keep updating every update iteration

    • Constructor Detail

      • MPSNNOptimizerStochasticGradientDescent

        protected MPSNNOptimizerStochasticGradientDescent​(org.moe.natj.general.Pointer peer)

    • Method Detail

      • accessInstanceVariablesDirectly

        public static boolean accessInstanceVariablesDirectly()

      • allocWithZone

        public static java.lang.Object allocWithZone​(org.moe.natj.general.ptr.VoidPtr zone)

      • automaticallyNotifiesObserversForKey

        public static boolean automaticallyNotifiesObserversForKey​(java.lang.String key)

      • cancelPreviousPerformRequestsWithTarget

        public static void cancelPreviousPerformRequestsWithTarget​(java.lang.Object aTarget)

      • cancelPreviousPerformRequestsWithTargetSelectorObject

        public static void cancelPreviousPerformRequestsWithTargetSelectorObject​(java.lang.Object aTarget,
                                                                         org.moe.natj.objc.SEL aSelector,
                                                                         java.lang.Object anArgument)

      • classFallbacksForKeyedArchiver

        public static NSArray<java.lang.String> classFallbacksForKeyedArchiver()

      • classForKeyedUnarchiver

        public static org.moe.natj.objc.Class classForKeyedUnarchiver()

      • debugDescription_static

        public static java.lang.String debugDescription_static()

      • description_static

        public static java.lang.String description_static()

      • encodeToCommandBufferBatchNormalizationGradientStateBatchNormalizationSourceStateInputMomentumVectorsResultState

        public void encodeToCommandBufferBatchNormalizationGradientStateBatchNormalizationSourceStateInputMomentumVectorsResultState​(MTLCommandBuffer commandBuffer,
                                                                                                                             MPSCNNBatchNormalizationState batchNormalizationGradientState,
                                                                                                                             MPSCNNBatchNormalizationState batchNormalizationSourceState,
                                                                                                                             NSArray<? extends MPSVector> inputMomentumVectors,
                                                                                                                             MPSCNNNormalizationGammaAndBetaState resultState)
        Encode an MPSNNOptimizerStochasticGradientDescent object to a command buffer to perform out of place update The following operations would be applied useNesterov == NO: m[t] = momentumScale * m[t-1] + learningRate * g variable = variable - m[t] useNesterov == YES: m[t] = momentumScale * m[t-1] + g variable = variable - (learningRate * (g + m[t] * momentumScale)) inputMomentumVector == nil variable = variable - (learningRate * g) where, g is gradient of error wrt variable m[t] is momentum of gradients it is a state we keep updating every update iteration
        Parameters:
        commandBuffer - A valid MTLCommandBuffer to receive the encoded kernel.
        batchNormalizationGradientState - A valid MPSCNNBatchNormalizationState object which specifies the input state with gradients for this update.
        batchNormalizationSourceState - A valid MPSCNNBatchNormalizationState object which specifies the input state with original gamma/beta for this update.
        inputMomentumVectors - An array MPSVector object which specifies the gradient momentum vectors which will be updated and overwritten. The index 0 corresponds to gamma, index 1 corresponds to beta, array can be of size 1 in which case beta won't be updated
        resultState - A valid MPSCNNNormalizationGammaAndBetaState object which specifies the resultValues state which will be updated and overwritten.

      • encodeToCommandBufferBatchNormalizationStateInputMomentumVectorsResultState

        public void encodeToCommandBufferBatchNormalizationStateInputMomentumVectorsResultState​(MTLCommandBuffer commandBuffer,
                                                                                        MPSCNNBatchNormalizationState batchNormalizationState,
                                                                                        NSArray<? extends MPSVector> inputMomentumVectors,
                                                                                        MPSCNNNormalizationGammaAndBetaState resultState)
        Encode an MPSNNOptimizerStochasticGradientDescent object to a command buffer to perform out of place update The following operations would be applied useNesterov == NO: m[t] = momentumScale * m[t-1] + learningRate * g variable = variable - m[t] useNesterov == YES: m[t] = momentumScale * m[t-1] + g variable = variable - (learningRate * (g + m[t] * momentumScale)) inputMomentumVector == nil variable = variable - (learningRate * g) where, g is gradient of error wrt variable m[t] is momentum of gradients it is a state we keep updating every update iteration
        Parameters:
        commandBuffer - A valid MTLCommandBuffer to receive the encoded kernel.
        batchNormalizationState - A valid MPSCNNBatchNormalizationState object which specifies the input state with gradients and original gamma/beta for this update.
        inputMomentumVectors - An array MPSVector object which specifies the gradient momentum vectors which will be updated and overwritten. The index 0 corresponds to gamma, index 1 corresponds to beta, array can be of size 1 in which case beta won't be updated
        resultState - A valid MPSCNNNormalizationGammaAndBetaState object which specifies the resultValues state which will be updated and overwritten.

      • encodeToCommandBufferConvolutionGradientStateConvolutionSourceStateInputMomentumVectorsResultState

        public void encodeToCommandBufferConvolutionGradientStateConvolutionSourceStateInputMomentumVectorsResultState​(MTLCommandBuffer commandBuffer,
                                                                                                               MPSCNNConvolutionGradientState convolutionGradientState,
                                                                                                               MPSCNNConvolutionWeightsAndBiasesState convolutionSourceState,
                                                                                                               NSArray<? extends MPSVector> inputMomentumVectors,
                                                                                                               MPSCNNConvolutionWeightsAndBiasesState resultState)
        Encode an MPSNNOptimizerStochasticGradientDescent object to a command buffer to perform out of place update The following operations would be applied useNesterov == NO: m[t] = momentumScale * m[t-1] + learningRate * g variable = variable - m[t] useNesterov == YES: m[t] = momentumScale * m[t-1] + g variable = variable - (learningRate * (g + m[t] * momentumScale)) inputMomentumVector == nil variable = variable - (learningRate * g) where, g is gradient of error wrt variable m[t] is momentum of gradients it is a state we keep updating every update iteration
        Parameters:
        commandBuffer - A valid MTLCommandBuffer to receive the encoded kernel.
        convolutionGradientState - A valid MPSCNNConvolutionGradientState object which specifies the input state with gradients for this update.
        convolutionSourceState - A valid MPSCNNConvolutionWeightsAndBiasesState object which specifies the input state with values to be updated.
        inputMomentumVectors - An array MPSVector object which specifies the gradient momentum vectors which will be updated and overwritten. The index 0 corresponds to weights, index 1 corresponds to biases, array can be of size 1 in which case biases won't be updated
        resultState - A valid MPSCNNConvolutionWeightsAndBiasesState object which specifies the resultValues state which will be updated and overwritten.

      • encodeToCommandBufferInputGradientMatrixInputValuesMatrixInputMomentumMatrixResultValuesMatrix

        public void encodeToCommandBufferInputGradientMatrixInputValuesMatrixInputMomentumMatrixResultValuesMatrix​(MTLCommandBuffer commandBuffer,
                                                                                                           MPSMatrix inputGradientMatrix,
                                                                                                           MPSMatrix inputValuesMatrix,
                                                                                                           MPSMatrix inputMomentumMatrix,
                                                                                                           MPSMatrix resultValuesMatrix)

      • encodeToCommandBufferInputGradientVectorInputValuesVectorInputMomentumVectorResultValuesVector

        public void encodeToCommandBufferInputGradientVectorInputValuesVectorInputMomentumVectorResultValuesVector​(MTLCommandBuffer commandBuffer,
                                                                                                           MPSVector inputGradientVector,
                                                                                                           MPSVector inputValuesVector,
                                                                                                           MPSVector inputMomentumVector,
                                                                                                           MPSVector resultValuesVector)
        Encode an MPSNNOptimizerStochasticGradientDescent object to a command buffer to perform out of place update The following operations would be applied useNesterov == NO: m[t] = momentumScale * m[t-1] + learningRate * g variable = variable - m[t] useNesterov == YES: m[t] = momentumScale * m[t-1] + g variable = variable - (learningRate * (g + m[t] * momentumScale)) inputMomentumVector == nil variable = variable - (learningRate * g) where, g is gradient of error wrt variable m[t] is momentum of gradients it is a state we keep updating every update iteration
        Parameters:
        commandBuffer - A valid MTLCommandBuffer to receive the encoded kernel.
        inputGradientVector - A valid MPSVector object which specifies the input vector of gradients for this update.
        inputValuesVector - A valid MPSVector object which specifies the input vector of values to be updated.
        inputMomentumVector - A valid MPSVector object which specifies the gradient momentum vector which will be updated and overwritten.
        resultValuesVector - A valid MPSVector object which specifies the resultValues vector which will be updated and overwritten.

      • hash_static

        public static long hash_static()

      • initWithCoderDevice

        public MPSNNOptimizerStochasticGradientDescent initWithCoderDevice​(NSCoder aDecoder,
                                                                   java.lang.Object device)
        Description copied from class: MPSKernel
        NSSecureCoding compatability 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.
        Overrides:
        initWithCoderDevice in class MPSNNOptimizer
        Parameters:
        aDecoder - The NSCoder subclass with your serialized MPSKernel
        device - The MTLDevice on which to make the MPSKernel
        Returns:
        A new MPSKernel object, or nil if failure.

      • initWithDevice

        public MPSNNOptimizerStochasticGradientDescent initWithDevice​(java.lang.Object device)
        Description copied from class: MPSKernel
        Standard init with default properties per filter type
        Overrides:
        initWithDevice in class MPSNNOptimizer
        Parameters:
        device - The device that the filter will be used on. May not be NULL.
        Returns:
        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.

      • initWithDeviceLearningRate

        public MPSNNOptimizerStochasticGradientDescent initWithDeviceLearningRate​(MTLDevice device,
                                                                          float learningRate)
        Convenience initialization for the momentum update
        Parameters:
        device - The device on which the kernel will execute.
        learningRate - The learningRate which will be applied
        Returns:
        A valid MPSNNOptimizerStochasticGradientDescent object or nil, if failure.

      • instanceMethodSignatureForSelector

        public static NSMethodSignature instanceMethodSignatureForSelector​(org.moe.natj.objc.SEL aSelector)

      • instancesRespondToSelector

        public static boolean instancesRespondToSelector​(org.moe.natj.objc.SEL aSelector)

      • isSubclassOfClass

        public static boolean isSubclassOfClass​(org.moe.natj.objc.Class aClass)

      • keyPathsForValuesAffectingValueForKey

        public static NSSet<java.lang.String> keyPathsForValuesAffectingValueForKey​(java.lang.String key)

      • momentumScale

        public float momentumScale()
        [@property] momentumScale The momentumScale at which we update momentum for values array Default value is 0.0

      • new_objc

        public static java.lang.Object new_objc()

      • resolveClassMethod

        public static boolean resolveClassMethod​(org.moe.natj.objc.SEL sel)

      • resolveInstanceMethod

        public static boolean resolveInstanceMethod​(org.moe.natj.objc.SEL sel)

      • setVersion_static

        public static void setVersion_static​(long aVersion)

      • superclass_static

        public static org.moe.natj.objc.Class superclass_static()

      • supportsSecureCoding

        public static boolean supportsSecureCoding()

      • _supportsSecureCoding

        public boolean _supportsSecureCoding()
        Description copied from interface: NSSecureCoding
        This property must return YES on all classes that allow secure coding. Subclasses of classes that adopt NSSecureCoding and override initWithCoder: must also override this method and return YES. The Secure Coding Guide should be consulted when writing methods that decode data.
        Specified by:
        _supportsSecureCoding in interface NSSecureCoding
        Overrides:
        _supportsSecureCoding in class MPSNNOptimizer

      • useNestrovMomentum

        public boolean useNestrovMomentum()

      • version_static

        public static long version_static()

      • initWithDeviceMomentumScaleUseNesterovMomentumOptimizerDescriptor

        public MPSNNOptimizerStochasticGradientDescent initWithDeviceMomentumScaleUseNesterovMomentumOptimizerDescriptor​(MTLDevice device,
                                                                                                                 float momentumScale,
                                                                                                                 boolean useNesterovMomentum,
                                                                                                                 MPSNNOptimizerDescriptor optimizerDescriptor)
        Full initialization for the momentum update
        Parameters:
        device - The device on which the kernel will execute.
        momentumScale - The momentumScale to update momentum for values array
        useNesterovMomentum - Use the Nesterov style momentum update
        optimizerDescriptor - The optimizerDescriptor which will have a bunch of properties to be applied
        Returns:
        A valid MPSNNOptimizerMomentum object or nil, if failure.

      • useNesterovMomentum

        public boolean useNesterovMomentum()
        [@property] useNesterovMomentum Nesterov momentum is considered an improvement on the usual momentum update Default value is NO [@note] Maps to old useNestrovMomentum property