nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/autodiff/samediff/ops/SDCNN.java
/*
* ******************************************************************************
* *
* *
* * This program and the accompanying materials are made available under the
* * terms of the Apache License, Version 2.0 which is available at
* * https://www.apache.org/licenses/LICENSE-2.0.
* *
* * See the NOTICE file distributed with this work for additional
* * information regarding copyright ownership.
* * Unless required by applicable law or agreed to in writing, software
* * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* * License for the specific language governing permissions and limitations
* * under the License.
* *
* * SPDX-License-Identifier: Apache-2.0
* *****************************************************************************
*/
//================== GENERATED CODE - DO NOT MODIFY THIS FILE ==================
package org.nd4j.autodiff.samediff.ops;
import static org.nd4j.autodiff.samediff.ops.SDValidation.isSameType;
import java.lang.String;
import org.nd4j.autodiff.samediff.SDVariable;
import org.nd4j.autodiff.samediff.SameDiff;
import org.nd4j.common.base.Preconditions;
import org.nd4j.enums.DataFormat;
import org.nd4j.linalg.api.ops.impl.layers.convolution.config.Conv1DConfig;
import org.nd4j.linalg.api.ops.impl.layers.convolution.config.Conv2DConfig;
import org.nd4j.linalg.api.ops.impl.layers.convolution.config.Conv3DConfig;
import org.nd4j.linalg.api.ops.impl.layers.convolution.config.DeConv2DConfig;
import org.nd4j.linalg.api.ops.impl.layers.convolution.config.DeConv3DConfig;
import org.nd4j.linalg.api.ops.impl.layers.convolution.config.LocalResponseNormalizationConfig;
import org.nd4j.linalg.api.ops.impl.layers.convolution.config.Pooling2DConfig;
import org.nd4j.linalg.api.ops.impl.layers.convolution.config.Pooling3DConfig;
public class SDCNN extends SDOps {
public SDCNN(SameDiff sameDiff) {
super(sameDiff);
}
/**
* 2D Convolution layer operation - average pooling 2d<br>
*
* @param input the input to average pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param Pooling2DConfig Configuration Object
* @return output Result after applying average pooling on the input (NUMERIC type)
*/
public SDVariable avgPooling2d(SDVariable input, Pooling2DConfig Pooling2DConfig) {
SDValidation.validateNumerical("avgPooling2d", "input", input);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.AvgPooling2D(sd,input, Pooling2DConfig).outputVariable();
}
/**
* 2D Convolution layer operation - average pooling 2d<br>
*
* @param name name May be null. Name for the output variable
* @param input the input to average pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param Pooling2DConfig Configuration Object
* @return output Result after applying average pooling on the input (NUMERIC type)
*/
public SDVariable avgPooling2d(String name, SDVariable input, Pooling2DConfig Pooling2DConfig) {
SDValidation.validateNumerical("avgPooling2d", "input", input);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.AvgPooling2D(sd,input, Pooling2DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* 3D convolution layer operation - average pooling 3d <br>
*
* @param input the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels]) (NUMERIC type)
* @param Pooling3DConfig Configuration Object
* @return output after applying average pooling on the input (NUMERIC type)
*/
public SDVariable avgPooling3d(SDVariable input, Pooling3DConfig Pooling3DConfig) {
SDValidation.validateNumerical("avgPooling3d", "input", input);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.AvgPooling3D(sd,input, Pooling3DConfig).outputVariable();
}
/**
* 3D convolution layer operation - average pooling 3d <br>
*
* @param name name May be null. Name for the output variable
* @param input the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels]) (NUMERIC type)
* @param Pooling3DConfig Configuration Object
* @return output after applying average pooling on the input (NUMERIC type)
*/
public SDVariable avgPooling3d(String name, SDVariable input, Pooling3DConfig Pooling3DConfig) {
SDValidation.validateNumerical("avgPooling3d", "input", input);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.AvgPooling3D(sd,input, Pooling3DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Convolution 2d layer batch to space operation on 4d input.<br>
* Reduces input batch dimension by rearranging data into a larger spatial dimensions<br>
*
* @param x Input variable. 4d input (NUMERIC type)
* @param blocks Block size, in the height/width dimension (Size: Exactly(count=2))
* @param croppingTop (Size: Exactly(count=2))
* @param croppingBottom (Size: Exactly(count=2))
* @return output Output variable (NUMERIC type)
*/
public SDVariable batchToSpace(SDVariable x, int[] blocks, int[] croppingTop,
int... croppingBottom) {
SDValidation.validateNumerical("batchToSpace", "x", x);
Preconditions.checkArgument(blocks.length == 2, "blocks has incorrect size/length. Expected: blocks.length == 2, got %s", blocks.length);
Preconditions.checkArgument(croppingTop.length == 2, "croppingTop has incorrect size/length. Expected: croppingTop.length == 2, got %s", croppingTop.length);
Preconditions.checkArgument(croppingBottom.length == 2, "croppingBottom has incorrect size/length. Expected: croppingBottom.length == 2, got %s", croppingBottom.length);
return new org.nd4j.linalg.api.ops.impl.transforms.custom.BatchToSpace(sd,x, blocks, croppingTop, croppingBottom).outputVariable();
}
/**
* Convolution 2d layer batch to space operation on 4d input.<br>
* Reduces input batch dimension by rearranging data into a larger spatial dimensions<br>
*
* @param name name May be null. Name for the output variable
* @param x Input variable. 4d input (NUMERIC type)
* @param blocks Block size, in the height/width dimension (Size: Exactly(count=2))
* @param croppingTop (Size: Exactly(count=2))
* @param croppingBottom (Size: Exactly(count=2))
* @return output Output variable (NUMERIC type)
*/
public SDVariable batchToSpace(String name, SDVariable x, int[] blocks, int[] croppingTop,
int... croppingBottom) {
SDValidation.validateNumerical("batchToSpace", "x", x);
Preconditions.checkArgument(blocks.length == 2, "blocks has incorrect size/length. Expected: blocks.length == 2, got %s", blocks.length);
Preconditions.checkArgument(croppingTop.length == 2, "croppingTop has incorrect size/length. Expected: croppingTop.length == 2, got %s", croppingTop.length);
Preconditions.checkArgument(croppingBottom.length == 2, "croppingBottom has incorrect size/length. Expected: croppingBottom.length == 2, got %s", croppingBottom.length);
SDVariable out = new org.nd4j.linalg.api.ops.impl.transforms.custom.BatchToSpace(sd,x, blocks, croppingTop, croppingBottom).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* col2im operation for use in 2D convolution operations. Outputs a 4d array with shape<br>
* [minibatch, inputChannels, height, width]<br>
*
* @param in Input - rank 6 input with shape [minibatch, inputChannels, kernelHeight, kernelWidth, outputHeight, outputWidth] (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output Col2Im output variable (NUMERIC type)
*/
public SDVariable col2Im(SDVariable in, Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("col2Im", "in", in);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.Col2Im(sd,in, Conv2DConfig).outputVariable();
}
/**
* col2im operation for use in 2D convolution operations. Outputs a 4d array with shape<br>
* [minibatch, inputChannels, height, width]<br>
*
* @param name name May be null. Name for the output variable
* @param in Input - rank 6 input with shape [minibatch, inputChannels, kernelHeight, kernelWidth, outputHeight, outputWidth] (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output Col2Im output variable (NUMERIC type)
*/
public SDVariable col2Im(String name, SDVariable in, Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("col2Im", "in", in);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.Col2Im(sd,in, Conv2DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Conv1d operation.<br>
*
* @param input the inputs to conv1d (NUMERIC type)
* @param weights weights for conv1d op - rank 3 array with shape [kernelSize, inputChannels, outputChannels] (NUMERIC type)
* @param bias bias for conv1d op - rank 1 array with shape [outputChannels]. May be null. (NUMERIC type)
* @param Conv1DConfig Configuration Object
* @return output result of conv1d op (NUMERIC type)
*/
public SDVariable conv1d(SDVariable input, SDVariable weights, SDVariable bias,
Conv1DConfig Conv1DConfig) {
SDValidation.validateNumerical("conv1d", "input", input);
SDValidation.validateNumerical("conv1d", "weights", weights);
SDValidation.validateNumerical("conv1d", "bias", bias);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.Conv1D(sd,input, weights, bias, Conv1DConfig).outputVariable();
}
/**
* Conv1d operation.<br>
*
* @param name name May be null. Name for the output variable
* @param input the inputs to conv1d (NUMERIC type)
* @param weights weights for conv1d op - rank 3 array with shape [kernelSize, inputChannels, outputChannels] (NUMERIC type)
* @param bias bias for conv1d op - rank 1 array with shape [outputChannels]. May be null. (NUMERIC type)
* @param Conv1DConfig Configuration Object
* @return output result of conv1d op (NUMERIC type)
*/
public SDVariable conv1d(String name, SDVariable input, SDVariable weights, SDVariable bias,
Conv1DConfig Conv1DConfig) {
SDValidation.validateNumerical("conv1d", "input", input);
SDValidation.validateNumerical("conv1d", "weights", weights);
SDValidation.validateNumerical("conv1d", "bias", bias);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.Conv1D(sd,input, weights, bias, Conv1DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Conv1d operation.<br>
*
* @param input the inputs to conv1d (NUMERIC type)
* @param weights weights for conv1d op - rank 3 array with shape [kernelSize, inputChannels, outputChannels] (NUMERIC type)
* @param Conv1DConfig Configuration Object
* @return output result of conv1d op (NUMERIC type)
*/
public SDVariable conv1d(SDVariable input, SDVariable weights, Conv1DConfig Conv1DConfig) {
SDValidation.validateNumerical("conv1d", "input", input);
SDValidation.validateNumerical("conv1d", "weights", weights);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.Conv1D(sd,input, weights, null, Conv1DConfig).outputVariable();
}
/**
* Conv1d operation.<br>
*
* @param name name May be null. Name for the output variable
* @param input the inputs to conv1d (NUMERIC type)
* @param weights weights for conv1d op - rank 3 array with shape [kernelSize, inputChannels, outputChannels] (NUMERIC type)
* @param Conv1DConfig Configuration Object
* @return output result of conv1d op (NUMERIC type)
*/
public SDVariable conv1d(String name, SDVariable input, SDVariable weights,
Conv1DConfig Conv1DConfig) {
SDValidation.validateNumerical("conv1d", "input", input);
SDValidation.validateNumerical("conv1d", "weights", weights);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.Conv1D(sd,input, weights, null, Conv1DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* 2D Convolution operation with optional bias<br>
*
* @param layerInput the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (NUMERIC type)
* @param weights Weights for the convolution operation. 4 dimensions with format [kernelHeight, kernelWidth, inputChannels, outputChannels] (NUMERIC type)
* @param bias Optional 1D bias array with shape [outputChannels]. May be null. (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output result of conv2d op (NUMERIC type)
*/
public SDVariable conv2d(SDVariable layerInput, SDVariable weights, SDVariable bias,
Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("conv2d", "layerInput", layerInput);
SDValidation.validateNumerical("conv2d", "weights", weights);
SDValidation.validateNumerical("conv2d", "bias", bias);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.Conv2D(sd,layerInput, weights, bias, Conv2DConfig).outputVariable();
}
/**
* 2D Convolution operation with optional bias<br>
*
* @param name name May be null. Name for the output variable
* @param layerInput the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (NUMERIC type)
* @param weights Weights for the convolution operation. 4 dimensions with format [kernelHeight, kernelWidth, inputChannels, outputChannels] (NUMERIC type)
* @param bias Optional 1D bias array with shape [outputChannels]. May be null. (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output result of conv2d op (NUMERIC type)
*/
public SDVariable conv2d(String name, SDVariable layerInput, SDVariable weights, SDVariable bias,
Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("conv2d", "layerInput", layerInput);
SDValidation.validateNumerical("conv2d", "weights", weights);
SDValidation.validateNumerical("conv2d", "bias", bias);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.Conv2D(sd,layerInput, weights, bias, Conv2DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* 2D Convolution operation with optional bias<br>
*
* @param layerInput the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (NUMERIC type)
* @param weights Weights for the convolution operation. 4 dimensions with format [kernelHeight, kernelWidth, inputChannels, outputChannels] (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output result of conv2d op (NUMERIC type)
*/
public SDVariable conv2d(SDVariable layerInput, SDVariable weights, Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("conv2d", "layerInput", layerInput);
SDValidation.validateNumerical("conv2d", "weights", weights);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.Conv2D(sd,layerInput, weights, null, Conv2DConfig).outputVariable();
}
/**
* 2D Convolution operation with optional bias<br>
*
* @param name name May be null. Name for the output variable
* @param layerInput the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (NUMERIC type)
* @param weights Weights for the convolution operation. 4 dimensions with format [kernelHeight, kernelWidth, inputChannels, outputChannels] (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output result of conv2d op (NUMERIC type)
*/
public SDVariable conv2d(String name, SDVariable layerInput, SDVariable weights,
Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("conv2d", "layerInput", layerInput);
SDValidation.validateNumerical("conv2d", "weights", weights);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.Conv2D(sd,layerInput, weights, null, Conv2DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Convolution 3D operation with optional bias <br>
*
* @param input the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels]) (NUMERIC type)
* @param weights Weights for conv3d. Rank 5 with shape [kernelDepth, kernelHeight, kernelWidth, inputChannels, outputChannels]. (NUMERIC type)
* @param bias Optional 1D bias array with shape [outputChannels]. May be null. (NUMERIC type)
* @param Conv3DConfig Configuration Object
* @return output Conv3d output variable (NUMERIC type)
*/
public SDVariable conv3d(SDVariable input, SDVariable weights, SDVariable bias,
Conv3DConfig Conv3DConfig) {
SDValidation.validateNumerical("conv3d", "input", input);
SDValidation.validateNumerical("conv3d", "weights", weights);
SDValidation.validateNumerical("conv3d", "bias", bias);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.Conv3D(sd,input, weights, bias, Conv3DConfig).outputVariable();
}
/**
* Convolution 3D operation with optional bias <br>
*
* @param name name May be null. Name for the output variable
* @param input the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels]) (NUMERIC type)
* @param weights Weights for conv3d. Rank 5 with shape [kernelDepth, kernelHeight, kernelWidth, inputChannels, outputChannels]. (NUMERIC type)
* @param bias Optional 1D bias array with shape [outputChannels]. May be null. (NUMERIC type)
* @param Conv3DConfig Configuration Object
* @return output Conv3d output variable (NUMERIC type)
*/
public SDVariable conv3d(String name, SDVariable input, SDVariable weights, SDVariable bias,
Conv3DConfig Conv3DConfig) {
SDValidation.validateNumerical("conv3d", "input", input);
SDValidation.validateNumerical("conv3d", "weights", weights);
SDValidation.validateNumerical("conv3d", "bias", bias);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.Conv3D(sd,input, weights, bias, Conv3DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Convolution 3D operation with optional bias <br>
*
* @param input the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels]) (NUMERIC type)
* @param weights Weights for conv3d. Rank 5 with shape [kernelDepth, kernelHeight, kernelWidth, inputChannels, outputChannels]. (NUMERIC type)
* @param Conv3DConfig Configuration Object
* @return output Conv3d output variable (NUMERIC type)
*/
public SDVariable conv3d(SDVariable input, SDVariable weights, Conv3DConfig Conv3DConfig) {
SDValidation.validateNumerical("conv3d", "input", input);
SDValidation.validateNumerical("conv3d", "weights", weights);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.Conv3D(sd,input, weights, null, Conv3DConfig).outputVariable();
}
/**
* Convolution 3D operation with optional bias <br>
*
* @param name name May be null. Name for the output variable
* @param input the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels]) (NUMERIC type)
* @param weights Weights for conv3d. Rank 5 with shape [kernelDepth, kernelHeight, kernelWidth, inputChannels, outputChannels]. (NUMERIC type)
* @param Conv3DConfig Configuration Object
* @return output Conv3d output variable (NUMERIC type)
*/
public SDVariable conv3d(String name, SDVariable input, SDVariable weights,
Conv3DConfig Conv3DConfig) {
SDValidation.validateNumerical("conv3d", "input", input);
SDValidation.validateNumerical("conv3d", "weights", weights);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.Conv3D(sd,input, weights, null, Conv3DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* 2D deconvolution operation with optional bias<br>
*
* @param layerInput the input to deconvolution 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param weights Weights for the 2d deconvolution operation. 4 dimensions with format [inputChannels, outputChannels, kernelHeight, kernelWidth] (NUMERIC type)
* @param bias Optional 1D bias array with shape [outputChannels]. May be null. (NUMERIC type)
* @param DeConv2DConfig Configuration Object
* @return output result of deconv2d op (NUMERIC type)
*/
public SDVariable deconv2d(SDVariable layerInput, SDVariable weights, SDVariable bias,
DeConv2DConfig DeConv2DConfig) {
SDValidation.validateNumerical("deconv2d", "layerInput", layerInput);
SDValidation.validateNumerical("deconv2d", "weights", weights);
SDValidation.validateNumerical("deconv2d", "bias", bias);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.DeConv2D(sd,layerInput, weights, bias, DeConv2DConfig).outputVariable();
}
/**
* 2D deconvolution operation with optional bias<br>
*
* @param name name May be null. Name for the output variable
* @param layerInput the input to deconvolution 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param weights Weights for the 2d deconvolution operation. 4 dimensions with format [inputChannels, outputChannels, kernelHeight, kernelWidth] (NUMERIC type)
* @param bias Optional 1D bias array with shape [outputChannels]. May be null. (NUMERIC type)
* @param DeConv2DConfig Configuration Object
* @return output result of deconv2d op (NUMERIC type)
*/
public SDVariable deconv2d(String name, SDVariable layerInput, SDVariable weights,
SDVariable bias, DeConv2DConfig DeConv2DConfig) {
SDValidation.validateNumerical("deconv2d", "layerInput", layerInput);
SDValidation.validateNumerical("deconv2d", "weights", weights);
SDValidation.validateNumerical("deconv2d", "bias", bias);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.DeConv2D(sd,layerInput, weights, bias, DeConv2DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* 2D deconvolution operation with optional bias<br>
*
* @param layerInput the input to deconvolution 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param weights Weights for the 2d deconvolution operation. 4 dimensions with format [inputChannels, outputChannels, kernelHeight, kernelWidth] (NUMERIC type)
* @param DeConv2DConfig Configuration Object
* @return output result of deconv2d op (NUMERIC type)
*/
public SDVariable deconv2d(SDVariable layerInput, SDVariable weights,
DeConv2DConfig DeConv2DConfig) {
SDValidation.validateNumerical("deconv2d", "layerInput", layerInput);
SDValidation.validateNumerical("deconv2d", "weights", weights);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.DeConv2D(sd,layerInput, weights, null, DeConv2DConfig).outputVariable();
}
/**
* 2D deconvolution operation with optional bias<br>
*
* @param name name May be null. Name for the output variable
* @param layerInput the input to deconvolution 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param weights Weights for the 2d deconvolution operation. 4 dimensions with format [inputChannels, outputChannels, kernelHeight, kernelWidth] (NUMERIC type)
* @param DeConv2DConfig Configuration Object
* @return output result of deconv2d op (NUMERIC type)
*/
public SDVariable deconv2d(String name, SDVariable layerInput, SDVariable weights,
DeConv2DConfig DeConv2DConfig) {
SDValidation.validateNumerical("deconv2d", "layerInput", layerInput);
SDValidation.validateNumerical("deconv2d", "weights", weights);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.DeConv2D(sd,layerInput, weights, null, DeConv2DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* 3D CNN deconvolution operation with or without optional bias<br>
*
* @param input Input array - shape [bS, iD, iH, iW, iC] (NDHWC) or [bS, iC, iD, iH, iW] (NCDHW) (NUMERIC type)
* @param weights Weights array - shape [kD, kH, kW, oC, iC] (NUMERIC type)
* @param bias Bias array - optional, may be null. If non-null, must have shape [outputChannels] (NUMERIC type)
* @param DeConv3DConfig Configuration Object
* @return output result of 3D CNN deconvolution operation (NUMERIC type)
*/
public SDVariable deconv3d(SDVariable input, SDVariable weights, SDVariable bias,
DeConv3DConfig DeConv3DConfig) {
SDValidation.validateNumerical("deconv3d", "input", input);
SDValidation.validateNumerical("deconv3d", "weights", weights);
SDValidation.validateNumerical("deconv3d", "bias", bias);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.DeConv3D(sd,input, weights, bias, DeConv3DConfig).outputVariable();
}
/**
* 3D CNN deconvolution operation with or without optional bias<br>
*
* @param name name May be null. Name for the output variable
* @param input Input array - shape [bS, iD, iH, iW, iC] (NDHWC) or [bS, iC, iD, iH, iW] (NCDHW) (NUMERIC type)
* @param weights Weights array - shape [kD, kH, kW, oC, iC] (NUMERIC type)
* @param bias Bias array - optional, may be null. If non-null, must have shape [outputChannels] (NUMERIC type)
* @param DeConv3DConfig Configuration Object
* @return output result of 3D CNN deconvolution operation (NUMERIC type)
*/
public SDVariable deconv3d(String name, SDVariable input, SDVariable weights, SDVariable bias,
DeConv3DConfig DeConv3DConfig) {
SDValidation.validateNumerical("deconv3d", "input", input);
SDValidation.validateNumerical("deconv3d", "weights", weights);
SDValidation.validateNumerical("deconv3d", "bias", bias);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.DeConv3D(sd,input, weights, bias, DeConv3DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* 3D CNN deconvolution operation with or without optional bias<br>
*
* @param input Input array - shape [bS, iD, iH, iW, iC] (NDHWC) or [bS, iC, iD, iH, iW] (NCDHW) (NUMERIC type)
* @param weights Weights array - shape [kD, kH, kW, oC, iC] (NUMERIC type)
* @param DeConv3DConfig Configuration Object
* @return output result of 3D CNN deconvolution operation (NUMERIC type)
*/
public SDVariable deconv3d(SDVariable input, SDVariable weights, DeConv3DConfig DeConv3DConfig) {
SDValidation.validateNumerical("deconv3d", "input", input);
SDValidation.validateNumerical("deconv3d", "weights", weights);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.DeConv3D(sd,input, weights, null, DeConv3DConfig).outputVariable();
}
/**
* 3D CNN deconvolution operation with or without optional bias<br>
*
* @param name name May be null. Name for the output variable
* @param input Input array - shape [bS, iD, iH, iW, iC] (NDHWC) or [bS, iC, iD, iH, iW] (NCDHW) (NUMERIC type)
* @param weights Weights array - shape [kD, kH, kW, oC, iC] (NUMERIC type)
* @param DeConv3DConfig Configuration Object
* @return output result of 3D CNN deconvolution operation (NUMERIC type)
*/
public SDVariable deconv3d(String name, SDVariable input, SDVariable weights,
DeConv3DConfig DeConv3DConfig) {
SDValidation.validateNumerical("deconv3d", "input", input);
SDValidation.validateNumerical("deconv3d", "weights", weights);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.DeConv3D(sd,input, weights, null, DeConv3DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Convolution 2d layer batch to space operation on 4d input.<br>
* Reduces input channels dimension by rearranging data into a larger spatial dimensions<br>
* Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2]<br>
* = [mb, 2, 4, 4]<br>
*
* @param x the input to depth to space pooling 2d operation - 4d activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param blockSize Block size, in the height/width dimension
* @param dataFormat Data format: "NCHW" or "NHWC"
* @return output Output variable (NUMERIC type)
*/
public SDVariable depthToSpace(SDVariable x, int blockSize, DataFormat dataFormat) {
SDValidation.validateNumerical("depthToSpace", "x", x);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.DepthToSpace(sd,x, blockSize, dataFormat).outputVariable();
}
/**
* Convolution 2d layer batch to space operation on 4d input.<br>
* Reduces input channels dimension by rearranging data into a larger spatial dimensions<br>
* Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2]<br>
* = [mb, 2, 4, 4]<br>
*
* @param name name May be null. Name for the output variable
* @param x the input to depth to space pooling 2d operation - 4d activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param blockSize Block size, in the height/width dimension
* @param dataFormat Data format: "NCHW" or "NHWC"
* @return output Output variable (NUMERIC type)
*/
public SDVariable depthToSpace(String name, SDVariable x, int blockSize, DataFormat dataFormat) {
SDValidation.validateNumerical("depthToSpace", "x", x);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.DepthToSpace(sd,x, blockSize, dataFormat).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Depth-wise 2D convolution operation with optional bias <br>
*
* @param layerInput the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (NUMERIC type)
* @param depthWeights Depth-wise conv2d weights. 4 dimensions with format [kernelHeight, kernelWidth, inputChannels, depthMultiplier] (NUMERIC type)
* @param bias Optional 1D bias array with shape [outputChannels]. May be null. (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output result of depthwise conv2d op (NUMERIC type)
*/
public SDVariable depthWiseConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable bias,
Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("depthWiseConv2d", "layerInput", layerInput);
SDValidation.validateNumerical("depthWiseConv2d", "depthWeights", depthWeights);
SDValidation.validateNumerical("depthWiseConv2d", "bias", bias);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.DepthwiseConv2D(sd,layerInput, depthWeights, bias, Conv2DConfig).outputVariable();
}
/**
* Depth-wise 2D convolution operation with optional bias <br>
*
* @param name name May be null. Name for the output variable
* @param layerInput the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (NUMERIC type)
* @param depthWeights Depth-wise conv2d weights. 4 dimensions with format [kernelHeight, kernelWidth, inputChannels, depthMultiplier] (NUMERIC type)
* @param bias Optional 1D bias array with shape [outputChannels]. May be null. (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output result of depthwise conv2d op (NUMERIC type)
*/
public SDVariable depthWiseConv2d(String name, SDVariable layerInput, SDVariable depthWeights,
SDVariable bias, Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("depthWiseConv2d", "layerInput", layerInput);
SDValidation.validateNumerical("depthWiseConv2d", "depthWeights", depthWeights);
SDValidation.validateNumerical("depthWiseConv2d", "bias", bias);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.DepthwiseConv2D(sd,layerInput, depthWeights, bias, Conv2DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Depth-wise 2D convolution operation with optional bias <br>
*
* @param layerInput the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (NUMERIC type)
* @param depthWeights Depth-wise conv2d weights. 4 dimensions with format [kernelHeight, kernelWidth, inputChannels, depthMultiplier] (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output result of depthwise conv2d op (NUMERIC type)
*/
public SDVariable depthWiseConv2d(SDVariable layerInput, SDVariable depthWeights,
Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("depthWiseConv2d", "layerInput", layerInput);
SDValidation.validateNumerical("depthWiseConv2d", "depthWeights", depthWeights);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.DepthwiseConv2D(sd,layerInput, depthWeights, null, Conv2DConfig).outputVariable();
}
/**
* Depth-wise 2D convolution operation with optional bias <br>
*
* @param name name May be null. Name for the output variable
* @param layerInput the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (NUMERIC type)
* @param depthWeights Depth-wise conv2d weights. 4 dimensions with format [kernelHeight, kernelWidth, inputChannels, depthMultiplier] (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output result of depthwise conv2d op (NUMERIC type)
*/
public SDVariable depthWiseConv2d(String name, SDVariable layerInput, SDVariable depthWeights,
Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("depthWiseConv2d", "layerInput", layerInput);
SDValidation.validateNumerical("depthWiseConv2d", "depthWeights", depthWeights);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.DepthwiseConv2D(sd,layerInput, depthWeights, null, Conv2DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* TODO doc string<br>
*
* @param df (NUMERIC type)
* @param weights df (NUMERIC type)
* @param strides weights (Size: Exactly(count=2))
* @param rates strides (Size: Exactly(count=2))
* @param isSameMode isSameMode
* @return output Computed the grayscale dilation of 4-D input and 3-D filters tensors. (NUMERIC type)
*/
public SDVariable dilation2D(SDVariable df, SDVariable weights, int[] strides, int[] rates,
boolean isSameMode) {
SDValidation.validateNumerical("dilation2D", "df", df);
SDValidation.validateNumerical("dilation2D", "weights", weights);
Preconditions.checkArgument(strides.length == 2, "strides has incorrect size/length. Expected: strides.length == 2, got %s", strides.length);
Preconditions.checkArgument(rates.length == 2, "rates has incorrect size/length. Expected: rates.length == 2, got %s", rates.length);
return new org.nd4j.linalg.api.ops.impl.transforms.custom.Dilation2D(sd,df, weights, strides, rates, isSameMode).outputVariable();
}
/**
* TODO doc string<br>
*
* @param name name May be null. Name for the output variable
* @param df (NUMERIC type)
* @param weights df (NUMERIC type)
* @param strides weights (Size: Exactly(count=2))
* @param rates strides (Size: Exactly(count=2))
* @param isSameMode isSameMode
* @return output Computed the grayscale dilation of 4-D input and 3-D filters tensors. (NUMERIC type)
*/
public SDVariable dilation2D(String name, SDVariable df, SDVariable weights, int[] strides,
int[] rates, boolean isSameMode) {
SDValidation.validateNumerical("dilation2D", "df", df);
SDValidation.validateNumerical("dilation2D", "weights", weights);
Preconditions.checkArgument(strides.length == 2, "strides has incorrect size/length. Expected: strides.length == 2, got %s", strides.length);
Preconditions.checkArgument(rates.length == 2, "rates has incorrect size/length. Expected: rates.length == 2, got %s", rates.length);
SDVariable out = new org.nd4j.linalg.api.ops.impl.transforms.custom.Dilation2D(sd,df, weights, strides, rates, isSameMode).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Extract image patches <br>
*
* @param input Input array. Must be rank 4, with shape [minibatch, height, width, channels] (NUMERIC type)
* @param kH Kernel height
* @param kW Kernel width
* @param sH Stride height
* @param sW Stride width
* @param rH Rate height
* @param rW Rate width
* @param sameMode If true: use same mode padding. If false
* @return output The result is a 4D tensor which is indexed by batch, row, and column. (NUMERIC type)
*/
public SDVariable extractImagePatches(SDVariable input, int kH, int kW, int sH, int sW, int rH,
int rW, boolean sameMode) {
SDValidation.validateNumerical("extractImagePatches", "input", input);
return new org.nd4j.linalg.api.ops.impl.image.ExtractImagePatches(sd,input, kH, kW, sH, sW, rH, rW, sameMode).outputVariable();
}
/**
* Extract image patches <br>
*
* @param name name May be null. Name for the output variable
* @param input Input array. Must be rank 4, with shape [minibatch, height, width, channels] (NUMERIC type)
* @param kH Kernel height
* @param kW Kernel width
* @param sH Stride height
* @param sW Stride width
* @param rH Rate height
* @param rW Rate width
* @param sameMode If true: use same mode padding. If false
* @return output The result is a 4D tensor which is indexed by batch, row, and column. (NUMERIC type)
*/
public SDVariable extractImagePatches(String name, SDVariable input, int kH, int kW, int sH,
int sW, int rH, int rW, boolean sameMode) {
SDValidation.validateNumerical("extractImagePatches", "input", input);
SDVariable out = new org.nd4j.linalg.api.ops.impl.image.ExtractImagePatches(sd,input, kH, kW, sH, sW, rH, rW, sameMode).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* im2col operation for use in 2D convolution operations. Outputs a 6d array with shape<br>
* [minibatch, inputChannels, kernelHeight, kernelWidth, outputHeight, outputWidth] <br>
*
* @param in Input - rank 4 input with shape [minibatch, inputChannels, height, width] (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output Im2Col output variable (NUMERIC type)
*/
public SDVariable im2Col(SDVariable in, Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("im2Col", "in", in);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.Im2col(sd,in, Conv2DConfig).outputVariable();
}
/**
* im2col operation for use in 2D convolution operations. Outputs a 6d array with shape<br>
* [minibatch, inputChannels, kernelHeight, kernelWidth, outputHeight, outputWidth] <br>
*
* @param name name May be null. Name for the output variable
* @param in Input - rank 4 input with shape [minibatch, inputChannels, height, width] (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output Im2Col output variable (NUMERIC type)
*/
public SDVariable im2Col(String name, SDVariable in, Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("im2Col", "in", in);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.Im2col(sd,in, Conv2DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* 2D convolution layer operation - local response normalization<br>
*
* @param input the inputs to lrn (NUMERIC type)
* @param LocalResponseNormalizationConfig Configuration Object
* @return output Result after Local Response Normalization (NUMERIC type)
*/
public SDVariable localResponseNormalization(SDVariable input,
LocalResponseNormalizationConfig LocalResponseNormalizationConfig) {
SDValidation.validateNumerical("localResponseNormalization", "input", input);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.LocalResponseNormalization(sd,input, LocalResponseNormalizationConfig).outputVariable();
}
/**
* 2D convolution layer operation - local response normalization<br>
*
* @param name name May be null. Name for the output variable
* @param input the inputs to lrn (NUMERIC type)
* @param LocalResponseNormalizationConfig Configuration Object
* @return output Result after Local Response Normalization (NUMERIC type)
*/
public SDVariable localResponseNormalization(String name, SDVariable input,
LocalResponseNormalizationConfig LocalResponseNormalizationConfig) {
SDValidation.validateNumerical("localResponseNormalization", "input", input);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.LocalResponseNormalization(sd,input, LocalResponseNormalizationConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* 2D Convolution layer operation - Max pooling on the input and outputs both max values and indices <br>
*
* @param input the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param Pooling2DConfig Configuration Object
*/
public SDVariable[] maxPoolWithArgmax(SDVariable input, Pooling2DConfig Pooling2DConfig) {
SDValidation.validateNumerical("maxPoolWithArgmax", "input", input);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.MaxPoolWithArgmax(sd,input, Pooling2DConfig).outputVariables();
}
/**
* 2D Convolution layer operation - Max pooling on the input and outputs both max values and indices <br>
*
* @param names names May be null. Arrays of names for the output variables.
* @param input the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param Pooling2DConfig Configuration Object
*/
public SDVariable[] maxPoolWithArgmax(String[] names, SDVariable input,
Pooling2DConfig Pooling2DConfig) {
SDValidation.validateNumerical("maxPoolWithArgmax", "input", input);
SDVariable[] out = new org.nd4j.linalg.api.ops.impl.layers.convolution.MaxPoolWithArgmax(sd,input, Pooling2DConfig).outputVariables();
return sd.updateVariableNamesAndReferences(out, names);
}
/**
* 2D Convolution layer operation - max pooling 2d <br>
*
* @param input the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param Pooling2DConfig Configuration Object
* @return output Result after applying max pooling on the input (NUMERIC type)
*/
public SDVariable maxPooling2d(SDVariable input, Pooling2DConfig Pooling2DConfig) {
SDValidation.validateNumerical("maxPooling2d", "input", input);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.MaxPooling2D(sd,input, Pooling2DConfig).outputVariable();
}
/**
* 2D Convolution layer operation - max pooling 2d <br>
*
* @param name name May be null. Name for the output variable
* @param input the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param Pooling2DConfig Configuration Object
* @return output Result after applying max pooling on the input (NUMERIC type)
*/
public SDVariable maxPooling2d(String name, SDVariable input, Pooling2DConfig Pooling2DConfig) {
SDValidation.validateNumerical("maxPooling2d", "input", input);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.MaxPooling2D(sd,input, Pooling2DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* 3D convolution layer operation - max pooling 3d operation.<br>
*
* @param input the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels]) (NUMERIC type)
* @param Pooling3DConfig Configuration Object
* @return output Result after applying max pooling on the input (NUMERIC type)
*/
public SDVariable maxPooling3d(SDVariable input, Pooling3DConfig Pooling3DConfig) {
SDValidation.validateNumerical("maxPooling3d", "input", input);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.MaxPooling3D(sd,input, Pooling3DConfig).outputVariable();
}
/**
* 3D convolution layer operation - max pooling 3d operation.<br>
*
* @param name name May be null. Name for the output variable
* @param input the input to average pooling 3d operation - 5d activations in NCDHW format (shape [minibatch, channels, depth, height, width]) or NDHWC format (shape [minibatch, depth, height, width, channels]) (NUMERIC type)
* @param Pooling3DConfig Configuration Object
* @return output Result after applying max pooling on the input (NUMERIC type)
*/
public SDVariable maxPooling3d(String name, SDVariable input, Pooling3DConfig Pooling3DConfig) {
SDValidation.validateNumerical("maxPooling3d", "input", input);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.MaxPooling3D(sd,input, Pooling3DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Separable 2D convolution operation with optional bias <br>
*
* @param layerInput the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param depthWeights Separable conv2d depth weights. 4 dimensions with format [kernelHeight, kernelWidth, inputChannels, depthMultiplier] (NUMERIC type)
* @param pointWeights Point weights, rank 4 with format [1, 1, inputChannels*depthMultiplier, outputChannels]. May be null (NUMERIC type)
* @param bias Optional bias, rank 1 with shape [outputChannels]. May be null. (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output result of separable convolution 2d operation (NUMERIC type)
*/
public SDVariable separableConv2d(SDVariable layerInput, SDVariable depthWeights,
SDVariable pointWeights, SDVariable bias, Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("separableConv2d", "layerInput", layerInput);
SDValidation.validateNumerical("separableConv2d", "depthWeights", depthWeights);
SDValidation.validateNumerical("separableConv2d", "pointWeights", pointWeights);
SDValidation.validateNumerical("separableConv2d", "bias", bias);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.SConv2D(sd,layerInput, depthWeights, pointWeights, bias, Conv2DConfig).outputVariable();
}
/**
* Separable 2D convolution operation with optional bias <br>
*
* @param name name May be null. Name for the output variable
* @param layerInput the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param depthWeights Separable conv2d depth weights. 4 dimensions with format [kernelHeight, kernelWidth, inputChannels, depthMultiplier] (NUMERIC type)
* @param pointWeights Point weights, rank 4 with format [1, 1, inputChannels*depthMultiplier, outputChannels]. May be null (NUMERIC type)
* @param bias Optional bias, rank 1 with shape [outputChannels]. May be null. (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output result of separable convolution 2d operation (NUMERIC type)
*/
public SDVariable separableConv2d(String name, SDVariable layerInput, SDVariable depthWeights,
SDVariable pointWeights, SDVariable bias, Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("separableConv2d", "layerInput", layerInput);
SDValidation.validateNumerical("separableConv2d", "depthWeights", depthWeights);
SDValidation.validateNumerical("separableConv2d", "pointWeights", pointWeights);
SDValidation.validateNumerical("separableConv2d", "bias", bias);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.SConv2D(sd,layerInput, depthWeights, pointWeights, bias, Conv2DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Separable 2D convolution operation with optional bias <br>
*
* @param layerInput the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param depthWeights Separable conv2d depth weights. 4 dimensions with format [kernelHeight, kernelWidth, inputChannels, depthMultiplier] (NUMERIC type)
* @param pointWeights Point weights, rank 4 with format [1, 1, inputChannels*depthMultiplier, outputChannels]. May be null (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output result of separable convolution 2d operation (NUMERIC type)
*/
public SDVariable separableConv2d(SDVariable layerInput, SDVariable depthWeights,
SDVariable pointWeights, Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("separableConv2d", "layerInput", layerInput);
SDValidation.validateNumerical("separableConv2d", "depthWeights", depthWeights);
SDValidation.validateNumerical("separableConv2d", "pointWeights", pointWeights);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.SConv2D(sd,layerInput, depthWeights, pointWeights, null, Conv2DConfig).outputVariable();
}
/**
* Separable 2D convolution operation with optional bias <br>
*
* @param name name May be null. Name for the output variable
* @param layerInput the input to max pooling 2d operation - 4d CNN (image) activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param depthWeights Separable conv2d depth weights. 4 dimensions with format [kernelHeight, kernelWidth, inputChannels, depthMultiplier] (NUMERIC type)
* @param pointWeights Point weights, rank 4 with format [1, 1, inputChannels*depthMultiplier, outputChannels]. May be null (NUMERIC type)
* @param Conv2DConfig Configuration Object
* @return output result of separable convolution 2d operation (NUMERIC type)
*/
public SDVariable separableConv2d(String name, SDVariable layerInput, SDVariable depthWeights,
SDVariable pointWeights, Conv2DConfig Conv2DConfig) {
SDValidation.validateNumerical("separableConv2d", "layerInput", layerInput);
SDValidation.validateNumerical("separableConv2d", "depthWeights", depthWeights);
SDValidation.validateNumerical("separableConv2d", "pointWeights", pointWeights);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.SConv2D(sd,layerInput, depthWeights, pointWeights, null, Conv2DConfig).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Convolution 2d layer space to batch operation on 4d input.<br>
* Increases input batch dimension by rearranging data from spatial dimensions into batch dimension <br>
*
* @param x Input variable. 4d input (NUMERIC type)
* @param blocks Block size, in the height/width dimension (Size: Exactly(count=2))
* @param paddingTop Optional 2d int[] array for padding the result: values [[pad top, pad bottom], [pad left, pad right]] (Size: Exactly(count=2))
* @param paddingBottom Optional 2d int[] array for padding the result: values [[pad top, pad bottom], [pad left, pad right]] (Size: Exactly(count=2))
* @return output Output variable (NUMERIC type)
*/
public SDVariable spaceToBatch(SDVariable x, int[] blocks, int[] paddingTop,
int... paddingBottom) {
SDValidation.validateNumerical("spaceToBatch", "x", x);
Preconditions.checkArgument(blocks.length == 2, "blocks has incorrect size/length. Expected: blocks.length == 2, got %s", blocks.length);
Preconditions.checkArgument(paddingTop.length == 2, "paddingTop has incorrect size/length. Expected: paddingTop.length == 2, got %s", paddingTop.length);
Preconditions.checkArgument(paddingBottom.length == 2, "paddingBottom has incorrect size/length. Expected: paddingBottom.length == 2, got %s", paddingBottom.length);
return new org.nd4j.linalg.api.ops.impl.transforms.custom.SpaceToBatch(sd,x, blocks, paddingTop, paddingBottom).outputVariable();
}
/**
* Convolution 2d layer space to batch operation on 4d input.<br>
* Increases input batch dimension by rearranging data from spatial dimensions into batch dimension <br>
*
* @param name name May be null. Name for the output variable
* @param x Input variable. 4d input (NUMERIC type)
* @param blocks Block size, in the height/width dimension (Size: Exactly(count=2))
* @param paddingTop Optional 2d int[] array for padding the result: values [[pad top, pad bottom], [pad left, pad right]] (Size: Exactly(count=2))
* @param paddingBottom Optional 2d int[] array for padding the result: values [[pad top, pad bottom], [pad left, pad right]] (Size: Exactly(count=2))
* @return output Output variable (NUMERIC type)
*/
public SDVariable spaceToBatch(String name, SDVariable x, int[] blocks, int[] paddingTop,
int... paddingBottom) {
SDValidation.validateNumerical("spaceToBatch", "x", x);
Preconditions.checkArgument(blocks.length == 2, "blocks has incorrect size/length. Expected: blocks.length == 2, got %s", blocks.length);
Preconditions.checkArgument(paddingTop.length == 2, "paddingTop has incorrect size/length. Expected: paddingTop.length == 2, got %s", paddingTop.length);
Preconditions.checkArgument(paddingBottom.length == 2, "paddingBottom has incorrect size/length. Expected: paddingBottom.length == 2, got %s", paddingBottom.length);
SDVariable out = new org.nd4j.linalg.api.ops.impl.transforms.custom.SpaceToBatch(sd,x, blocks, paddingTop, paddingBottom).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Convolution 2d layer space to depth operation on 4d input.<br>
* Increases input channels (reduced spatial dimensions) by rearranging data into a larger channels dimension<br>
* Example: if input has shape [mb, 2, 4, 4] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2]<br>
* = [mb, 2, 4, 4] <br>
*
* @param x the input to depth to space pooling 2d operation - 4d activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param blockSize Block size, in the height/width dimension
* @param dataFormat Data format: "NCHW" or "NHWC"
* @return output Output variable (NUMERIC type)
*/
public SDVariable spaceToDepth(SDVariable x, int blockSize, DataFormat dataFormat) {
SDValidation.validateNumerical("spaceToDepth", "x", x);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.SpaceToDepth(sd,x, blockSize, dataFormat).outputVariable();
}
/**
* Convolution 2d layer space to depth operation on 4d input.<br>
* Increases input channels (reduced spatial dimensions) by rearranging data into a larger channels dimension<br>
* Example: if input has shape [mb, 2, 4, 4] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2]<br>
* = [mb, 2, 4, 4] <br>
*
* @param name name May be null. Name for the output variable
* @param x the input to depth to space pooling 2d operation - 4d activations in NCHW format (shape [minibatch, channels, height, width]) or NHWC format (shape [minibatch, height, width, channels]) (NUMERIC type)
* @param blockSize Block size, in the height/width dimension
* @param dataFormat Data format: "NCHW" or "NHWC"
* @return output Output variable (NUMERIC type)
*/
public SDVariable spaceToDepth(String name, SDVariable x, int blockSize, DataFormat dataFormat) {
SDValidation.validateNumerical("spaceToDepth", "x", x);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.SpaceToDepth(sd,x, blockSize, dataFormat).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* Upsampling layer for 2D inputs.<br>
* scale is used for both height and width dimensions. <br>
*
* @param input Input in NCHW format (NUMERIC type)
* @param scale The scale for both height and width dimensions.
* @return output Upsampled input (NUMERIC type)
*/
public SDVariable upsampling2d(SDVariable input, int scale) {
SDValidation.validateNumerical("upsampling2d", "input", input);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.Upsampling2d(sd,input, scale).outputVariable();
}
/**
* Upsampling layer for 2D inputs.<br>
* scale is used for both height and width dimensions. <br>
*
* @param name name May be null. Name for the output variable
* @param input Input in NCHW format (NUMERIC type)
* @param scale The scale for both height and width dimensions.
* @return output Upsampled input (NUMERIC type)
*/
public SDVariable upsampling2d(String name, SDVariable input, int scale) {
SDValidation.validateNumerical("upsampling2d", "input", input);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.Upsampling2d(sd,input, scale).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* 2D Convolution layer operation - Upsampling 2d <br>
*
* @param input Input in NCHW format (NUMERIC type)
* @param scaleH Scale to upsample in height dimension
* @param scaleW Scale to upsample in width dimension
* @param nchw If true: input is in NCHW (minibatch, channels, height, width) format. False: NHWC format
* @return output Upsampled input (NUMERIC type)
*/
public SDVariable upsampling2d(SDVariable input, int scaleH, int scaleW, boolean nchw) {
SDValidation.validateNumerical("upsampling2d", "input", input);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.Upsampling2d(sd,input, scaleH, scaleW, nchw).outputVariable();
}
/**
* 2D Convolution layer operation - Upsampling 2d <br>
*
* @param name name May be null. Name for the output variable
* @param input Input in NCHW format (NUMERIC type)
* @param scaleH Scale to upsample in height dimension
* @param scaleW Scale to upsample in width dimension
* @param nchw If true: input is in NCHW (minibatch, channels, height, width) format. False: NHWC format
* @return output Upsampled input (NUMERIC type)
*/
public SDVariable upsampling2d(String name, SDVariable input, int scaleH, int scaleW,
boolean nchw) {
SDValidation.validateNumerical("upsampling2d", "input", input);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.Upsampling2d(sd,input, scaleH, scaleW, nchw).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
/**
* 3D Convolution layer operation - Upsampling 3d <br>
*
* @param input Input in NCHW format (NUMERIC type)
* @param ncdhw If true: input is in NCDHW (minibatch, channels, depth, height, width) format. False: NDHWC format
* @param scaleD Scale to upsample in depth dimension
* @param scaleH Scale to upsample in height dimension
* @param scaleW Scale to upsample in width dimension
* @return output Upsampled input (NUMERIC type)
*/
public SDVariable upsampling3d(SDVariable input, boolean ncdhw, int scaleD, int scaleH,
int scaleW) {
SDValidation.validateNumerical("upsampling3d", "input", input);
return new org.nd4j.linalg.api.ops.impl.layers.convolution.Upsampling3d(sd,input, ncdhw, scaleD, scaleH, scaleW).outputVariable();
}
/**
* 3D Convolution layer operation - Upsampling 3d <br>
*
* @param name name May be null. Name for the output variable
* @param input Input in NCHW format (NUMERIC type)
* @param ncdhw If true: input is in NCDHW (minibatch, channels, depth, height, width) format. False: NDHWC format
* @param scaleD Scale to upsample in depth dimension
* @param scaleH Scale to upsample in height dimension
* @param scaleW Scale to upsample in width dimension
* @return output Upsampled input (NUMERIC type)
*/
public SDVariable upsampling3d(String name, SDVariable input, boolean ncdhw, int scaleD,
int scaleH, int scaleW) {
SDValidation.validateNumerical("upsampling3d", "input", input);
SDVariable out = new org.nd4j.linalg.api.ops.impl.layers.convolution.Upsampling3d(sd,input, ncdhw, scaleD, scaleH, scaleW).outputVariable();
return sd.updateVariableNameAndReference(out, name);
}
}