SeparableConv2D

class SeparableConv2D(filters: Int, kernelSize: IntArray, strides: IntArray, dilations: IntArray, activation: Activations, depthMultiplier: Int, depthwiseInitializer: Initializer, pointwiseInitializer: Initializer, biasInitializer: Initializer, depthwiseRegularizer: Regularizer?, pointwiseRegularizer: Regularizer?, biasRegularizer: Regularizer?, activityRegularizer: Regularizer?, padding: ConvPadding, useBias: Boolean, name: String) : Layer, NoGradients, ParametrizedLayer

2-D convolution with separable filters.

Performs a depthwise convolution that acts separately on channels followed by a pointwise convolution that mixes channels. Note that this is separability between dimensions [1, 2] and 3, not spatial separability between dimensions 1 and 2.

Intuitively, separable convolutions can be understood as a way to factorize a convolution kernel into two smaller kernels, or as an extreme version of an Inception block.

Since

0.2

Constructors

SeparableConv2D

fun SeparableConv2D(filters: Int = 32, kernelSize: Int = 3, strides: Int = 1, dilations: Int = 1, activation: Activations = Activations.Relu, depthMultiplier: Int = 1, depthwiseInitializer: Initializer = HeNormal(), pointwiseInitializer: Initializer = HeNormal(), biasInitializer: Initializer = HeUniform(), depthwiseRegularizer: Regularizer? = null, pointwiseRegularizer: Regularizer? = null, biasRegularizer: Regularizer? = null, activityRegularizer: Regularizer? = null, padding: ConvPadding = ConvPadding.SAME, useBias: Boolean = true, name: String = "")

SeparableConv2D

fun SeparableConv2D(filters: Int = 32, kernelSize: IntArray = intArrayOf(3, 3), strides: IntArray = intArrayOf(1, 1, 1, 1), dilations: IntArray = intArrayOf(1, 1, 1, 1), activation: Activations = Activations.Relu, depthMultiplier: Int = 1, depthwiseInitializer: Initializer = HeNormal(), pointwiseInitializer: Initializer = HeNormal(), biasInitializer: Initializer = HeUniform(), depthwiseRegularizer: Regularizer? = null, pointwiseRegularizer: Regularizer? = null, biasRegularizer: Regularizer? = null, activityRegularizer: Regularizer? = null, padding: ConvPadding = ConvPadding.SAME, useBias: Boolean = true, name: String = "")

Creates SeparableConv2D object.

Functions

build

open override fun build(tf: Ops, inputShape: Shape)

Extend this function to define variables in layer.

buildFromInboundLayers

fun buildFromInboundLayers(tf: Ops)

Extend this function to define variables in layer.

computeOutputShape

open override fun computeOutputShape(inputShape: Shape): Shape

Computes output shape, based on inputShape and Layer type.

computeOutputShapeFromInboundLayers

open fun computeOutputShapeFromInboundLayers(): TensorShape

Computes output shape, based on input shapes of inbound layers.

forward

open override fun forward(tf: Ops, input: Operand<Float>, isTraining: Operand<Boolean>, numberOfLosses: Operand<Float>?): Operand<Float>

Builds main layer input transformation with tf. Depends on Layer type.

open fun forward(tf: Ops, input: List<Operand<Float>>, isTraining: Operand<Boolean>, numberOfLosses: Operand<Float>?): Operand<Float>

Builds main layer input transformation with tf. Depends on Layer type.

invoke

operator fun invoke(vararg layers: Layer): Layer

Important part of functional API. It takes layers as input and saves them to the inboundLayers of the given layer.

toString

open override fun toString(): String

Properties

activation

val activation: Activations

Activation function.

activityRegularizer

val activityRegularizer: Regularizer? = null

Regularizer function applied to the output of the layer (its "activation").

biasInitializer

val biasInitializer: Initializer

An initializer for the bias vector.

biasRegularizer

val biasRegularizer: Regularizer? = null

Regularizer function applied to the bias vector.

depthMultiplier

val depthMultiplier: Int = 1

The number of depthwise convolution output channels for each input channel. The total number of depthwise convolution output channels will be equal to numberOfChannels * depthMultiplier.

depthwiseInitializer

val depthwiseInitializer: Initializer

An initializer for the depthwise kernel matrix.

depthwiseRegularizer

val depthwiseRegularizer: Regularizer? = null

Regularizer function applied to the depthwise kernel matrix.

dilations

val dilations: IntArray

Four numbers, specifying the dilation rate to use for dilated convolution for each dimension of input tensor.

filters

val filters: Int = 32

The dimensionality of the output space (i.e. the number of filters in the convolution).

hasActivation

open override val hasActivation: Boolean

Returns True, if layer has internal activation function.

inboundLayers

var inboundLayers: MutableList<Layer>

Returns inbound layers.

kernelSize

val kernelSize: IntArray

Two long numbers, specifying the height and width of the 2D convolution window.

name

var name: String

Layer name. A new name is generated during model compilation when provided name is empty.

outboundLayers

var outboundLayers: MutableList<Layer>

Returns outbound layers.

outputShape

lateinit var outputShape: TensorShape

Output data tensor shape.

padding

val padding: ConvPadding

The padding method, either 'valid' or 'same' or 'full'.

paramCount

open val paramCount: Int

Number of parameters in this layer.

parentModel

var parentModel: GraphTrainableModel? = null

Model where this layer is used.

pointwiseInitializer

val pointwiseInitializer: Initializer

An initializer for the pointwise kernel matrix.

pointwiseRegularizer

val pointwiseRegularizer: Regularizer? = null

Regularizer function applied to the pointwise kernel matrix

strides

val strides: IntArray

Strides of the pooling operation for each dimension of input tensor. NOTE: Specifying any stride value != 1 is incompatible with specifying any dilation_rate value != 1.

useBias

val useBias: Boolean = true

If true the layer uses a bias vector.

variables

open override val variables: List<KVariable>

Variables used in this layer.