PythonZooKeras

Instance Constructors

new PythonZooKeras()(implicit arg0: ClassTag[T], ev: TensorNumeric[T])

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def activityToJTensors(outputActivity: Activity): List[JTensor]

Definition Classes
PythonBigDL
def addScheduler(seq: SequentialSchedule, scheduler: LearningRateSchedule, maxIteration: Int): SequentialSchedule

Definition Classes
PythonBigDL
final def asInstanceOf[T0]: T0

Definition Classes
Any
def batching(dataset: DataSet[Sample[T]], batchSize: Int): DataSet[MiniBatch[T]]

Definition Classes
PythonBigDL
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def compile(module: KerasModel[T], optimizer: OptimMethod[T], loss: Criterion[T], metrics: List[ValidationMethod[T]]): Unit

Definition Classes
PythonBigDLKeras
def connectInputs(module: AbstractModule[Activity, Activity, T], x: List[Variable[T]]): Variable[T]
def createAUC(thresholdNum: Int): ValidationMethod[T]
def createAbs(): Abs[T]

Definition Classes
PythonBigDL
def createAbsCriterion(sizeAverage: Boolean): AbsCriterion[T]

Definition Classes
PythonBigDL
def createActivityRegularization(l1: Double, l2: Double): ActivityRegularization[T]

Definition Classes
PythonBigDL
def createAdadelta(decayRate: Double, Epsilon: Double): Adadelta[T]

Definition Classes
PythonBigDL
def createAdagrad(learningRate: Double, learningRateDecay: Double, weightDecay: Double): Adagrad[T]

Definition Classes
PythonBigDL
def createAdam(learningRate: Double, learningRateDecay: Double, beta1: Double, beta2: Double, Epsilon: Double): Adam[T]

Definition Classes
PythonBigDL
def createAdamax(learningRate: Double, beta1: Double, beta2: Double, Epsilon: Double): Adamax[T]

Definition Classes
PythonBigDL
def createAdd(inputSize: Int): Add[T]

Definition Classes
PythonBigDL
def createAddConstant(constant_scalar: Double, inplace: Boolean): AddConstant[T]

Definition Classes
PythonBigDL
def createAspectScale(scale: Int, scaleMultipleOf: Int, maxSize: Int, resizeMode: Int, useScaleFactor: Boolean, minScale: Double): FeatureTransformer

Definition Classes
PythonBigDL
def createBCECriterion(weights: JTensor, sizeAverage: Boolean): BCECriterion[T]

Definition Classes
PythonBigDL
def createBatchNormalization(nOutput: Int, eps: Double, momentum: Double, affine: Boolean, initWeight: JTensor, initBias: JTensor, initGradWeight: JTensor, initGradBias: JTensor): BatchNormalization[T]

Definition Classes
PythonBigDL
def createBiRecurrent(merge: AbstractModule[Table, Tensor[T], T]): BiRecurrent[T]

Definition Classes
PythonBigDL
def createBifurcateSplitTable(dimension: Int): BifurcateSplitTable[T]

Definition Classes
PythonBigDL
def createBilinear(inputSize1: Int, inputSize2: Int, outputSize: Int, biasRes: Boolean, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T]): Bilinear[T]

Definition Classes
PythonBigDL
def createBilinearFiller(): BilinearFiller.type

Definition Classes
PythonBigDL
def createBinaryThreshold(th: Double, ip: Boolean): BinaryThreshold[T]

Definition Classes
PythonBigDL
def createBinaryTreeLSTM(inputSize: Int, hiddenSize: Int, gateOutput: Boolean, withGraph: Boolean): BinaryTreeLSTM[T]

Definition Classes
PythonBigDL
def createBottle(module: AbstractModule[Activity, Activity, T], nInputDim: Int, nOutputDim1: Int): Bottle[T]

Definition Classes
PythonBigDL
def createBrightness(deltaLow: Double, deltaHigh: Double): Brightness

Definition Classes
PythonBigDL
def createBytesToMat(byteKey: String): BytesToMat

Definition Classes
PythonBigDL
def createCAdd(size: List[Int], bRegularizer: Regularizer[T]): CAdd[T]

Definition Classes
PythonBigDL
def createCAddTable(inplace: Boolean): CAddTable[T, T]

Definition Classes
PythonBigDL
def createCAveTable(inplace: Boolean): CAveTable[T]

Definition Classes
PythonBigDL
def createCDivTable(): CDivTable[T]

Definition Classes
PythonBigDL
def createCMaxTable(): CMaxTable[T]

Definition Classes
PythonBigDL
def createCMinTable(): CMinTable[T]

Definition Classes
PythonBigDL
def createCMul(size: List[Int], wRegularizer: Regularizer[T]): CMul[T]

Definition Classes
PythonBigDL
def createCMulTable(): CMulTable[T]

Definition Classes
PythonBigDL
def createCSubTable(): CSubTable[T]

Definition Classes
PythonBigDL
def createCategoricalCrossEntropy(): CategoricalCrossEntropy[T]

Definition Classes
PythonBigDL
def createCenterCrop(cropWidth: Int, cropHeight: Int, isClip: Boolean): CenterCrop

Definition Classes
PythonBigDL
def createChannelNormalize(meanR: Double, meanG: Double, meanB: Double, stdR: Double, stdG: Double, stdB: Double): FeatureTransformer

Definition Classes
PythonBigDL
def createChannelOrder(): ChannelOrder

Definition Classes
PythonBigDL
def createClamp(min: Int, max: Int): Clamp[T]

Definition Classes
PythonBigDL
def createClassNLLCriterion(weights: JTensor, sizeAverage: Boolean, logProbAsInput: Boolean): ClassNLLCriterion[T]

Definition Classes
PythonBigDL
def createClassSimplexCriterion(nClasses: Int): ClassSimplexCriterion[T]

Definition Classes
PythonBigDL
def createColorJitter(brightnessProb: Double, brightnessDelta: Double, contrastProb: Double, contrastLower: Double, contrastUpper: Double, hueProb: Double, hueDelta: Double, saturationProb: Double, saturationLower: Double, saturationUpper: Double, randomOrderProb: Double, shuffle: Boolean): ColorJitter

Definition Classes
PythonBigDL
def createConcat(dimension: Int): Concat[T]

Definition Classes
PythonBigDL
def createConcatTable(): ConcatTable[T]

Definition Classes
PythonBigDL
def createConstInitMethod(value: Double): ConstInitMethod

Definition Classes
PythonBigDL
def createContiguous(): Contiguous[T]

Definition Classes
PythonBigDL
def createContrast(deltaLow: Double, deltaHigh: Double): Contrast

Definition Classes
PythonBigDL
def createConvLSTMPeephole(inputSize: Int, outputSize: Int, kernelI: Int, kernelC: Int, stride: Int, padding: Int, activation: TensorModule[T], innerActivation: TensorModule[T], wRegularizer: Regularizer[T], uRegularizer: Regularizer[T], bRegularizer: Regularizer[T], cRegularizer: Regularizer[T], withPeephole: Boolean): ConvLSTMPeephole[T]

Definition Classes
PythonBigDL
def createConvLSTMPeephole3D(inputSize: Int, outputSize: Int, kernelI: Int, kernelC: Int, stride: Int, padding: Int, wRegularizer: Regularizer[T], uRegularizer: Regularizer[T], bRegularizer: Regularizer[T], cRegularizer: Regularizer[T], withPeephole: Boolean): ConvLSTMPeephole3D[T]

Definition Classes
PythonBigDL
def createCosine(inputSize: Int, outputSize: Int): Cosine[T]

Definition Classes
PythonBigDL
def createCosineDistance(): CosineDistance[T]

Definition Classes
PythonBigDL
def createCosineDistanceCriterion(sizeAverage: Boolean): CosineDistanceCriterion[T]

Definition Classes
PythonBigDL
def createCosineEmbeddingCriterion(margin: Double, sizeAverage: Boolean): CosineEmbeddingCriterion[T]

Definition Classes
PythonBigDL
def createCosineProximityCriterion(): CosineProximityCriterion[T]

Definition Classes
PythonBigDL
def createCropping2D(heightCrop: List[Int], widthCrop: List[Int], dataFormat: String): Cropping2D[T]

Definition Classes
PythonBigDL
def createCropping3D(dim1Crop: List[Int], dim2Crop: List[Int], dim3Crop: List[Int], dataFormat: String): Cropping3D[T]

Definition Classes
PythonBigDL
def createCrossEntropyCriterion(weights: JTensor, sizeAverage: Boolean): CrossEntropyCriterion[T]

Definition Classes
PythonBigDL
def createCrossProduct(numTensor: Int, embeddingSize: Int): CrossProduct[T]

Definition Classes
PythonBigDL
def createDLClassifier(model: Module[T], criterion: Criterion[T], featureSize: ArrayList[Int], labelSize: ArrayList[Int]): DLClassifier[T]

Definition Classes
PythonBigDL
def createDLClassifierModel(model: Module[T], featureSize: ArrayList[Int]): DLClassifierModel[T]

Definition Classes
PythonBigDL
def createDLEstimator(model: Module[T], criterion: Criterion[T], featureSize: ArrayList[Int], labelSize: ArrayList[Int]): DLEstimator[T]

Definition Classes
PythonBigDL
def createDLImageTransformer(transformer: FeatureTransformer): DLImageTransformer

Definition Classes
PythonBigDL
def createDLModel(model: Module[T], featureSize: ArrayList[Int]): DLModel[T]

Definition Classes
PythonBigDL
def createDatasetFromImageFrame(imageFrame: ImageFrame): DataSet[ImageFeature]

Definition Classes
PythonBigDL
def createDefault(): Default

Definition Classes
PythonBigDL
def createDenseToSparse(): DenseToSparse[T]

Definition Classes
PythonBigDL
def createDetectionCrop(roiKey: String, normalized: Boolean): DetectionCrop

Definition Classes
PythonBigDL
def createDetectionOutputFrcnn(nmsThresh: Float, nClasses: Int, bboxVote: Boolean, maxPerImage: Int, thresh: Double): DetectionOutputFrcnn

Definition Classes
PythonBigDL
def createDetectionOutputSSD(nClasses: Int, shareLocation: Boolean, bgLabel: Int, nmsThresh: Double, nmsTopk: Int, keepTopK: Int, confThresh: Double, varianceEncodedInTarget: Boolean, confPostProcess: Boolean): DetectionOutputSSD[T]

Definition Classes
PythonBigDL
def createDiceCoefficientCriterion(sizeAverage: Boolean, epsilon: Float): DiceCoefficientCriterion[T]

Definition Classes
PythonBigDL
def createDistKLDivCriterion(sizeAverage: Boolean): DistKLDivCriterion[T]

Definition Classes
PythonBigDL
def createDistriOptimizer(model: AbstractModule[Activity, Activity, T], trainingRdd: JavaRDD[Sample], criterion: Criterion[T], optimMethod: OptimMethod[T], endTrigger: Trigger, batchSize: Int): Optimizer[T, MiniBatch[T]]

Definition Classes
PythonBigDL
def createDistriOptimizerFromDataSet(model: AbstractModule[Activity, Activity, T], trainDataSet: DataSet[ImageFeature], criterion: Criterion[T], optimMethod: OptimMethod[T], endTrigger: Trigger, batchSize: Int): Optimizer[T, MiniBatch[T]]

Definition Classes
PythonBigDL
def createDistributedImageFrame(imageRdd: JavaRDD[JTensor], labelRdd: JavaRDD[JTensor]): DistributedImageFrame

Definition Classes
PythonBigDL
def createDotProduct(): DotProduct[T]

Definition Classes
PythonBigDL
def createDotProductCriterion(sizeAverage: Boolean): DotProductCriterion[T]

Definition Classes
PythonBigDL
def createDropout(initP: Double, inplace: Boolean, scale: Boolean): Dropout[T]

Definition Classes
PythonBigDL
def createELU(alpha: Double, inplace: Boolean): ELU[T]

Definition Classes
PythonBigDL
def createEcho(): Echo[T]

Definition Classes
PythonBigDL
def createEuclidean(inputSize: Int, outputSize: Int, fastBackward: Boolean): Euclidean[T]

Definition Classes
PythonBigDL
def createEveryEpoch(): Trigger

Definition Classes
PythonBigDL
def createExp(): Exp[T]

Definition Classes
PythonBigDL
def createExpand(meansR: Int, meansG: Int, meansB: Int, minExpandRatio: Double, maxExpandRatio: Double): Expand

Definition Classes
PythonBigDL
def createExponential(decayStep: Int, decayRate: Double, stairCase: Boolean): Exponential

Definition Classes
PythonBigDL
def createFiller(startX: Double, startY: Double, endX: Double, endY: Double, value: Int): Filler

Definition Classes
PythonBigDL
def createFixExpand(eh: Int, ew: Int): FixExpand

Definition Classes
PythonBigDL
def createFixedCrop(wStart: Double, hStart: Double, wEnd: Double, hEnd: Double, normalized: Boolean, isClip: Boolean): FixedCrop

Definition Classes
PythonBigDL
def createFlattenTable(): FlattenTable[T]

Definition Classes
PythonBigDL
def createGRU(inputSize: Int, outputSize: Int, p: Double, activation: TensorModule[T], innerActivation: TensorModule[T], wRegularizer: Regularizer[T], uRegularizer: Regularizer[T], bRegularizer: Regularizer[T]): GRU[T]

Definition Classes
PythonBigDL
def createGaussianCriterion(): GaussianCriterion[T]

Definition Classes
PythonBigDL
def createGaussianDropout(rate: Double): GaussianDropout[T]

Definition Classes
PythonBigDL
def createGaussianNoise(stddev: Double): GaussianNoise[T]

Definition Classes
PythonBigDL
def createGaussianSampler(): GaussianSampler[T]

Definition Classes
PythonBigDL
def createGradientReversal(lambda: Double): GradientReversal[T]

Definition Classes
PythonBigDL
def createHFlip(): HFlip

Definition Classes
PythonBigDL
def createHardShrink(lambda: Double): HardShrink[T]

Definition Classes
PythonBigDL
def createHardSigmoid: HardSigmoid[T]

Definition Classes
PythonBigDL
def createHardTanh(minValue: Double, maxValue: Double, inplace: Boolean): HardTanh[T]

Definition Classes
PythonBigDL
def createHighway(size: Int, withBias: Boolean, activation: TensorModule[T], wRegularizer: Regularizer[T], bRegularizer: Regularizer[T]): Graph[T]

Definition Classes
PythonBigDL
def createHingeEmbeddingCriterion(margin: Double, sizeAverage: Boolean): HingeEmbeddingCriterion[T]

Definition Classes
PythonBigDL
def createHue(deltaLow: Double, deltaHigh: Double): Hue

Definition Classes
PythonBigDL
def createIdentity(): Identity[T]

Definition Classes
PythonBigDL
def createImageFeature(data: JTensor, label: JTensor, uri: String): ImageFeature

Definition Classes
PythonBigDL
def createImageFrameToSample(inputKeys: List[String], targetKeys: List[String], sampleKey: String): ImageFrameToSample[T]

Definition Classes
PythonBigDL
def createIndex(dimension: Int): Index[T]

Definition Classes
PythonBigDL
def createInferReshape(size: List[Int], batchMode: Boolean): InferReshape[T]

Definition Classes
PythonBigDL
def createInput(): ModuleNode[T]

Definition Classes
PythonBigDL
def createJoinTable(dimension: Int, nInputDims: Int): JoinTable[T]

Definition Classes
PythonBigDL
def createKLDCriterion(sizeAverage: Boolean): KLDCriterion[T]

Definition Classes
PythonBigDL
def createKerasActivation(activation: String, inputShape: List[Int]): Activation[T]

Definition Classes
PythonBigDLKeras
def createKerasAtrousConvolution1D(nbFilter: Int, filterLength: Int, init: String, activation: String, subsampleLength: Int, atrousRate: Int, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], inputShape: List[Int]): AtrousConvolution1D[T]

Definition Classes
PythonBigDLKeras
def createKerasAtrousConvolution2D(nbFilter: Int, nbRow: Int, nbCol: Int, init: String, activation: String, subsample: List[Int], atrousRate: List[Int], dimOrdering: String, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], inputShape: List[Int]): AtrousConvolution2D[T]

Definition Classes
PythonBigDLKeras
def createKerasAveragePooling1D(poolLength: Int, stride: Int, borderMode: String, inputShape: List[Int]): AveragePooling1D[T]

Definition Classes
PythonBigDLKeras
def createKerasAveragePooling2D(poolSize: List[Int], strides: List[Int], borderMode: String, dimOrdering: String, inputShape: List[Int]): AveragePooling2D[T]

Definition Classes
PythonBigDLKeras
def createKerasAveragePooling3D(poolSize: List[Int], strides: List[Int], dimOrdering: String, inputShape: List[Int]): AveragePooling3D[T]

Definition Classes
PythonBigDLKeras
def createKerasBatchNormalization(epsilon: Double, momentum: Double, betaInit: String, gammaInit: String, dimOrdering: String, inputShape: List[Int]): BatchNormalization[T]

Definition Classes
PythonBigDLKeras
def createKerasBidirectional(layer: Recurrent[T], mergeMode: String, inputShape: List[Int]): Bidirectional[T]

Definition Classes
PythonBigDLKeras
def createKerasConvLSTM2D(nbFilter: Int, nbKernel: Int, activation: String, innerActivation: String, dimOrdering: String, subsample: Int, wRegularizer: Regularizer[T], uRegularizer: Regularizer[T], bRegularizer: Regularizer[T], returnSequences: Boolean, goBackwards: Boolean, inputShape: List[Int]): ConvLSTM2D[T]

Definition Classes
PythonBigDLKeras
def createKerasConvolution1D(nbFilter: Int, filterLength: Int, init: String, activation: String, borderMode: String, subsampleLength: Int, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], bias: Boolean, inputShape: List[Int]): Convolution1D[T]

Definition Classes
PythonBigDLKeras
def createKerasConvolution2D(nbFilter: Int, nbRow: Int, nbCol: Int, init: String, activation: String, borderMode: String, subsample: List[Int], dimOrdering: String, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], bias: Boolean, inputShape: List[Int]): Convolution2D[T]

Definition Classes
PythonBigDLKeras
def createKerasConvolution3D(nbFilter: Int, kernelDim1: Int, kernelDim2: Int, kernelDim3: Int, init: String, activation: String, borderMode: String, subsample: List[Int], dimOrdering: String, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], bias: Boolean, inputShape: List[Int]): Convolution3D[T]

Definition Classes
PythonBigDLKeras
def createKerasCropping1D(cropping: List[Int], inputShape: List[Int]): Cropping1D[T]

Definition Classes
PythonBigDLKeras
def createKerasCropping2D(heightCrop: List[Int], widthCrop: List[Int], dimOrdering: String, inputShape: List[Int]): Cropping2D[T]

Definition Classes
PythonBigDLKeras
def createKerasCropping3D(dim1Crop: List[Int], dim2Crop: List[Int], dim3Crop: List[Int], dimOrdering: String, inputShape: List[Int]): Cropping3D[T]

Definition Classes
PythonBigDLKeras
def createKerasDeconvolution2D(nbFilter: Int, nbRow: Int, nbCol: Int, init: String, activation: String, subsample: List[Int], dimOrdering: String, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], bias: Boolean, inputShape: List[Int]): Deconvolution2D[T]

Definition Classes
PythonBigDLKeras
def createKerasDense(outputDim: Int, init: String, activation: String, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], bias: Boolean, inputShape: List[Int]): Dense[T]

Definition Classes
PythonBigDLKeras
def createKerasDropout(p: Double, inputShape: List[Int]): Dropout[T]

Definition Classes
PythonBigDLKeras
def createKerasELU(alpha: Double, inputShape: List[Int]): ELU[T]

Definition Classes
PythonBigDLKeras
def createKerasEmbedding(inputDim: Int, outputDim: Int, init: String, wRegularizer: Regularizer[T], inputShape: List[Int]): Embedding[T]

Definition Classes
PythonBigDLKeras
def createKerasFlatten(inputShape: List[Int]): Flatten[T]

Definition Classes
PythonBigDLKeras
def createKerasGRU(outputDim: Int, activation: String, innerActivation: String, returnSequences: Boolean, goBackwards: Boolean, wRegularizer: Regularizer[T], uRegularizer: Regularizer[T], bRegularizer: Regularizer[T], inputShape: List[Int]): GRU[T]

Definition Classes
PythonBigDLKeras
def createKerasGaussianDropout(p: Double, inputShape: List[Int]): GaussianDropout[T]

Definition Classes
PythonBigDLKeras
def createKerasGaussianNoise(sigma: Double, inputShape: List[Int]): GaussianNoise[T]

Definition Classes
PythonBigDLKeras
def createKerasGlobalAveragePooling1D(inputShape: List[Int]): GlobalAveragePooling1D[T]

Definition Classes
PythonBigDLKeras
def createKerasGlobalAveragePooling2D(dimOrdering: String, inputShape: List[Int]): GlobalAveragePooling2D[T]

Definition Classes
PythonBigDLKeras
def createKerasGlobalAveragePooling3D(dimOrdering: String, inputShape: List[Int]): GlobalAveragePooling3D[T]

Definition Classes
PythonBigDLKeras
def createKerasGlobalMaxPooling1D(inputShape: List[Int]): GlobalMaxPooling1D[T]

Definition Classes
PythonBigDLKeras
def createKerasGlobalMaxPooling2D(dimOrdering: String, inputShape: List[Int]): GlobalMaxPooling2D[T]

Definition Classes
PythonBigDLKeras
def createKerasGlobalMaxPooling3D(dimOrdering: String, inputShape: List[Int]): GlobalMaxPooling3D[T]

Definition Classes
PythonBigDLKeras
def createKerasHighway(activation: String, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], bias: Boolean, inputShape: List[Int]): Highway[T]

Definition Classes
PythonBigDLKeras
def createKerasInput(name: String, inputShape: List[Int]): ModuleNode[T]

Definition Classes
PythonBigDLKeras
def createKerasInputLayer(inputShape: List[Int]): KerasLayer[Activity, Activity, T]

Definition Classes
PythonBigDLKeras
def createKerasLSTM(outputDim: Int, activation: String, innerActivation: String, returnSequences: Boolean, goBackwards: Boolean, wRegularizer: Regularizer[T], uRegularizer: Regularizer[T], bRegularizer: Regularizer[T], inputShape: List[Int]): LSTM[T]

Definition Classes
PythonBigDLKeras
def createKerasLeakyReLU(alpha: Double, inputShape: List[Int]): LeakyReLU[T]

Definition Classes
PythonBigDLKeras
def createKerasLocallyConnected1D(nbFilter: Int, filterLength: Int, activation: String, subsampleLength: Int, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], bias: Boolean, inputShape: List[Int]): LocallyConnected1D[T]

Definition Classes
PythonBigDLKeras
def createKerasLocallyConnected2D(nbFilter: Int, nbRow: Int, nbCol: Int, activation: String, borderMode: String, subsample: List[Int], dimOrdering: String, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], bias: Boolean, inputShape: List[Int]): LocallyConnected2D[T]

Definition Classes
PythonBigDLKeras
def createKerasMasking(maskValue: Double, inputShape: List[Int]): Masking[T]

Definition Classes
PythonBigDLKeras
def createKerasMaxPooling1D(poolLength: Int, stride: Int, borderMode: String, inputShape: List[Int]): MaxPooling1D[T]

Definition Classes
PythonBigDLKeras
def createKerasMaxPooling2D(poolSize: List[Int], strides: List[Int], borderMode: String, dimOrdering: String, inputShape: List[Int]): MaxPooling2D[T]

Definition Classes
PythonBigDLKeras
def createKerasMaxPooling3D(poolSize: List[Int], strides: List[Int], dimOrdering: String, inputShape: List[Int]): MaxPooling3D[T]

Definition Classes
PythonBigDLKeras
def createKerasMaxoutDense(outputDim: Int, nbFeature: Int, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], bias: Boolean, inputShape: List[Int]): MaxoutDense[T]

Definition Classes
PythonBigDLKeras
def createKerasMerge(layers: List[AbstractModule[Activity, Activity, T]], mode: String, concatAxis: Int, inputShape: List[List[Int]]): Merge[T]

Definition Classes
PythonBigDLKeras
def createKerasModel(input: List[ModuleNode[T]], output: List[ModuleNode[T]]): Model[T]

Definition Classes
PythonBigDLKeras
def createKerasPermute(dims: List[Int], inputShape: List[Int]): Permute[T]

Definition Classes
PythonBigDLKeras
def createKerasRepeatVector(n: Int, inputShape: List[Int]): RepeatVector[T]

Definition Classes
PythonBigDLKeras
def createKerasReshape(targetShape: List[Int], inputShape: List[Int]): Reshape[T]

Definition Classes
PythonBigDLKeras
def createKerasSReLU(tLeftInit: String, aLeftInit: String, tRightInit: String, aRightInit: String, sharedAxes: List[Int], inputShape: List[Int]): SReLU[T]

Definition Classes
PythonBigDLKeras
def createKerasSeparableConvolution2D(nbFilter: Int, nbRow: Int, nbCol: Int, init: String, activation: String, borderMode: String, subsample: List[Int], depthMultiplier: Int, dimOrdering: String, depthwiseRegularizer: Regularizer[T], pointwiseRegularizer: Regularizer[T], bRegularizer: Regularizer[T], bias: Boolean, inputShape: List[Int]): SeparableConvolution2D[T]

Definition Classes
PythonBigDLKeras
def createKerasSequential(): Sequential[T]

Definition Classes
PythonBigDLKeras
def createKerasSimpleRNN(outputDim: Int, activation: String, returnSequences: Boolean, goBackwards: Boolean, wRegularizer: Regularizer[T], uRegularizer: Regularizer[T], bRegularizer: Regularizer[T], inputShape: List[Int]): SimpleRNN[T]

Definition Classes
PythonBigDLKeras
def createKerasSpatialDropout1D(p: Double, inputShape: List[Int]): SpatialDropout1D[T]

Definition Classes
PythonBigDLKeras
def createKerasSpatialDropout2D(p: Double, dimOrdering: String, inputShape: List[Int]): SpatialDropout2D[T]

Definition Classes
PythonBigDLKeras
def createKerasSpatialDropout3D(p: Double, dimOrdering: String, inputShape: List[Int]): SpatialDropout3D[T]

Definition Classes
PythonBigDLKeras
def createKerasThresholdedReLU(theta: Double, inputShape: List[Int]): ThresholdedReLU[T]

Definition Classes
PythonBigDLKeras
def createKerasTimeDistributed(layer: KerasLayer[Tensor[T], Tensor[T], T], inputShape: List[Int]): TimeDistributed[T]

Definition Classes
PythonBigDLKeras
def createKerasUpSampling1D(length: Int, inputShape: List[Int]): UpSampling1D[T]

Definition Classes
PythonBigDLKeras
def createKerasUpSampling2D(size: List[Int], dimOrdering: String, inputShape: List[Int]): UpSampling2D[T]

Definition Classes
PythonBigDLKeras
def createKerasUpSampling3D(size: List[Int], dimOrdering: String, inputShape: List[Int]): UpSampling3D[T]

Definition Classes
PythonBigDLKeras
def createKerasZeroPadding1D(padding: List[Int], inputShape: List[Int]): ZeroPadding1D[T]

Definition Classes
PythonBigDLKeras
def createKerasZeroPadding2D(padding: List[Int], dimOrdering: String, inputShape: List[Int]): ZeroPadding2D[T]

Definition Classes
PythonBigDLKeras
def createKerasZeroPadding3D(padding: List[Int], dimOrdering: String, inputShape: List[Int]): ZeroPadding3D[T]

Definition Classes
PythonBigDLKeras
def createKullbackLeiblerDivergenceCriterion: KullbackLeiblerDivergenceCriterion[T]

Definition Classes
PythonBigDL
def createL1Cost(): L1Cost[T]

Definition Classes
PythonBigDL
def createL1HingeEmbeddingCriterion(margin: Double): L1HingeEmbeddingCriterion[T]

Definition Classes
PythonBigDL
def createL1L2Regularizer(l1: Double, l2: Double): L1L2Regularizer[T]

Definition Classes
PythonBigDL
def createL1Penalty(l1weight: Int, sizeAverage: Boolean, provideOutput: Boolean): L1Penalty[T]

Definition Classes
PythonBigDL
def createL1Regularizer(l1: Double): L1Regularizer[T]

Definition Classes
PythonBigDL
def createL2Regularizer(l2: Double): L2Regularizer[T]

Definition Classes
PythonBigDL
def createLBFGS(maxIter: Int, maxEval: Double, tolFun: Double, tolX: Double, nCorrection: Int, learningRate: Double, verbose: Boolean, lineSearch: LineSearch[T], lineSearchOptions: Map[Any, Any]): LBFGS[T]

Definition Classes
PythonBigDL
def createLSTM(inputSize: Int, hiddenSize: Int, p: Double, activation: TensorModule[T], innerActivation: TensorModule[T], wRegularizer: Regularizer[T], uRegularizer: Regularizer[T], bRegularizer: Regularizer[T]): LSTM[T]

Definition Classes
PythonBigDL
def createLSTMPeephole(inputSize: Int, hiddenSize: Int, p: Double, wRegularizer: Regularizer[T], uRegularizer: Regularizer[T], bRegularizer: Regularizer[T]): LSTMPeephole[T]

Definition Classes
PythonBigDL
def createLeakyReLU(negval: Double, inplace: Boolean): LeakyReLU[T]

Definition Classes
PythonBigDL
def createLinear(inputSize: Int, outputSize: Int, withBias: Boolean, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], initWeight: JTensor, initBias: JTensor, initGradWeight: JTensor, initGradBias: JTensor): Linear[T]

Definition Classes
PythonBigDL
def createLocalImageFrame(images: List[JTensor], labels: List[JTensor]): LocalImageFrame

Definition Classes
PythonBigDL
def createLocalOptimizer(features: List[JTensor], y: JTensor, model: AbstractModule[Activity, Activity, T], criterion: Criterion[T], optimMethod: OptimMethod[T], endTrigger: Trigger, batchSize: Int, localCores: Int): Optimizer[T, MiniBatch[T]]

Definition Classes
PythonBigDL
def createLocallyConnected1D(nInputFrame: Int, inputFrameSize: Int, outputFrameSize: Int, kernelW: Int, strideW: Int, propagateBack: Boolean, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], initWeight: JTensor, initBias: JTensor, initGradWeight: JTensor, initGradBias: JTensor): LocallyConnected1D[T]

Definition Classes
PythonBigDL
def createLocallyConnected2D(nInputPlane: Int, inputWidth: Int, inputHeight: Int, nOutputPlane: Int, kernelW: Int, kernelH: Int, strideW: Int, strideH: Int, padW: Int, padH: Int, propagateBack: Boolean, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], initWeight: JTensor, initBias: JTensor, initGradWeight: JTensor, initGradBias: JTensor, withBias: Boolean, dataFormat: String): LocallyConnected2D[T]

Definition Classes
PythonBigDL
def createLog(): Log[T]

Definition Classes
PythonBigDL
def createLogSigmoid(): LogSigmoid[T]

Definition Classes
PythonBigDL
def createLogSoftMax(): LogSoftMax[T]

Definition Classes
PythonBigDL
def createLookupTable(nIndex: Int, nOutput: Int, paddingValue: Double, maxNorm: Double, normType: Double, shouldScaleGradByFreq: Boolean, wRegularizer: Regularizer[T]): LookupTable[T]

Definition Classes
PythonBigDL
def createLookupTableSparse(nIndex: Int, nOutput: Int, combiner: String, maxNorm: Double, wRegularizer: Regularizer[T]): LookupTableSparse[T]

Definition Classes
PythonBigDL
def createLoss(criterion: Criterion[T]): ValidationMethod[T]

Definition Classes
PythonBigDL
def createMAE(): ValidationMethod[T]

Definition Classes
PythonBigDL
def createMM(transA: Boolean, transB: Boolean): MM[T]

Definition Classes
PythonBigDL
def createMSECriterion: MSECriterion[T]

Definition Classes
PythonBigDL
def createMV(trans: Boolean): MV[T]

Definition Classes
PythonBigDL
def createMapTable(module: AbstractModule[Activity, Activity, T]): MapTable[T]

Definition Classes
PythonBigDL
def createMarginCriterion(margin: Double, sizeAverage: Boolean, squared: Boolean): MarginCriterion[T]

Definition Classes
PythonBigDL
def createMarginRankingCriterion(margin: Double, sizeAverage: Boolean): MarginRankingCriterion[T]

Definition Classes
PythonBigDL
def createMaskedSelect(): MaskedSelect[T]

Definition Classes
PythonBigDL
def createMasking(maskValue: Double): Masking[T]

Definition Classes
PythonBigDL
def createMatToFloats(validHeight: Int, validWidth: Int, validChannels: Int, outKey: String, shareBuffer: Boolean): MatToFloats

Definition Classes
PythonBigDL
def createMatToTensor(toRGB: Boolean, tensorKey: String): MatToTensor[T]

Definition Classes
PythonBigDL
def createMax(dim: Int, numInputDims: Int): Max[T]

Definition Classes
PythonBigDL
def createMaxEpoch(max: Int): Trigger

Definition Classes
PythonBigDL
def createMaxIteration(max: Int): Trigger

Definition Classes
PythonBigDL
def createMaxScore(max: Float): Trigger

Definition Classes
PythonBigDL
def createMaxout(inputSize: Int, outputSize: Int, maxoutNumber: Int, withBias: Boolean, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], initWeight: Tensor[T], initBias: Tensor[T]): Maxout[T]

Definition Classes
PythonBigDL
def createMean(dimension: Int, nInputDims: Int, squeeze: Boolean): Mean[T]

Definition Classes
PythonBigDL
def createMeanAbsolutePercentageCriterion: MeanAbsolutePercentageCriterion[T]

Definition Classes
PythonBigDL
def createMeanSquaredLogarithmicCriterion: MeanSquaredLogarithmicCriterion[T]

Definition Classes
PythonBigDL
def createMin(dim: Int, numInputDims: Int): Min[T]

Definition Classes
PythonBigDL
def createMinLoss(min: Float): Trigger

Definition Classes
PythonBigDL
def createMixtureTable(dim: Int): MixtureTable[T]

Definition Classes
PythonBigDL
def createModel(input: List[ModuleNode[T]], output: List[ModuleNode[T]]): Graph[T]

Definition Classes
PythonBigDL
def createMsraFiller(varianceNormAverage: Boolean): MsraFiller

Definition Classes
PythonBigDL
def createMul(): Mul[T]

Definition Classes
PythonBigDL
def createMulConstant(scalar: Double, inplace: Boolean): MulConstant[T]

Definition Classes
PythonBigDL
def createMultiCriterion(): MultiCriterion[T]

Definition Classes
PythonBigDL
def createMultiLabelMarginCriterion(sizeAverage: Boolean): MultiLabelMarginCriterion[T]

Definition Classes
PythonBigDL
def createMultiLabelSoftMarginCriterion(weights: JTensor, sizeAverage: Boolean): MultiLabelSoftMarginCriterion[T]

Definition Classes
PythonBigDL
def createMultiMarginCriterion(p: Int, weights: JTensor, margin: Double, sizeAverage: Boolean): MultiMarginCriterion[T]

Definition Classes
PythonBigDL
def createMultiRNNCell(cells: List[Cell[T]]): MultiRNNCell[T]

Definition Classes
PythonBigDL
def createMultiStep(stepSizes: List[Int], gamma: Double): MultiStep

Definition Classes
PythonBigDL
def createNarrow(dimension: Int, offset: Int, length: Int): Narrow[T]

Definition Classes
PythonBigDL
def createNarrowTable(offset: Int, length: Int): NarrowTable[T]

Definition Classes
PythonBigDL
def createNegative(inplace: Boolean): Negative[T]

Definition Classes
PythonBigDL
def createNegativeEntropyPenalty(beta: Double): NegativeEntropyPenalty[T]

Definition Classes
PythonBigDL
def createNode(module: AbstractModule[Activity, Activity, T], x: List[ModuleNode[T]]): ModuleNode[T]

Definition Classes
PythonBigDL
def createNormalize(p: Double, eps: Double): Normalize[T]

Definition Classes
PythonBigDL
def createNormalizeScale(p: Double, eps: Double, scale: Double, size: List[Int], wRegularizer: Regularizer[T]): NormalizeScale[T]

Definition Classes
PythonBigDL
def createOnes(): Ones.type

Definition Classes
PythonBigDL
def createPGCriterion(sizeAverage: Boolean): PGCriterion[T]

Definition Classes
PythonBigDL
def createPReLU(nOutputPlane: Int): PReLU[T]

Definition Classes
PythonBigDL
def createPack(dimension: Int): Pack[T]

Definition Classes
PythonBigDL
def createPadding(dim: Int, pad: Int, nInputDim: Int, value: Double, nIndex: Int): Padding[T]

Definition Classes
PythonBigDL
def createPairwiseDistance(norm: Int): PairwiseDistance[T]

Definition Classes
PythonBigDL
def createParallelCriterion(repeatTarget: Boolean): ParallelCriterion[T]

Definition Classes
PythonBigDL
def createParallelTable(): ParallelTable[T]

Definition Classes
PythonBigDL
def createPipeline(list: List[FeatureTransformer]): FeatureTransformer

Definition Classes
PythonBigDL
def createPixelBytesToMat(byteKey: String): PixelBytesToMat

Definition Classes
PythonBigDL
def createPixelNormalize(means: List[Double]): PixelNormalizer

Definition Classes
PythonBigDL
def createPlateau(monitor: String, factor: Float, patience: Int, mode: String, epsilon: Float, cooldown: Int, minLr: Float): Plateau

Definition Classes
PythonBigDL
def createPoissonCriterion: PoissonCriterion[T]

Definition Classes
PythonBigDL
def createPoly(power: Double, maxIteration: Int): Poly

Definition Classes
PythonBigDL
def createPower(power: Double, scale: Double, shift: Double): Power[T]

Definition Classes
PythonBigDL
def createPriorBox(minSizes: List[Double], maxSizes: List[Double], aspectRatios: List[Double], isFlip: Boolean, isClip: Boolean, variances: List[Double], offset: Float, imgH: Int, imgW: Int, imgSize: Int, stepH: Float, stepW: Float, step: Float): PriorBox[T]

Definition Classes
PythonBigDL
def createProposal(preNmsTopN: Int, postNmsTopN: Int, ratios: List[Double], scales: List[Double], rpnPreNmsTopNTrain: Int, rpnPostNmsTopNTrain: Int): Proposal

Definition Classes
PythonBigDL
def createRMSprop(learningRate: Double, learningRateDecay: Double, decayRate: Double, Epsilon: Double): RMSprop[T]

Definition Classes
PythonBigDL
def createRReLU(lower: Double, upper: Double, inplace: Boolean): RReLU[T]

Definition Classes
PythonBigDL
def createRandomAspectScale(scales: List[Int], scaleMultipleOf: Int, maxSize: Int): RandomAspectScale

Definition Classes
PythonBigDL
def createRandomCrop(cropWidth: Int, cropHeight: Int, isClip: Boolean): RandomCrop

Definition Classes
PythonBigDL
def createRandomNormal(mean: Double, stdv: Double): RandomNormal

Definition Classes
PythonBigDL
def createRandomSampler(): FeatureTransformer

Definition Classes
PythonBigDL
def createRandomTransformer(transformer: FeatureTransformer, prob: Double): RandomTransformer

Definition Classes
PythonBigDL
def createRandomUniform(): InitializationMethod

Definition Classes
PythonBigDL
def createRandomUniform(lower: Double, upper: Double): InitializationMethod

Definition Classes
PythonBigDL
def createReLU(ip: Boolean): ReLU[T]

Definition Classes
PythonBigDL
def createReLU6(inplace: Boolean): ReLU6[T]

Definition Classes
PythonBigDL
def createRecurrent(): Recurrent[T]

Definition Classes
PythonBigDL
def createRecurrentDecoder(outputLength: Int): RecurrentDecoder[T]

Definition Classes
PythonBigDL
def createReplicate(nFeatures: Int, dim: Int, nDim: Int): Replicate[T]

Definition Classes
PythonBigDL
def createReshape(size: List[Int], batchMode: Boolean): Reshape[T]

Definition Classes
PythonBigDL
def createResize(resizeH: Int, resizeW: Int, resizeMode: Int, useScaleFactor: Boolean): Resize

Definition Classes
PythonBigDL
def createResizeBilinear(outputHeight: Int, outputWidth: Int, alignCorner: Boolean, dataFormat: String): ResizeBilinear[T]

Definition Classes
PythonBigDL
def createReverse(dimension: Int, isInplace: Boolean): Reverse[T]

Definition Classes
PythonBigDL
def createRnnCell(inputSize: Int, hiddenSize: Int, activation: TensorModule[T], isInputWithBias: Boolean, isHiddenWithBias: Boolean, wRegularizer: Regularizer[T], uRegularizer: Regularizer[T], bRegularizer: Regularizer[T]): RnnCell[T]

Definition Classes
PythonBigDL
def createRoiHFlip(normalized: Boolean): RoiHFlip

Definition Classes
PythonBigDL
def createRoiNormalize(): RoiNormalize

Definition Classes
PythonBigDL
def createRoiPooling(pooled_w: Int, pooled_h: Int, spatial_scale: Double): RoiPooling[T]

Definition Classes
PythonBigDL
def createRoiProject(needMeetCenterConstraint: Boolean): RoiProject

Definition Classes
PythonBigDL
def createRoiResize(normalized: Boolean): RoiResize

Definition Classes
PythonBigDL
def createSGD(learningRate: Double, learningRateDecay: Double, weightDecay: Double, momentum: Double, dampening: Double, nesterov: Boolean, leaningRateSchedule: LearningRateSchedule, learningRates: JTensor, weightDecays: JTensor): SGD[T]

Definition Classes
PythonBigDL
def createSReLU(shape: ArrayList[Int], shareAxes: ArrayList[Int]): SReLU[T]

Definition Classes
PythonBigDL
def createSaturation(deltaLow: Double, deltaHigh: Double): Saturation

Definition Classes
PythonBigDL
def createScale(size: List[Int]): Scale[T]

Definition Classes
PythonBigDL
def createSelect(dimension: Int, index: Int): Select[T]

Definition Classes
PythonBigDL
def createSelectTable(dimension: Int): SelectTable[T]

Definition Classes
PythonBigDL
def createSequential(): Container[Activity, Activity, T]

Definition Classes
PythonBigDL
def createSequentialSchedule(iterationPerEpoch: Int): SequentialSchedule

Definition Classes
PythonBigDL
def createSeveralIteration(interval: Int): Trigger

Definition Classes
PythonBigDL
def createSigmoid(): Sigmoid[T]

Definition Classes
PythonBigDL
def createSmoothL1Criterion(sizeAverage: Boolean): SmoothL1Criterion[T]

Definition Classes
PythonBigDL
def createSmoothL1CriterionWithWeights(sigma: Double, num: Int): SmoothL1CriterionWithWeights[T]

Definition Classes
PythonBigDL
def createSoftMarginCriterion(sizeAverage: Boolean): SoftMarginCriterion[T]

Definition Classes
PythonBigDL
def createSoftMax(): SoftMax[T]

Definition Classes
PythonBigDL
def createSoftMin(): SoftMin[T]

Definition Classes
PythonBigDL
def createSoftPlus(beta: Double): SoftPlus[T]

Definition Classes
PythonBigDL
def createSoftShrink(lambda: Double): SoftShrink[T]

Definition Classes
PythonBigDL
def createSoftSign(): SoftSign[T]

Definition Classes
PythonBigDL
def createSoftmaxWithCriterion(ignoreLabel: Integer, normalizeMode: String): SoftmaxWithCriterion[T]

Definition Classes
PythonBigDL
def createSparseJoinTable(dimension: Int): SparseJoinTable[T]

Definition Classes
PythonBigDL
def createSparseLinear(inputSize: Int, outputSize: Int, withBias: Boolean, backwardStart: Int, backwardLength: Int, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], initWeight: JTensor, initBias: JTensor, initGradWeight: JTensor, initGradBias: JTensor): SparseLinear[T]

Definition Classes
PythonBigDL
def createSpatialAveragePooling(kW: Int, kH: Int, dW: Int, dH: Int, padW: Int, padH: Int, globalPooling: Boolean, ceilMode: Boolean, countIncludePad: Boolean, divide: Boolean, format: String): SpatialAveragePooling[T]

Definition Classes
PythonBigDL
def createSpatialBatchNormalization(nOutput: Int, eps: Double, momentum: Double, affine: Boolean, initWeight: JTensor, initBias: JTensor, initGradWeight: JTensor, initGradBias: JTensor, dataFormat: String): SpatialBatchNormalization[T]

Definition Classes
PythonBigDL
def createSpatialContrastiveNormalization(nInputPlane: Int, kernel: JTensor, threshold: Double, thresval: Double): SpatialContrastiveNormalization[T]

Definition Classes
PythonBigDL
def createSpatialConvolution(nInputPlane: Int, nOutputPlane: Int, kernelW: Int, kernelH: Int, strideW: Int, strideH: Int, padW: Int, padH: Int, nGroup: Int, propagateBack: Boolean, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], initWeight: JTensor, initBias: JTensor, initGradWeight: JTensor, initGradBias: JTensor, withBias: Boolean, dataFormat: String): SpatialConvolution[T]

Definition Classes
PythonBigDL
def createSpatialConvolutionMap(connTable: JTensor, kW: Int, kH: Int, dW: Int, dH: Int, padW: Int, padH: Int, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T]): SpatialConvolutionMap[T]

Definition Classes
PythonBigDL
def createSpatialCrossMapLRN(size: Int, alpha: Double, beta: Double, k: Double, dataFormat: String): SpatialCrossMapLRN[T]

Definition Classes
PythonBigDL
def createSpatialDilatedConvolution(nInputPlane: Int, nOutputPlane: Int, kW: Int, kH: Int, dW: Int, dH: Int, padW: Int, padH: Int, dilationW: Int, dilationH: Int, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T]): SpatialDilatedConvolution[T]

Definition Classes
PythonBigDL
def createSpatialDivisiveNormalization(nInputPlane: Int, kernel: JTensor, threshold: Double, thresval: Double): SpatialDivisiveNormalization[T]

Definition Classes
PythonBigDL
def createSpatialDropout1D(initP: Double): SpatialDropout1D[T]

Definition Classes
PythonBigDL
def createSpatialDropout2D(initP: Double, dataFormat: String): SpatialDropout2D[T]

Definition Classes
PythonBigDL
def createSpatialDropout3D(initP: Double, dataFormat: String): SpatialDropout3D[T]

Definition Classes
PythonBigDL
def createSpatialFullConvolution(nInputPlane: Int, nOutputPlane: Int, kW: Int, kH: Int, dW: Int, dH: Int, padW: Int, padH: Int, adjW: Int, adjH: Int, nGroup: Int, noBias: Boolean, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T]): SpatialFullConvolution[T]

Definition Classes
PythonBigDL
def createSpatialMaxPooling(kW: Int, kH: Int, dW: Int, dH: Int, padW: Int, padH: Int, ceilMode: Boolean, format: String): SpatialMaxPooling[T]

Definition Classes
PythonBigDL
def createSpatialSeparableConvolution(nInputChannel: Int, nOutputChannel: Int, depthMultiplier: Int, kW: Int, kH: Int, sW: Int, sH: Int, pW: Int, pH: Int, withBias: Boolean, dataFormat: String, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], pRegularizer: Regularizer[T]): SpatialSeparableConvolution[T]

Definition Classes
PythonBigDL
def createSpatialShareConvolution(nInputPlane: Int, nOutputPlane: Int, kernelW: Int, kernelH: Int, strideW: Int, strideH: Int, padW: Int, padH: Int, nGroup: Int, propagateBack: Boolean, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], initWeight: JTensor, initBias: JTensor, initGradWeight: JTensor, initGradBias: JTensor, withBias: Boolean): SpatialShareConvolution[T]

Definition Classes
PythonBigDL
def createSpatialSubtractiveNormalization(nInputPlane: Int, kernel: JTensor): SpatialSubtractiveNormalization[T]

Definition Classes
PythonBigDL
def createSpatialWithinChannelLRN(size: Int, alpha: Double, beta: Double): SpatialWithinChannelLRN[T]

Definition Classes
PythonBigDL
def createSpatialZeroPadding(padLeft: Int, padRight: Int, padTop: Int, padBottom: Int): SpatialZeroPadding[T]

Definition Classes
PythonBigDL
def createSplitTable(dimension: Int, nInputDims: Int): SplitTable[T]

Definition Classes
PythonBigDL
def createSqrt(): Sqrt[T]

Definition Classes
PythonBigDL
def createSquare(): Square[T]

Definition Classes
PythonBigDL
def createSqueeze(dim: Int, numInputDims: Int): Squeeze[T]

Definition Classes
PythonBigDL
def createStep(stepSize: Int, gamma: Double): Step

Definition Classes
PythonBigDL
def createSum(dimension: Int, nInputDims: Int, sizeAverage: Boolean, squeeze: Boolean): Sum[T]

Definition Classes
PythonBigDL
def createTFNet(path: String, inputNames: List[String], outputNames: List[String]): TFNet
def createTanh(): Tanh[T]

Definition Classes
PythonBigDL
def createTanhShrink(): TanhShrink[T]

Definition Classes
PythonBigDL
def createTemporalConvolution(inputFrameSize: Int, outputFrameSize: Int, kernelW: Int, strideW: Int, propagateBack: Boolean, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T], initWeight: JTensor, initBias: JTensor, initGradWeight: JTensor, initGradBias: JTensor): TemporalConvolution[T]

Definition Classes
PythonBigDL
def createTemporalMaxPooling(kW: Int, dW: Int): TemporalMaxPooling[T]

Definition Classes
PythonBigDL
def createThreshold(th: Double, v: Double, ip: Boolean): Threshold[T]

Definition Classes
PythonBigDL
def createTile(dim: Int, copies: Int): Tile[T]

Definition Classes
PythonBigDL
def createTimeDistributed(layer: TensorModule[T]): TimeDistributed[T]

Definition Classes
PythonBigDL
def createTimeDistributedCriterion(critrn: TensorCriterion[T], sizeAverage: Boolean): TimeDistributedCriterion[T]

Definition Classes
PythonBigDL
def createTimeDistributedMaskCriterion(critrn: TensorCriterion[T], paddingValue: Int): TimeDistributedMaskCriterion[T]

Definition Classes
PythonBigDL
def createTop1Accuracy(): ValidationMethod[T]

Definition Classes
PythonBigDL
def createTop5Accuracy(): ValidationMethod[T]

Definition Classes
PythonBigDL
def createTrainSummary(logDir: String, appName: String): TrainSummary

Definition Classes
PythonBigDL
def createTransformerCriterion(criterion: AbstractCriterion[Activity, Activity, T], inputTransformer: AbstractModule[Activity, Activity, T], targetTransformer: AbstractModule[Activity, Activity, T]): TransformerCriterion[T]

Definition Classes
PythonBigDL
def createTranspose(permutations: List[List[Int]]): Transpose[T]

Definition Classes
PythonBigDL
def createTreeNNAccuracy(): ValidationMethod[T]

Definition Classes
PythonBigDL
def createUnsqueeze(pos: Int, numInputDims: Int): Unsqueeze[T]

Definition Classes
PythonBigDL
def createUpSampling1D(length: Int): UpSampling1D[T]

Definition Classes
PythonBigDL
def createUpSampling2D(size: List[Int], dataFormat: String): UpSampling2D[T]

Definition Classes
PythonBigDL
def createUpSampling3D(size: List[Int]): UpSampling3D[T]

Definition Classes
PythonBigDL
def createValidationSummary(logDir: String, appName: String): ValidationSummary

Definition Classes
PythonBigDL
def createView(sizes: List[Int], num_input_dims: Int): View[T]

Definition Classes
PythonBigDL
def createVolumetricAveragePooling(kT: Int, kW: Int, kH: Int, dT: Int, dW: Int, dH: Int, padT: Int, padW: Int, padH: Int, countIncludePad: Boolean, ceilMode: Boolean): VolumetricAveragePooling[T]

Definition Classes
PythonBigDL
def createVolumetricConvolution(nInputPlane: Int, nOutputPlane: Int, kT: Int, kW: Int, kH: Int, dT: Int, dW: Int, dH: Int, padT: Int, padW: Int, padH: Int, withBias: Boolean, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T]): VolumetricConvolution[T]

Definition Classes
PythonBigDL
def createVolumetricFullConvolution(nInputPlane: Int, nOutputPlane: Int, kT: Int, kW: Int, kH: Int, dT: Int, dW: Int, dH: Int, padT: Int, padW: Int, padH: Int, adjT: Int, adjW: Int, adjH: Int, nGroup: Int, noBias: Boolean, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T]): VolumetricFullConvolution[T]

Definition Classes
PythonBigDL
def createVolumetricMaxPooling(kT: Int, kW: Int, kH: Int, dT: Int, dW: Int, dH: Int, padT: Int, padW: Int, padH: Int): VolumetricMaxPooling[T]

Definition Classes
PythonBigDL
def createWarmup(delta: Double): Warmup

Definition Classes
PythonBigDL
def createXavier(): Xavier.type

Definition Classes
PythonBigDL
def createZeros(): Zeros.type

Definition Classes
PythonBigDL
def createZooKerasAccuracy(zeroBasedLabel: Boolean = true): ValidationMethod[T]
def createZooKerasActivation(activation: String, inputShape: List[Int] = null): Activation[T]
def createZooKerasAddConstant(constant: Double, inputShape: List[Int] = null): AddConstant[T]
def createZooKerasAtrousConvolution1D(nbFilter: Int, filterLength: Int, init: String = "glorot_uniform", activation: String = null, subsampleLength: Int = 1, atrousRate: Int = 1, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, inputShape: List[Int] = null): AtrousConvolution1D[T]
def createZooKerasAtrousConvolution2D(nbFilter: Int, nbRow: Int, nbCol: Int, init: String = "glorot_uniform", activation: String = null, subsample: List[Int], atrousRate: List[Int], dimOrdering: String = "th", wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, inputShape: List[Int] = null): AtrousConvolution2D[T]
def createZooKerasAveragePooling1D(poolLength: Int = 2, stride: Int = 1, borderMode: String = "valid", inputShape: List[Int] = null): AveragePooling1D[T]
def createZooKerasAveragePooling2D(poolSize: List[Int], strides: List[Int], borderMode: String = "valid", dimOrdering: String = "th", inputShape: List[Int] = null): AveragePooling2D[T]
def createZooKerasAveragePooling3D(poolSize: List[Int], strides: List[Int], dimOrdering: String = "th", inputShape: List[Int] = null): AveragePooling3D[T]
def createZooKerasBatchNormalization(epsilon: Double = 0.001, momentum: Double = 0.99, betaInit: String = "zero", gammaInit: String = "one", dimOrdering: String = "th", inputShape: List[Int] = null): BatchNormalization[T]
def createZooKerasBidirectional(layer: Recurrent[T], mergeMode: String = "concat", inputShape: List[Int] = null): Bidirectional[T]
def createZooKerasBinaryThreshold(th: Double = 1e-6, inputShape: List[Int] = null): BinaryThreshold[T]
def createZooKerasCAdd(size: List[Int], bRegularizer: Regularizer[T] = null, inputShape: List[Int] = null): CAdd[T]
def createZooKerasCMul(size: List[Int], wRegularizer: Regularizer[T] = null, inputShape: List[Int] = null): CMul[T]
def createZooKerasConvLSTM2D(nbFilter: Int, nbKernel: Int, activation: String = "tanh", innerActivation: String = "hard_sigmoid", dimOrdering: String = "th", subsample: Int = 1, wRegularizer: Regularizer[T] = null, uRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, returnSequences: Boolean = false, goBackwards: Boolean = false, inputShape: List[Int] = null): ConvLSTM2D[T]
def createZooKerasConvolution1D(nbFilter: Int, filterLength: Int, init: String = "glorot_uniform", activation: String = null, borderMode: String = "valid", subsampleLength: Int = 1, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, bias: Boolean = true, inputShape: List[Int] = null): Convolution1D[T]
def createZooKerasConvolution2D(nbFilter: Int, nbRow: Int, nbCol: Int, init: String = "glorot_uniform", activation: String = null, borderMode: String = "valid", subsample: List[Int], dimOrdering: String = "th", wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, bias: Boolean = true, inputShape: List[Int] = null): Convolution2D[T]
def createZooKerasConvolution3D(nbFilter: Int, kernelDim1: Int, kernelDim2: Int, kernelDim3: Int, init: String = "glorot_uniform", activation: String = null, borderMode: String = "valid", subsample: List[Int], dimOrdering: String = "th", wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, bias: Boolean = true, inputShape: List[Int] = null): Convolution3D[T]
def createZooKerasCropping1D(cropping: List[Int], inputShape: List[Int] = null): Cropping1D[T]
def createZooKerasCropping2D(heightCrop: List[Int], widthCrop: List[Int], dimOrdering: String = "th", inputShape: List[Int] = null): Cropping2D[T]
def createZooKerasCropping3D(dim1Crop: List[Int], dim2Crop: List[Int], dim3Crop: List[Int], dimOrdering: String = "th", inputShape: List[Int] = null): Cropping3D[T]
def createZooKerasDeconvolution2D(nbFilter: Int, nbRow: Int, nbCol: Int, init: String = "glorot_uniform", activation: String = null, subsample: List[Int], dimOrdering: String = "th", wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, bias: Boolean = true, inputShape: List[Int] = null): Deconvolution2D[T]
def createZooKerasDense(outputDim: Int, init: String = "glorot_uniform", activation: String = null, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, bias: Boolean = true, inputShape: List[Int] = null): Dense[T]
def createZooKerasDropout(p: Double, inputShape: List[Int] = null): Dropout[T]
def createZooKerasELU(alpha: Double = 1.0, inputShape: List[Int] = null): ELU[T]
def createZooKerasEmbedding(inputDim: Int, outputDim: Int, init: String = "uniform", wRegularizer: Regularizer[T] = null, inputShape: List[Int] = null): Embedding[T]
def createZooKerasExp(inputShape: List[Int] = null): Exp[T]
def createZooKerasFlatten(inputShape: List[Int] = null): Flatten[T]
def createZooKerasGRU(outputDim: Int, activation: String = "tanh", innerActivation: String = "hard_sigmoid", returnSequences: Boolean = false, goBackwards: Boolean = false, wRegularizer: Regularizer[T] = null, uRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, inputShape: List[Int] = null): GRU[T]
def createZooKerasGaussianDropout(p: Double, inputShape: List[Int] = null): GaussianDropout[T]
def createZooKerasGaussianNoise(sigma: Double, inputShape: List[Int] = null): GaussianNoise[T]
def createZooKerasGaussianSampler(inputShape: List[Int] = null): GaussianSampler[T]
def createZooKerasGlobalAveragePooling1D(inputShape: List[Int] = null): GlobalAveragePooling1D[T]
def createZooKerasGlobalAveragePooling2D(dimOrdering: String = "th", inputShape: List[Int] = null): GlobalAveragePooling2D[T]
def createZooKerasGlobalAveragePooling3D(dimOrdering: String = "th", inputShape: List[Int] = null): GlobalAveragePooling3D[T]
def createZooKerasGlobalMaxPooling1D(inputShape: List[Int] = null): GlobalMaxPooling1D[T]
def createZooKerasGlobalMaxPooling2D(dimOrdering: String = "th", inputShape: List[Int] = null): GlobalMaxPooling2D[T]
def createZooKerasGlobalMaxPooling3D(dimOrdering: String = "th", inputShape: List[Int] = null): GlobalMaxPooling3D[T]
def createZooKerasHardShrink(value: Double = 0.5, inputShape: List[Int] = null): HardShrink[T]
def createZooKerasHardTanh(minValue: Double = 1, maxValue: Double = 1, inputShape: List[Int] = null): HardTanh[T]
def createZooKerasHighway(activation: String = null, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, bias: Boolean = true, inputShape: List[Int] = null): Highway[T]
def createZooKerasInput(inputShape: List[List[Int]] = null, name: String = null): Variable[T]
def createZooKerasInputLayer(inputShape: List[Int] = null): KerasLayer[Activity, Activity, T]
def createZooKerasLRN2D(alpha: Double = 1e-4, k: Double = 1.0, beta: Double = 0.75, n: Int = 5, dimOrdering: String = "th", inputShape: List[Int] = null): LRN2D[T]
def createZooKerasLSTM(outputDim: Int, activation: String = "tanh", innerActivation: String = "hard_sigmoid", returnSequences: Boolean = false, goBackwards: Boolean = false, wRegularizer: Regularizer[T] = null, uRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, inputShape: List[Int] = null): LSTM[T]
def createZooKerasLeakyReLU(alpha: Double = 0.01, inputShape: List[Int] = null): LeakyReLU[T]
def createZooKerasLocallyConnected1D(nbFilter: Int, filterLength: Int, activation: String = null, subsampleLength: Int = 1, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, bias: Boolean = true, inputShape: List[Int] = null): LocallyConnected1D[T]
def createZooKerasLocallyConnected2D(nbFilter: Int, nbRow: Int, nbCol: Int, activation: String = null, borderMode: String = "valid", subsample: List[Int], dimOrdering: String = "th", wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, bias: Boolean = true, inputShape: List[Int] = null): LocallyConnected2D[T]
def createZooKerasLog(inputShape: List[Int] = null): Log[T]
def createZooKerasMasking(maskValue: Double = 0.0, inputShape: List[Int] = null): Masking[T]
def createZooKerasMaxPooling1D(poolLength: Int = 2, stride: Int = 1, borderMode: String = "valid", inputShape: List[Int] = null): MaxPooling1D[T]
def createZooKerasMaxPooling2D(poolSize: List[Int], strides: List[Int], borderMode: String = "valid", dimOrdering: String = "th", inputShape: List[Int] = null): MaxPooling2D[T]
def createZooKerasMaxPooling3D(poolSize: List[Int], strides: List[Int], dimOrdering: String = "th", inputShape: List[Int] = null): MaxPooling3D[T]
def createZooKerasMaxoutDense(outputDim: Int, nbFeature: Int = 4, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, bias: Boolean = true, inputShape: List[Int] = null): MaxoutDense[T]
def createZooKerasMeanAbsoluteError(sizeAverage: Boolean = true): MeanAbsoluteError[T]
def createZooKerasMerge(layers: List[KerasLayer[Activity, Activity, T]] = null, mode: String = "sum", concatAxis: Int = 1, inputShape: List[List[Int]]): Merge[T]
def createZooKerasModel(input: List[Variable[T]], output: List[Variable[T]]): Model[T]
def createZooKerasMul(inputShape: List[Int] = null): Mul[T]
def createZooKerasMulConstant(constant: Double, inputShape: List[Int] = null): MulConstant[T]
def createZooKerasNarrow(dim: Int, offset: Int, length: Int = 1, inputShape: List[Int] = null): Narrow[T]
def createZooKerasNegative(inputShape: List[Int] = null): Negative[T]
def createZooKerasPReLU(nOutputPlane: Int = 0, inputShape: List[Int] = null): PReLU[T]
def createZooKerasPermute(dims: List[Int], inputShape: List[Int] = null): Permute[T]
def createZooKerasPower(power: Double, scale: Double = 1, shift: Double = 0, inputShape: List[Int] = null): Power[T]
def createZooKerasRReLU(lower: Double = 1.0/8, upper: Double = 1.0/3, inputShape: List[Int] = null): RReLU[T]
def createZooKerasRepeatVector(n: Int, inputShape: List[Int] = null): RepeatVector[T]
def createZooKerasReshape(targetShape: List[Int], inputShape: List[Int] = null): Reshape[T]
def createZooKerasResizeBilinear(outputHeight: Int, outputWidth: Int, alignCorners: Boolean, dimOrdering: String = "th", inputShape: List[Int] = null): ResizeBilinear[T]
def createZooKerasSReLU(tLeftInit: String = "zero", aLeftInit: String = "glorot_uniform", tRightInit: String = "glorot_uniform", aRightInit: String = "one", sharedAxes: List[Int] = null, inputShape: List[Int] = null): SReLU[T]
def createZooKerasScale(size: List[Int], inputShape: List[Int] = null): Scale[T]
def createZooKerasSelect(dim: Int, index: Int, inputShape: List[Int] = null): Select[T]
def createZooKerasSeparableConvolution2D(nbFilter: Int, nbRow: Int, nbCol: Int, init: String = "glorot_uniform", activation: String = null, borderMode: String = "valid", subsample: List[Int], depthMultiplier: Int = 1, dimOrdering: String = "th", depthwiseRegularizer: Regularizer[T] = null, pointwiseRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, bias: Boolean = true, inputShape: List[Int] = null): SeparableConvolution2D[T]
def createZooKerasSequential(): Sequential[T]
def createZooKerasShareConvolution2D(nbFilter: Int, nbRow: Int, nbCol: Int, init: String = "glorot_uniform", activation: String = null, subsample: List[Int], padH: Int = 0, padW: Int = 0, propagateBack: Boolean = true, dimOrdering: String = "th", wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, bias: Boolean = true, inputShape: List[Int] = null): ShareConvolution2D[T]
def createZooKerasSimpleRNN(outputDim: Int, activation: String = "tanh", returnSequences: Boolean = false, goBackwards: Boolean = false, wRegularizer: Regularizer[T] = null, uRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, inputShape: List[Int] = null): SimpleRNN[T]
def createZooKerasSoftShrink(value: Double = 0.5, inputShape: List[Int] = null): SoftShrink[T]
def createZooKerasSparseCategoricalCrossEntropy(logProbAsInput: Boolean = false, zeroBasedLabel: Boolean = true, weights: Tensor[T] = null, sizeAverage: Boolean = true, paddingValue: Int = 1): SparseCategoricalCrossEntropy[T]
def createZooKerasSpatialDropout1D(p: Double = 0.5, inputShape: List[Int] = null): SpatialDropout1D[T]
def createZooKerasSpatialDropout2D(p: Double = 0.5, dimOrdering: String = "th", inputShape: List[Int] = null): SpatialDropout2D[T]
def createZooKerasSpatialDropout3D(p: Double = 0.5, dimOrdering: String = "th", inputShape: List[Int] = null): SpatialDropout3D[T]
def createZooKerasSqrt(inputShape: List[Int] = null): Sqrt[T]
def createZooKerasSquare(inputShape: List[Int] = null): Square[T]
def createZooKerasSqueeze(dims: List[Int], inputShape: List[Int] = null): Squeeze[T]
def createZooKerasThreshold(th: Double = 1e-6, v: Double = 0.0, inputShape: List[Int] = null): Threshold[T]
def createZooKerasThresholdedReLU(theta: Double = 1.0, inputShape: List[Int] = null): ThresholdedReLU[T]
def createZooKerasTimeDistributed(layer: KerasLayer[Tensor[T], Tensor[T], T], inputShape: List[Int] = null): TimeDistributed[T]
def createZooKerasTop5Accuracy(zeroBasedLabel: Boolean = true): ValidationMethod[T]
def createZooKerasUpSampling1D(length: Int = 2, inputShape: List[Int] = null): UpSampling1D[T]
def createZooKerasUpSampling2D(size: List[Int], dimOrdering: String = "th", inputShape: List[Int] = null): UpSampling2D[T]
def createZooKerasUpSampling3D(size: List[Int], dimOrdering: String = "th", inputShape: List[Int] = null): UpSampling3D[T]
def createZooKerasWithinChannelLRN2D(size: Int = 5, alpha: Double = 1.0, beta: Double = 0.75, inputShape: List[Int] = null): WithinChannelLRN2D[T]
def createZooKerasZeroPadding1D(padding: List[Int], inputShape: List[Int] = null): ZeroPadding1D[T]
def createZooKerasZeroPadding2D(padding: List[Int], dimOrdering: String = "th", inputShape: List[Int] = null): ZeroPadding2D[T]
def createZooKerasZeroPadding3D(padding: List[Int], dimOrdering: String = "th", inputShape: List[Int] = null): ZeroPadding3D[T]
def criterionBackward(criterion: AbstractCriterion[Activity, Activity, T], input: List[JTensor], inputIsTable: Boolean, target: List[JTensor], targetIsTable: Boolean): List[JTensor]

Definition Classes
PythonBigDL
def criterionForward(criterion: AbstractCriterion[Activity, Activity, T], input: List[JTensor], inputIsTable: Boolean, target: List[JTensor], targetIsTable: Boolean): T

Definition Classes
PythonBigDL
def disableClip(optimizer: Optimizer[T, MiniBatch[T]]): Unit

Definition Classes
PythonBigDL
def distributedImageFrameToImageTensorRdd(imageFrame: DistributedImageFrame, floatKey: String, toChw: Boolean): JavaRDD[JTensor]

Definition Classes
PythonBigDL
def distributedImageFrameToLabelTensorRdd(imageFrame: DistributedImageFrame): JavaRDD[JTensor]

Definition Classes
PythonBigDL
def distributedImageFrameToPredict(imageFrame: DistributedImageFrame, key: String): JavaRDD[List[Any]]

Definition Classes
PythonBigDL
def dlClassifierModelTransform(dlClassifierModel: DLClassifierModel[T], dataSet: DataFrame): DataFrame

Definition Classes
PythonBigDL
def dlImageTransform(dlImageTransformer: DLImageTransformer, dataSet: DataFrame): DataFrame

Definition Classes
PythonBigDL
def dlModelTransform(dlModel: DLModel[T], dataSet: DataFrame): DataFrame

Definition Classes
PythonBigDL
def dlReadImage(path: String, sc: JavaSparkContext, minParitions: Int): DataFrame

Definition Classes
PythonBigDL
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def evaluate(module: KerasModel[T], x: JavaRDD[Sample], batchSize: Int): List[EvaluatedResult]

Definition Classes
PythonBigDLKeras
def evaluate(module: AbstractModule[Activity, Activity, T]): AbstractModule[Activity, Activity, T]

Definition Classes
PythonBigDL
def featureTransformDataset(dataset: DataSet[ImageFeature], transformer: FeatureTransformer): DataSet[ImageFeature]

Definition Classes
PythonBigDL
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def findGraphNode(model: Graph[T], name: String): ModuleNode[T]

Definition Classes
PythonBigDL
def fit(module: KerasModel[T], xTrain: List[JTensor], yTrain: JTensor, batchSize: Int, epochs: Int, xVal: List[JTensor], yVal: JTensor, localCores: Int): Unit

Definition Classes
PythonBigDLKeras
def fit(module: KerasModel[T], x: DataSet[ImageFeature], batchSize: Int, epochs: Int, validationData: DataSet[ImageFeature]): Unit

Definition Classes
PythonBigDLKeras
def fit(module: KerasModel[T], x: JavaRDD[Sample], batchSize: Int, epochs: Int, validationData: JavaRDD[Sample]): Unit

Definition Classes
PythonBigDLKeras
def fitClassifier(classifier: DLClassifier[T], dataSet: DataFrame): DLModel[T]

Definition Classes
PythonBigDL
def fitEstimator(estimator: DLEstimator[T], dataSet: DataFrame): DLModel[T]

Definition Classes
PythonBigDL
def freeze(model: AbstractModule[Activity, Activity, T], freezeLayers: List[String]): AbstractModule[Activity, Activity, T]

Definition Classes
PythonBigDL
def freezeUpTo(model: NetUtils[T, _], names: List[String]): Unit
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getContainerModules(module: Container[Activity, Activity, T]): List[AbstractModule[Activity, Activity, T]]

Definition Classes
PythonBigDL
def getFlattenModules(module: Container[Activity, Activity, T], includeContainer: Boolean): List[AbstractModule[Activity, Activity, T]]

Definition Classes
PythonBigDL
def getFlattenSubModules(module: AbstractModule[Activity, Activity, T], includeContainer: Boolean): List[AbstractModule[Activity, Activity, T]]
def getHiddenState(rec: Recurrent[T]): JActivity

Definition Classes
PythonBigDL
def getInputShape(module: Container[Activity, Activity, T]): List[List[Int]]

Definition Classes
PythonBigDLKeras
def getNodeAndCoreNumber(): Array[Int]

Definition Classes
PythonBigDL
def getOutputShape(module: Container[Activity, Activity, T]): List[List[Int]]

Definition Classes
PythonBigDLKeras
def getRealClassNameOfJValue(module: AbstractModule[Activity, Activity, T]): String

Definition Classes
PythonBigDL
def getRunningMean(module: BatchNormalization[T]): JTensor

Definition Classes
PythonBigDLKeras
def getRunningMean(module: BatchNormalization[T]): JTensor

Definition Classes
PythonBigDL
def getRunningStd(module: BatchNormalization[T]): JTensor

Definition Classes
PythonBigDLKeras
def getRunningStd(module: BatchNormalization[T]): JTensor

Definition Classes
PythonBigDL
def getSubModules(module: AbstractModule[Activity, Activity, T]): List[AbstractModule[Activity, Activity, T]]
def getWeights(model: AbstractModule[Activity, Activity, T]): List[JTensor]

Definition Classes
PythonBigDL
def hashCode(): Int

Definition Classes
AnyRef → Any
def imageFeatureGetKeys(imageFeature: ImageFeature): List[String]

Definition Classes
PythonBigDL
def imageFeatureToImageTensor(imageFeature: ImageFeature, floatKey: String, toChw: Boolean): JTensor

Definition Classes
PythonBigDL
def imageFeatureToLabelTensor(imageFeature: ImageFeature): JTensor

Definition Classes
PythonBigDL
def initEngine(): Unit

Definition Classes
PythonBigDL
def isDistributed(imageFrame: ImageFrame): Boolean

Definition Classes
PythonBigDL
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isLocal(imageFrame: ImageFrame): Boolean

Definition Classes
PythonBigDL
def isWithWeights(module: Module[T]): Boolean

Definition Classes
PythonBigDL
def jTensorsToActivity(input: List[JTensor], isTable: Boolean): Activity

Definition Classes
PythonBigDL
def kerasNetToModel(value: KerasNet[T]): Model[T]
def loadBigDL(path: String): AbstractModule[Activity, Activity, T]

Definition Classes
PythonBigDL
def loadBigDLModule(modulePath: String, weightPath: String): AbstractModule[Activity, Activity, T]

Definition Classes
PythonBigDL
def loadCaffe(model: AbstractModule[Activity, Activity, T], defPath: String, modelPath: String, matchAll: Boolean): AbstractModule[Activity, Activity, T]

Definition Classes
PythonBigDL
def loadCaffeModel(defPath: String, modelPath: String): AbstractModule[Activity, Activity, T]

Definition Classes
PythonBigDL
def loadOptimMethod(path: String): OptimMethod[T]

Definition Classes
PythonBigDL
def loadTF(path: String, inputs: List[String], outputs: List[String], byteOrder: String, binFile: String): AbstractModule[Activity, Activity, T]

Definition Classes
PythonBigDL
def loadTorch(path: String): AbstractModule[Activity, Activity, T]

Definition Classes
PythonBigDL
def localImageFrameToImageTensor(imageFrame: LocalImageFrame, floatKey: String, toChw: Boolean): List[JTensor]

Definition Classes
PythonBigDL
def localImageFrameToLabelTensor(imageFrame: LocalImageFrame): List[JTensor]

Definition Classes
PythonBigDL
def localImageFrameToPredict(imageFrame: LocalImageFrame, key: String): List[List[Any]]

Definition Classes
PythonBigDL
def modelBackward(model: AbstractModule[Activity, Activity, T], input: List[JTensor], inputIsTable: Boolean, gradOutput: List[JTensor], gradOutputIsTable: Boolean): List[JTensor]

Definition Classes
PythonBigDL
def modelEvaluate(model: AbstractModule[Activity, Activity, T], valRDD: JavaRDD[Sample], batchSize: Int, valMethods: List[ValidationMethod[T]]): List[EvaluatedResult]

Definition Classes
PythonBigDL
def modelForward(model: AbstractModule[Activity, Activity, T], input: List[JTensor], inputIsTable: Boolean): List[JTensor]

Definition Classes
PythonBigDL
def modelGetParameters(model: AbstractModule[Activity, Activity, T]): Map[Any, Map[Any, List[List[Any]]]]

Definition Classes
PythonBigDL
def modelPredictClass(model: AbstractModule[Activity, Activity, T], dataRdd: JavaRDD[Sample]): JavaRDD[Int]

Definition Classes
PythonBigDL
def modelPredictImage(model: AbstractModule[Activity, Activity, T], imageFrame: ImageFrame, featLayerName: String, shareBuffer: Boolean, batchPerPartition: Int, predictKey: String): ImageFrame

Definition Classes
PythonBigDL
def modelPredictRDD(model: AbstractModule[Activity, Activity, T], dataRdd: JavaRDD[Sample]): JavaRDD[JTensor]

Definition Classes
PythonBigDL
def modelSave(module: AbstractModule[Activity, Activity, T], path: String, overWrite: Boolean): Unit

Definition Classes
PythonBigDL
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def netLoad(modulePath: String, weightPath: String): AbstractModule[Activity, Activity, T]
def netLoadBigDL(modulePath: String, weightPath: String): AbstractModule[Activity, Activity, T]
def netLoadCaffe(defPath: String, modelPath: String): AbstractModule[Activity, Activity, T]
def netLoadTF(folder: String): AbstractModule[Activity, Activity, T]
def netLoadTF(path: String, inputs: List[String], outputs: List[String], byteOrder: String, binFile: String = null): AbstractModule[Activity, Activity, T]
def netLoadTorch(path: String): AbstractModule[Activity, Activity, T]
def netToKeras(value: NetUtils[T, _]): KerasLayer[Activity, Activity, T]
def newGraph(model: NetUtils[T, _], outputs: List[String]): NetUtils[T, _]
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def predictLocal(model: AbstractModule[Activity, Activity, T], features: List[JTensor]): List[JTensor]

Definition Classes
PythonBigDL
def predictLocalClass(model: AbstractModule[Activity, Activity, T], features: List[JTensor]): List[Int]

Definition Classes
PythonBigDL
def quantize(module: AbstractModule[Activity, Activity, T]): Module[T]

Definition Classes
PythonBigDL
def read(path: String, sc: JavaSparkContext, minPartitions: Int): ImageFrame

Definition Classes
PythonBigDL
def readParquet(path: String, sqlContext: SQLContext): DistributedImageFrame

Definition Classes
PythonBigDL
def redirectSparkLogs(logPath: String): Unit

Definition Classes
PythonBigDL
def saveBigDLModule(module: AbstractModule[Activity, Activity, T], modulePath: String, weightPath: String, overWrite: Boolean): Unit

Definition Classes
PythonBigDL
def saveCaffe(module: AbstractModule[Activity, Activity, T], prototxtPath: String, modelPath: String, useV2: Boolean, overwrite: Boolean): Unit

Definition Classes
PythonBigDL
def saveGraphTopology(model: Graph[T], logPath: String): Graph[T]

Definition Classes
PythonBigDL
def saveOptimMethod(method: OptimMethod[T], path: String, overWrite: Boolean): Unit

Definition Classes
PythonBigDL
def saveTF(model: AbstractModule[Activity, Activity, T], inputs: List[Any], path: String, byteOrder: String, dataFormat: String): Unit

Definition Classes
PythonBigDL
def saveTensorDictionary(tensors: HashMap[String, JTensor], path: String): Unit

Definition Classes
PythonBigDL
def seqFilesToImageFrame(url: String, sc: JavaSparkContext, classNum: Int, partitionNum: Int): ImageFrame

Definition Classes
PythonBigDL
def setBatchSizeDLClassifier(classifier: DLClassifier[T], batchSize: Int): DLClassifier[T]

Definition Classes
PythonBigDL
def setBatchSizeDLClassifierModel(dlClassifierModel: DLClassifierModel[T], batchSize: Int): DLClassifierModel[T]

Definition Classes
PythonBigDL
def setBatchSizeDLEstimator(estimator: DLEstimator[T], batchSize: Int): DLEstimator[T]

Definition Classes
PythonBigDL
def setBatchSizeDLModel(dlModel: DLModel[T], batchSize: Int): DLModel[T]

Definition Classes
PythonBigDL
def setCheckPoint(optimizer: Optimizer[T, MiniBatch[T]], trigger: Trigger, checkPointPath: String, isOverwrite: Boolean): Unit

Definition Classes
PythonBigDL
def setConstantClip(optimizer: Optimizer[T, MiniBatch[T]], min: Float, max: Float): Unit

Definition Classes
PythonBigDL
def setCriterion(optimizer: Optimizer[T, MiniBatch[T]], criterion: Criterion[T]): Unit

Definition Classes
PythonBigDL
def setFeatureSizeDLClassifierModel(dlClassifierModel: DLClassifierModel[T], featureSize: ArrayList[Int]): DLClassifierModel[T]

Definition Classes
PythonBigDL
def setFeatureSizeDLModel(dlModel: DLModel[T], featureSize: ArrayList[Int]): DLModel[T]

Definition Classes
PythonBigDL
def setInitMethod(layer: Initializable, initMethods: ArrayList[InitializationMethod]): layer.type

Definition Classes
PythonBigDL
def setInitMethod(layer: Initializable, weightInitMethod: InitializationMethod, biasInitMethod: InitializationMethod): layer.type

Definition Classes
PythonBigDL
def setL2NormClip(optimizer: Optimizer[T, MiniBatch[T]], normValue: Float): Unit

Definition Classes
PythonBigDL
def setLearningRateDLClassifier(classifier: DLClassifier[T], lr: Double): DLClassifier[T]

Definition Classes
PythonBigDL
def setLearningRateDLEstimator(estimator: DLEstimator[T], lr: Double): DLEstimator[T]

Definition Classes
PythonBigDL
def setMaxEpochDLClassifier(classifier: DLClassifier[T], maxEpoch: Int): DLClassifier[T]

Definition Classes
PythonBigDL
def setMaxEpochDLEstimator(estimator: DLEstimator[T], maxEpoch: Int): DLEstimator[T]

Definition Classes
PythonBigDL
def setModelSeed(seed: Long): Unit

Definition Classes
PythonBigDL
def setRunningMean(module: BatchNormalization[T], runningMean: JTensor): Unit

Definition Classes
PythonBigDLKeras
def setRunningMean(module: BatchNormalization[T], runningMean: JTensor): Unit

Definition Classes
PythonBigDL
def setRunningStd(module: BatchNormalization[T], runningStd: JTensor): Unit

Definition Classes
PythonBigDLKeras
def setRunningStd(module: BatchNormalization[T], runningStd: JTensor): Unit

Definition Classes
PythonBigDL
def setStopGradient(model: Graph[T], layers: List[String]): Graph[T]

Definition Classes
PythonBigDL
def setTrainData(optimizer: Optimizer[T, MiniBatch[T]], trainingRdd: JavaRDD[Sample], batchSize: Int): Unit

Definition Classes
PythonBigDL
def setTrainSummary(optimizer: Optimizer[T, MiniBatch[T]], summary: TrainSummary): Unit

Definition Classes
PythonBigDL
def setValSummary(optimizer: Optimizer[T, MiniBatch[T]], summary: ValidationSummary): Unit

Definition Classes
PythonBigDL
def setValidation(optimizer: Optimizer[T, MiniBatch[T]], batchSize: Int, trigger: Trigger, xVal: List[JTensor], yVal: JTensor, vMethods: List[ValidationMethod[T]]): Unit

Definition Classes
PythonBigDL
def setValidation(optimizer: Optimizer[T, MiniBatch[T]], batchSize: Int, trigger: Trigger, valRdd: JavaRDD[Sample], vMethods: List[ValidationMethod[T]]): Unit

Definition Classes
PythonBigDL
def setValidationFromDataSet(optimizer: Optimizer[T, MiniBatch[T]], batchSize: Int, trigger: Trigger, valDataSet: DataSet[ImageFeature], vMethods: List[ValidationMethod[T]]): Unit

Definition Classes
PythonBigDL
def setWeights(model: AbstractModule[Activity, Activity, T], weights: List[JTensor]): Unit

Definition Classes
PythonBigDL
def shapeToJList(shape: Shape): List[List[Int]]

Definition Classes
PythonBigDLKeras
def showBigDlInfoLogs(): Unit

Definition Classes
PythonBigDL
def summaryReadScalar(summary: Summary, tag: String): List[List[Any]]

Definition Classes
PythonBigDL
def summarySetTrigger(summary: TrainSummary, summaryName: String, trigger: Trigger): TrainSummary

Definition Classes
PythonBigDL
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def testSample(sample: Sample): Sample

Definition Classes
PythonBigDL
def testTensor(jTensor: JTensor): JTensor

Definition Classes
PythonBigDL
def toJSample(psamples: RDD[Sample]): RDD[Sample[T]]

Definition Classes
PythonBigDL
def toJSample(record: Sample): Sample[T]

Definition Classes
PythonBigDL
def toJTensor(tensor: Tensor[T]): JTensor

Definition Classes
PythonBigDL
def toPySample(sample: Sample[T]): Sample

Definition Classes
PythonBigDL
def toSampleArray(Xs: List[Tensor[T]], y: Tensor[T]): Array[Sample[T]]

Definition Classes
PythonBigDL
def toScalaArray(list: List[Int]): Array[Int]

Definition Classes
PythonBigDLKeras
def toScalaMultiShape(inputShape: List[List[Int]]): Shape

Definition Classes
PythonBigDLKeras
def toScalaShape(inputShape: List[Int]): Shape

Definition Classes
PythonBigDLKeras
def toString(): String

Definition Classes
AnyRef → Any
def toTensor(jTensor: JTensor): Tensor[T]

Definition Classes
PythonBigDL
def trainTF(modelPath: String, output: String, samples: JavaRDD[Sample], optMethod: OptimMethod[T], criterion: Criterion[T], batchSize: Int, endWhen: Trigger): AbstractModule[Activity, Activity, T]

Definition Classes
PythonBigDL
def transformImageFeature(transformer: FeatureTransformer, feature: ImageFeature): ImageFeature

Definition Classes
PythonBigDL
def transformImageFrame(transformer: FeatureTransformer, imageFrame: ImageFrame): ImageFrame

Definition Classes
PythonBigDL
def unFreeze(model: AbstractModule[Activity, Activity, T], names: List[String]): AbstractModule[Activity, Activity, T]

Definition Classes
PythonBigDL
def uniform(a: Double, b: Double, size: List[Int]): JTensor

Definition Classes
PythonBigDL
def updateParameters(model: AbstractModule[Activity, Activity, T], lr: Double): Unit

Definition Classes
PythonBigDL
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def zooClearGradientClipping(module: KerasNet[T]): Unit
def zooCompile(module: KerasNet[T], optimizer: OptimMethod[T], loss: Criterion[T], metrics: List[ValidationMethod[T]] = null): Unit
def zooEvaluate(module: KerasNet[T], x: JavaRDD[Sample], batchSize: Int = 32): List[EvaluatedResult]
def zooFit(module: KerasNet[T], xTrain: List[JTensor], yTrain: JTensor, batchSize: Int, nbEpoch: Int, xVal: List[JTensor], yVal: JTensor): Unit
def zooFit(module: KerasNet[T], x: ImageSet, batchSize: Int, nbEpoch: Int, validationData: ImageSet): Unit
def zooFit(module: KerasNet[T], x: JavaRDD[Sample], batchSize: Int = 32, nbEpoch: Int = 10, validationData: JavaRDD[Sample] = null): Unit
def zooKerasNetSummary(model: KerasNet[T], lineLength: Int = 120, positions: List[Double]): Unit
def zooPredict(module: KerasNet[T], x: List[JTensor], batchSize: Int): List[List[JTensor]]
def zooPredict(module: KerasNet[T], x: JavaRDD[Sample], batchSize: Int = 32): JavaRDD[List[JTensor]]
def zooPredictClasses(module: KerasNet[T], x: JavaRDD[Sample], batchSize: Int = 32, zeroBasedLabel: Boolean = true): JavaRDD[Int]
def zooSaveGraphTopology(module: Model[T], logPath: String, backward: Boolean = false): Model[T]
def zooSetCheckpoint(module: KerasNet[T], path: String, overWrite: Boolean = true): Unit
def zooSetConstantGradientClipping(module: KerasNet[T], min: Float, max: Float): Unit
def zooSetGradientClippingByL2Norm(module: KerasNet[T], clipNorm: Float): Unit
def zooSetTensorBoard(module: KerasNet[T], logDir: String, appName: String): Unit

class PythonZooKeras[T] extends PythonBigDLKeras[T]

Instance Constructors

new PythonZooKeras()(implicit arg0: ClassTag[T], ev: TensorNumeric[T])

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def activityToJTensors(outputActivity: Activity): List[JTensor]

def addScheduler(seq: SequentialSchedule, scheduler: LearningRateSchedule, maxIteration: Int): SequentialSchedule

final def asInstanceOf[T0]: T0

def batching(dataset: DataSet[Sample[T]], batchSize: Int): DataSet[MiniBatch[T]]

def clone(): AnyRef

def compile(module: KerasModel[T], optimizer: OptimMethod[T], loss: Criterion[T], metrics: List[ValidationMethod[T]]): Unit

def connectInputs(module: AbstractModule[Activity, Activity, T], x: List[Variable[T]]): Variable[T]

def createAUC(thresholdNum: Int): ValidationMethod[T]

def createAbs(): Abs[T]

def createAbsCriterion(sizeAverage: Boolean): AbsCriterion[T]

def createActivityRegularization(l1: Double, l2: Double): ActivityRegularization[T]

def createAdadelta(decayRate: Double, Epsilon: Double): Adadelta[T]

def createAdagrad(learningRate: Double, learningRateDecay: Double, weightDecay: Double): Adagrad[T]

def createAdam(learningRate: Double, learningRateDecay: Double, beta1: Double, beta2: Double, Epsilon: Double): Adam[T]

def createAdamax(learningRate: Double, beta1: Double, beta2: Double, Epsilon: Double): Adamax[T]

def createAdd(inputSize: Int): Add[T]

def createAddConstant(constant_scalar: Double, inplace: Boolean): AddConstant[T]

def createAspectScale(scale: Int, scaleMultipleOf: Int, maxSize: Int, resizeMode: Int, useScaleFactor: Boolean, minScale: Double): FeatureTransformer

def createBCECriterion(weights: JTensor, sizeAverage: Boolean): BCECriterion[T]

def createBatchNormalization(nOutput: Int, eps: Double, momentum: Double, affine: Boolean, initWeight: JTensor, initBias: JTensor, initGradWeight: JTensor, initGradBias: JTensor): BatchNormalization[T]

def createBiRecurrent(merge: AbstractModule[Table, Tensor[T], T]): BiRecurrent[T]

def createBifurcateSplitTable(dimension: Int): BifurcateSplitTable[T]

def createBilinear(inputSize1: Int, inputSize2: Int, outputSize: Int, biasRes: Boolean, wRegularizer: Regularizer[T], bRegularizer: Regularizer[T]): Bilinear[T]

def createBilinearFiller(): BilinearFiller.type

def createBinaryThreshold(th: Double, ip: Boolean): BinaryThreshold[T]

def createBinaryTreeLSTM(inputSize: Int, hiddenSize: Int, gateOutput: Boolean, withGraph: Boolean): BinaryTreeLSTM[T]

def createBottle(module: AbstractModule[Activity, Activity, T], nInputDim: Int, nOutputDim1: Int): Bottle[T]

def createBrightness(deltaLow: Double, deltaHigh: Double): Brightness

def createBytesToMat(byteKey: String): BytesToMat

def createCAdd(size: List[Int], bRegularizer: Regularizer[T]): CAdd[T]

def createCAddTable(inplace: Boolean): CAddTable[T, T]

def createCAveTable(inplace: Boolean): CAveTable[T]

def createCDivTable(): CDivTable[T]

def createCMaxTable(): CMaxTable[T]

def createCMinTable(): CMinTable[T]

def createCMul(size: List[Int], wRegularizer: Regularizer[T]): CMul[T]

def createCMulTable(): CMulTable[T]

def createCSubTable(): CSubTable[T]

def createCategoricalCrossEntropy(): CategoricalCrossEntropy[T]

def createCenterCrop(cropWidth: Int, cropHeight: Int, isClip: Boolean): CenterCrop

def createChannelNormalize(meanR: Double, meanG: Double, meanB: Double, stdR: Double, stdG: Double, stdB: Double): FeatureTransformer

def createChannelOrder(): ChannelOrder

def createClamp(min: Int, max: Int): Clamp[T]

def createClassNLLCriterion(weights: JTensor, sizeAverage: Boolean, logProbAsInput: Boolean): ClassNLLCriterion[T]

def createClassSimplexCriterion(nClasses: Int): ClassSimplexCriterion[T]

def createConcat(dimension: Int): Concat[T]

def createConcatTable(): ConcatTable[T]

def createConstInitMethod(value: Double): ConstInitMethod

def createContiguous(): Contiguous[T]

def createContrast(deltaLow: Double, deltaHigh: Double): Contrast

def createConvLSTMPeephole3D(inputSize: Int, outputSize: Int, kernelI: Int, kernelC: Int, stride: Int, padding: Int, wRegularizer: Regularizer[T], uRegularizer: Regularizer[T], bRegularizer: Regularizer[T], cRegularizer: Regularizer[T], withPeephole: Boolean): ConvLSTMPeephole3D[T]

def createCosine(inputSize: Int, outputSize: Int): Cosine[T]

def createCosineDistance(): CosineDistance[T]

def createCosineDistanceCriterion(sizeAverage: Boolean): CosineDistanceCriterion[T]

def createCosineEmbeddingCriterion(margin: Double, sizeAverage: Boolean): CosineEmbeddingCriterion[T]

def createCosineProximityCriterion(): CosineProximityCriterion[T]

def createCropping2D(heightCrop: List[Int], widthCrop: List[Int], dataFormat: String): Cropping2D[T]

def createCropping3D(dim1Crop: List[Int], dim2Crop: List[Int], dim3Crop: List[Int], dataFormat: String): Cropping3D[T]

def createCrossEntropyCriterion(weights: JTensor, sizeAverage: Boolean): CrossEntropyCriterion[T]

def createCrossProduct(numTensor: Int, embeddingSize: Int): CrossProduct[T]

def createDLClassifier(model: Module[T], criterion: Criterion[T], featureSize: ArrayList[Int], labelSize: ArrayList[Int]): DLClassifier[T]

def createDLClassifierModel(model: Module[T], featureSize: ArrayList[Int]): DLClassifierModel[T]

def createDLEstimator(model: Module[T], criterion: Criterion[T], featureSize: ArrayList[Int], labelSize: ArrayList[Int]): DLEstimator[T]

def createDLImageTransformer(transformer: FeatureTransformer): DLImageTransformer

def createDLModel(model: Module[T], featureSize: ArrayList[Int]): DLModel[T]

def createDatasetFromImageFrame(imageFrame: ImageFrame): DataSet[ImageFeature]

def createDefault(): Default

def createDenseToSparse(): DenseToSparse[T]

def createDetectionCrop(roiKey: String, normalized: Boolean): DetectionCrop

def createDetectionOutputFrcnn(nmsThresh: Float, nClasses: Int, bboxVote: Boolean, maxPerImage: Int, thresh: Double): DetectionOutputFrcnn