com.intel.analytics.bigdl.python.api

PythonBigDL

class PythonBigDL[T] extends Serializable

Implementation of Python API for BigDL

Linear Supertypes
Serializable, Serializable, AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. PythonBigDL
  2. Serializable
  3. Serializable
  4. AnyRef
  5. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new PythonBigDL()(implicit arg0: ClassTag[T], ev: TensorNumeric[T])

Value Members

  1. final def !=(arg0: AnyRef): Boolean

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

    Definition Classes
    Any
  3. final def ##(): Int

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

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

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

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

  8. final def asInstanceOf[T0]: T0

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

  10. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  11. def createAbs(): Abs[T]

  12. def createAbsCriterion(sizeAverage: Boolean = true): AbsCriterion[T]

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

  14. def createAdadelta(decayRate: Double = 0.9, Epsilon: Double = 1e-10): Adadelta[T]

  15. def createAdagrad(learningRate: Double = 1e-3, learningRateDecay: Double = 0.0, weightDecay: Double = 0.0): Adagrad[T]

  16. def createAdam(learningRate: Double = 1e-3, learningRateDecay: Double = 0.0, beta1: Double = 0.9, beta2: Double = 0.999, Epsilon: Double = 1e-8): Adam[T]

  17. def createAdamax(learningRate: Double = 0.002, beta1: Double = 0.9, beta2: Double = 0.999, Epsilon: Double = 1e-38): Adamax[T]

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

  19. def createAddConstant(constant_scalar: Double, inplace: Boolean = false): AddConstant[T]

  20. def createAspectScale(scale: Int, scaleMultipleOf: Int, maxSize: Int, resizeMode: Int = 1, useScaleFactor: Boolean = true, minScale: Double = 1): FeatureTransformer

  21. def createAttention(hiddenSize: Int, numHeads: Int, attentionDropout: Float): Attention[T]

  22. def createBCECriterion(weights: JTensor = null, sizeAverage: Boolean = true): BCECriterion[T]

  23. def createBatchNormalization(nOutput: Int, eps: Double = 1e-5, momentum: Double = 0.1, affine: Boolean = true, initWeight: JTensor = null, initBias: JTensor = null, initGradWeight: JTensor = null, initGradBias: JTensor = null): BatchNormalization[T]

  24. def createBiRecurrent(merge: AbstractModule[Table, Tensor[T], T] = null): BiRecurrent[T]

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

  26. def createBilinear(inputSize1: Int, inputSize2: Int, outputSize: Int, biasRes: Boolean = true, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null): Bilinear[T]

  27. def createBilinearFiller(): BilinearFiller.type

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

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

  30. def createBottle(module: AbstractModule[Activity, Activity, T], nInputDim: Int = 2, nOutputDim1: Int = Int.MaxValue): Bottle[T]

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

  32. def createBytesToMat(byteKey: String): BytesToMat

  33. def createCAdd(size: List[Int], bRegularizer: Regularizer[T] = null): CAdd[T]

  34. def createCAddTable(inplace: Boolean = false): CAddTable[T, T]

  35. def createCAveTable(inplace: Boolean = false): CAveTable[T]

  36. def createCDivTable(): CDivTable[T]

  37. def createCMaxTable(): CMaxTable[T]

  38. def createCMinTable(): CMinTable[T]

  39. def createCMul(size: List[Int], wRegularizer: Regularizer[T] = null): CMul[T]

  40. def createCMulTable(): CMulTable[T]

  41. def createCSubTable(): CSubTable[T]

  42. def createCategoricalCrossEntropy(): CategoricalCrossEntropy[T]

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

  44. def createChannelNormalize(meanR: Double, meanG: Double, meanB: Double, stdR: Double = 1, stdG: Double = 1, stdB: Double = 1): FeatureTransformer

  45. def createChannelOrder(): ChannelOrder

  46. def createChannelScaledNormalizer(meanR: Int, meanG: Int, meanB: Int, scale: Double): ChannelScaledNormalizer

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

  48. def createClassNLLCriterion(weights: JTensor = null, sizeAverage: Boolean = true, logProbAsInput: Boolean = true): ClassNLLCriterion[T]

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

  50. def createColorJitter(brightnessProb: Double = 0.5, brightnessDelta: Double = 32, contrastProb: Double = 0.5, contrastLower: Double = 0.5, contrastUpper: Double = 1.5, hueProb: Double = 0.5, hueDelta: Double = 18, saturationProb: Double = 0.5, saturationLower: Double = 0.5, saturationUpper: Double = 1.5, randomOrderProb: Double = 0, shuffle: Boolean = false): ColorJitter

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

  52. def createConcatTable(): ConcatTable[T]

  53. def createConstInitMethod(value: Double): ConstInitMethod

  54. def createContiguous(): Contiguous[T]

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

  56. def createConvLSTMPeephole(inputSize: Int, outputSize: Int, kernelI: Int, kernelC: Int, stride: Int = 1, padding: Int = 1, activation: TensorModule[T] = null, innerActivation: TensorModule[T] = null, wRegularizer: Regularizer[T] = null, uRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, cRegularizer: Regularizer[T] = null, withPeephole: Boolean = true): ConvLSTMPeephole[T]

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

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

  59. def createCosineDistance(): CosineDistance[T]

  60. def createCosineDistanceCriterion(sizeAverage: Boolean = true): CosineDistanceCriterion[T]

  61. def createCosineEmbeddingCriterion(margin: Double = 0.0, sizeAverage: Boolean = true): CosineEmbeddingCriterion[T]

  62. def createCosineProximityCriterion(): CosineProximityCriterion[T]

  63. def createCropping2D(heightCrop: List[Int], widthCrop: List[Int], dataFormat: String = "NCHW"): Cropping2D[T]

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

  65. def createCrossEntropyCriterion(weights: JTensor = null, sizeAverage: Boolean = true): CrossEntropyCriterion[T]

  66. def createCrossProduct(numTensor: Int = 0, embeddingSize: Int = 0): CrossProduct[T]

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

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

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

  70. def createDLImageTransformer(transformer: FeatureTransformer): DLImageTransformer

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

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

  73. def createDefault(): Default

  74. def createDenseToSparse(): DenseToSparse[T]

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

  76. def createDetectionOutputFrcnn(nmsThresh: Float = 0.3f, nClasses: Int, bboxVote: Boolean, maxPerImage: Int = 100, thresh: Double = 0.05): DetectionOutputFrcnn

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

  78. def createDiceCoefficientCriterion(sizeAverage: Boolean = true, epsilon: Float = 1.0f): DiceCoefficientCriterion[T]

  79. def createDistKLDivCriterion(sizeAverage: Boolean = true): DistKLDivCriterion[T]

  80. def createDistriOptimizer(model: AbstractModule[Activity, Activity, T], trainingRdd: JavaRDD[Sample], criterion: Criterion[T], optimMethod: Map[String, OptimMethod[T]], endTrigger: Trigger, batchSize: Int): Optimizer[T, MiniBatch[T]]

  81. def createDistriOptimizerFromDataSet(model: AbstractModule[Activity, Activity, T], trainDataSet: DataSet[ImageFeature], criterion: Criterion[T], optimMethod: Map[String, OptimMethod[T]], endTrigger: Trigger, batchSize: Int): Optimizer[T, MiniBatch[T]]

  82. def createDistributedImageFrame(imageRdd: JavaRDD[JTensor], labelRdd: JavaRDD[JTensor]): DistributedImageFrame

  83. def createDotProduct(): DotProduct[T]

  84. def createDotProductCriterion(sizeAverage: Boolean = false): DotProductCriterion[T]

  85. def createDropout(initP: Double = 0.5, inplace: Boolean = false, scale: Boolean = true): Dropout[T]

  86. def createELU(alpha: Double = 1.0, inplace: Boolean = false): ELU[T]

  87. def createEcho(): Echo[T]

  88. def createEuclidean(inputSize: Int, outputSize: Int, fastBackward: Boolean = true): Euclidean[T]

  89. def createEveryEpoch(): Trigger

  90. def createExp(): Exp[T]

  91. def createExpand(meansR: Int = 123, meansG: Int = 117, meansB: Int = 104, minExpandRatio: Double = 1.0, maxExpandRatio: Double = 4.0): Expand

  92. def createExpandSize(targetSizes: List[Int]): ExpandSize[T]

  93. def createExponential(decayStep: Int, decayRate: Double, stairCase: Boolean = false): Exponential

  94. def createFPN(in_channels_list: List[Int], out_channels: Int, top_blocks: Int = 0, in_channels_of_p6p7: Int = 0, out_channels_of_p6p7: Int = 0): FPN[T]

  95. def createFeedForwardNetwork(hiddenSize: Int, filterSize: Int, reluDropout: Float): FeedForwardNetwork[T]

  96. def createFiller(startX: Double, startY: Double, endX: Double, endY: Double, value: Int = 255): Filler

  97. def createFixExpand(eh: Int, ew: Int): FixExpand

  98. def createFixedCrop(wStart: Double, hStart: Double, wEnd: Double, hEnd: Double, normalized: Boolean, isClip: Boolean): FixedCrop

  99. def createFlattenTable(): FlattenTable[T]

  100. def createFtrl(learningRate: Double = 1e-3, learningRatePower: Double = 0.5, initialAccumulatorValue: Double = 0.1, l1RegularizationStrength: Double = 0.0, l2RegularizationStrength: Double = 0.0, l2ShrinkageRegularizationStrength: Double = 0.0): Ftrl[T]

  101. def createGRU(inputSize: Int, outputSize: Int, p: Double = 0, activation: TensorModule[T] = null, innerActivation: TensorModule[T] = null, wRegularizer: Regularizer[T] = null, uRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null): GRU[T]

  102. def createGaussianCriterion(): GaussianCriterion[T]

  103. def createGaussianDropout(rate: Double): GaussianDropout[T]

  104. def createGaussianNoise(stddev: Double): GaussianNoise[T]

  105. def createGaussianSampler(): GaussianSampler[T]

  106. def createGradientReversal(lambda: Double = 1): GradientReversal[T]

  107. def createHFlip(): HFlip

  108. def createHardShrink(lambda: Double = 0.5): HardShrink[T]

  109. def createHardSigmoid: HardSigmoid[T]

  110. def createHardTanh(minValue: Double = 1, maxValue: Double = 1, inplace: Boolean = false): HardTanh[T]

  111. def createHighway(size: Int, withBias: Boolean, activation: TensorModule[T] = null, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null): Graph[T]

  112. def createHingeEmbeddingCriterion(margin: Double = 1, sizeAverage: Boolean = true): HingeEmbeddingCriterion[T]

  113. def createHitRatio(k: Int = 10, negNum: Int = 100): ValidationMethod[T]

  114. def createHue(deltaLow: Double, deltaHigh: Double): Hue

  115. def createIdentity(): Identity[T]

  116. def createImageFeature(data: JTensor = null, label: JTensor = null, uri: String = null): ImageFeature

  117. def createImageFrameToSample(inputKeys: List[String], targetKeys: List[String], sampleKey: String): ImageFrameToSample[T]

  118. def createIndex(dimension: Int): Index[T]

  119. def createInferReshape(size: List[Int], batchMode: Boolean = false): InferReshape[T]

  120. def createInput(): ModuleNode[T]

  121. def createJoinTable(dimension: Int, nInputDims: Int): JoinTable[T]

  122. def createKLDCriterion(sizeAverage: Boolean): KLDCriterion[T]

  123. def createKullbackLeiblerDivergenceCriterion: KullbackLeiblerDivergenceCriterion[T]

  124. def createL1Cost(): L1Cost[T]

  125. def createL1HingeEmbeddingCriterion(margin: Double = 1): L1HingeEmbeddingCriterion[T]

  126. def createL1L2Regularizer(l1: Double, l2: Double): L1L2Regularizer[T]

  127. def createL1Penalty(l1weight: Int, sizeAverage: Boolean = false, provideOutput: Boolean = true): L1Penalty[T]

  128. def createL1Regularizer(l1: Double): L1Regularizer[T]

  129. def createL2Regularizer(l2: Double): L2Regularizer[T]

  130. def createLBFGS(maxIter: Int = 20, maxEval: Double = Double.MaxValue, tolFun: Double = 1e-5, tolX: Double = 1e-9, nCorrection: Int = 100, learningRate: Double = 1.0, verbose: Boolean = false, lineSearch: LineSearch[T] = null, lineSearchOptions: Map[Any, Any] = null): LBFGS[T]

  131. def createLSTM(inputSize: Int, hiddenSize: Int, p: Double = 0, activation: TensorModule[T] = null, innerActivation: TensorModule[T] = null, wRegularizer: Regularizer[T] = null, uRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null): LSTM[T]

  132. def createLSTMPeephole(inputSize: Int, hiddenSize: Int, p: Double = 0, wRegularizer: Regularizer[T] = null, uRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null): LSTMPeephole[T]

  133. def createLayerNormalization(hiddenSize: Int): LayerNormalization[T]

  134. def createLeakyReLU(negval: Double = 0.01, inplace: Boolean = false): LeakyReLU[T]

  135. def createLinear(inputSize: Int, outputSize: Int, withBias: Boolean, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, initWeight: JTensor = null, initBias: JTensor = null, initGradWeight: JTensor = null, initGradBias: JTensor = null): Linear[T]

  136. def createLocalImageFrame(images: List[JTensor], labels: List[JTensor]): LocalImageFrame

  137. def createLocalOptimizer(features: List[JTensor], y: JTensor, model: AbstractModule[Activity, Activity, T], criterion: Criterion[T], optimMethod: Map[String, OptimMethod[T]], endTrigger: Trigger, batchSize: Int, localCores: Int): Optimizer[T, MiniBatch[T]]

  138. def createLocallyConnected1D(nInputFrame: Int, inputFrameSize: Int, outputFrameSize: Int, kernelW: Int, strideW: Int = 1, propagateBack: Boolean = true, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, initWeight: JTensor = null, initBias: JTensor = null, initGradWeight: JTensor = null, initGradBias: JTensor = null): LocallyConnected1D[T]

  139. def createLocallyConnected2D(nInputPlane: Int, inputWidth: Int, inputHeight: Int, nOutputPlane: Int, kernelW: Int, kernelH: Int, strideW: Int = 1, strideH: Int = 1, padW: Int = 0, padH: Int = 0, propagateBack: Boolean = true, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, initWeight: JTensor = null, initBias: JTensor = null, initGradWeight: JTensor = null, initGradBias: JTensor = null, withBias: Boolean = true, dataFormat: String = "NCHW"): LocallyConnected2D[T]

  140. def createLog(): Log[T]

  141. def createLogSigmoid(): LogSigmoid[T]

  142. def createLogSoftMax(): LogSoftMax[T]

  143. def createLookupTable(nIndex: Int, nOutput: Int, paddingValue: Double = 0, maxNorm: Double = Double.MaxValue, normType: Double = 2.0, shouldScaleGradByFreq: Boolean = false, wRegularizer: Regularizer[T] = null): LookupTable[T]

  144. def createLookupTableSparse(nIndex: Int, nOutput: Int, combiner: String = "sum", maxNorm: Double = 1, wRegularizer: Regularizer[T] = null): LookupTableSparse[T]

  145. def createLoss(criterion: Criterion[T]): ValidationMethod[T]

  146. def createMAE(): ValidationMethod[T]

  147. def createMM(transA: Boolean = false, transB: Boolean = false): MM[T]

  148. def createMSECriterion: MSECriterion[T]

  149. def createMV(trans: Boolean = false): MV[T]

  150. def createMapTable(module: AbstractModule[Activity, Activity, T] = null): MapTable[T]

  151. def createMarginCriterion(margin: Double = 1.0, sizeAverage: Boolean = true, squared: Boolean = false): MarginCriterion[T]

  152. def createMarginRankingCriterion(margin: Double = 1.0, sizeAverage: Boolean = true): MarginRankingCriterion[T]

  153. def createMaskedSelect(): MaskedSelect[T]

  154. def createMasking(maskValue: Double): Masking[T]

  155. def createMatToFloats(validHeight: Int = 300, validWidth: Int = 300, validChannels: Int = 3, outKey: String = ImageFeature.floats, shareBuffer: Boolean = true): MatToFloats

  156. def createMatToTensor(toRGB: Boolean = false, tensorKey: String = ImageFeature.imageTensor): MatToTensor[T]

  157. def createMax(dim: Int = 1, numInputDims: Int = Int.MinValue): Max[T]

  158. def createMaxEpoch(max: Int): Trigger

  159. def createMaxIteration(max: Int): Trigger

  160. def createMaxScore(max: Float): Trigger

  161. def createMaxout(inputSize: Int, outputSize: Int, maxoutNumber: Int, withBias: Boolean = true, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, initWeight: Tensor[T] = null, initBias: Tensor[T] = null): Maxout[T]

  162. def createMean(dimension: Int = 1, nInputDims: Int = 1, squeeze: Boolean = true): Mean[T]

  163. def createMeanAbsolutePercentageCriterion: MeanAbsolutePercentageCriterion[T]

  164. def createMeanAveragePrecision(k: Int, classes: Int): ValidationMethod[T]

  165. def createMeanAveragePrecisionObjectDetection(classes: Int, iou: Float, useVoc2007: Boolean, skipClass: Int): ValidationMethod[T]

  166. def createMeanSquaredLogarithmicCriterion: MeanSquaredLogarithmicCriterion[T]

  167. def createMin(dim: Int = 1, numInputDims: Int = Int.MinValue): Min[T]

  168. def createMinLoss(min: Float): Trigger

  169. def createMixtureTable(dim: Int = Int.MaxValue): MixtureTable[T]

  170. def createModel(input: List[ModuleNode[T]], output: List[ModuleNode[T]]): Graph[T]

  171. def createModelPreprocessor(preprocessor: AbstractModule[Activity, Activity, T], trainable: AbstractModule[Activity, Activity, T]): Graph[T]

  172. def createMsraFiller(varianceNormAverage: Boolean = true): MsraFiller

  173. def createMul(): Mul[T]

  174. def createMulConstant(scalar: Double, inplace: Boolean = false): MulConstant[T]

  175. def createMultiCriterion(): MultiCriterion[T]

  176. def createMultiLabelMarginCriterion(sizeAverage: Boolean = true): MultiLabelMarginCriterion[T]

  177. def createMultiLabelSoftMarginCriterion(weights: JTensor = null, sizeAverage: Boolean = true): MultiLabelSoftMarginCriterion[T]

  178. def createMultiMarginCriterion(p: Int = 1, weights: JTensor = null, margin: Double = 1.0, sizeAverage: Boolean = true): MultiMarginCriterion[T]

  179. def createMultiRNNCell(cells: List[Cell[T]]): MultiRNNCell[T]

  180. def createMultiStep(stepSizes: List[Int], gamma: Double): MultiStep

  181. def createNDCG(k: Int = 10, negNum: Int = 100): ValidationMethod[T]

  182. def createNarrow(dimension: Int, offset: Int, length: Int = 1): Narrow[T]

  183. def createNarrowTable(offset: Int, length: Int = 1): NarrowTable[T]

  184. def createNegative(inplace: Boolean): Negative[T]

  185. def createNegativeEntropyPenalty(beta: Double): NegativeEntropyPenalty[T]

  186. def createNode(module: AbstractModule[Activity, Activity, T], x: List[ModuleNode[T]]): ModuleNode[T]

  187. def createNormalize(p: Double, eps: Double = 1e-10): Normalize[T]

  188. def createNormalizeScale(p: Double, eps: Double = 1e-10, scale: Double, size: List[Int], wRegularizer: Regularizer[T] = null): NormalizeScale[T]

  189. def createOnes(): Ones.type

  190. def createPGCriterion(sizeAverage: Boolean = false): PGCriterion[T]

  191. def createPReLU(nOutputPlane: Int = 0): PReLU[T]

  192. def createPack(dimension: Int): Pack[T]

  193. def createPadding(dim: Int, pad: Int, nInputDim: Int, value: Double = 0.0, nIndex: Int = 1): Padding[T]

  194. def createPairwiseDistance(norm: Int = 2): PairwiseDistance[T]

  195. def createParallelAdam(learningRate: Double = 1e-3, learningRateDecay: Double = 0.0, beta1: Double = 0.9, beta2: Double = 0.999, Epsilon: Double = 1e-8, parallelNum: Int = Engine.coreNumber()): ParallelAdam[T]

  196. def createParallelCriterion(repeatTarget: Boolean = false): ParallelCriterion[T]

  197. def createParallelTable(): ParallelTable[T]

  198. def createPipeline(list: List[FeatureTransformer]): FeatureTransformer

  199. def createPixelBytesToMat(byteKey: String): PixelBytesToMat

  200. def createPixelNormalize(means: List[Double]): PixelNormalizer

  201. def createPlateau(monitor: String, factor: Float = 0.1f, patience: Int = 10, mode: String = "min", epsilon: Float = 1e-4f, cooldown: Int = 0, minLr: Float = 0): Plateau

  202. def createPoissonCriterion: PoissonCriterion[T]

  203. def createPoly(power: Double, maxIteration: Int): Poly

  204. def createPooler(resolution: Int, scales: List[Double], sampling_ratio: Int): Pooler[T]

  205. def createPower(power: Double, scale: Double = 1, shift: Double = 0): Power[T]

  206. def createPriorBox(minSizes: List[Double], maxSizes: List[Double] = null, aspectRatios: List[Double] = null, isFlip: Boolean = true, isClip: Boolean = false, variances: List[Double] = null, offset: Float = 0.5f, imgH: Int = 0, imgW: Int = 0, imgSize: Int = 0, stepH: Float = 0, stepW: Float = 0, step: Float = 0): PriorBox[T]

  207. def createProposal(preNmsTopN: Int, postNmsTopN: Int, ratios: List[Double], scales: List[Double], rpnPreNmsTopNTrain: Int = 12000, rpnPostNmsTopNTrain: Int = 2000): Proposal

  208. def createRMSprop(learningRate: Double = 1e-2, learningRateDecay: Double = 0.0, decayRate: Double = 0.99, Epsilon: Double = 1e-8): RMSprop[T]

  209. def createRReLU(lower: Double = 1.0 / 8, upper: Double = 1.0 / 3, inplace: Boolean = false): RReLU[T]

  210. def createRandomAlterAspect(min_area_ratio: Float, max_area_ratio: Int, min_aspect_ratio_change: Float, interp_mode: String, cropLength: Int): RandomAlterAspect

  211. def createRandomAspectScale(scales: List[Int], scaleMultipleOf: Int = 1, maxSize: Int = 1000): RandomAspectScale

  212. def createRandomCrop(cropWidth: Int, cropHeight: Int, isClip: Boolean): RandomCrop

  213. def createRandomCropper(cropWidth: Int, cropHeight: Int, mirror: Boolean, cropperMethod: String, channels: Int): RandomCropper

  214. def createRandomNormal(mean: Double, stdv: Double): RandomNormal

  215. def createRandomResize(minSize: Int, maxSize: Int): RandomResize

  216. def createRandomSampler(): FeatureTransformer

  217. def createRandomTransformer(transformer: FeatureTransformer, prob: Double): RandomTransformer

  218. def createRandomUniform(): InitializationMethod

  219. def createRandomUniform(lower: Double, upper: Double): InitializationMethod

  220. def createReLU(ip: Boolean = false): ReLU[T]

  221. def createReLU6(inplace: Boolean = false): ReLU6[T]

  222. def createRecurrent(): Recurrent[T]

  223. def createRecurrentDecoder(outputLength: Int): RecurrentDecoder[T]

  224. def createReplicate(nFeatures: Int, dim: Int = 1, nDim: Int = Int.MaxValue): Replicate[T]

  225. def createReshape(size: List[Int], batchMode: Boolean = null): Reshape[T]

  226. def createResize(resizeH: Int, resizeW: Int, resizeMode: Int = Imgproc.INTER_LINEAR, useScaleFactor: Boolean): Resize

  227. def createResizeBilinear(outputHeight: Int, outputWidth: Int, alignCorner: Boolean, dataFormat: String): ResizeBilinear[T]

  228. def createReverse(dimension: Int = 1, isInplace: Boolean = false): Reverse[T]

  229. def createRnnCell(inputSize: Int, hiddenSize: Int, activation: TensorModule[T], isInputWithBias: Boolean = true, isHiddenWithBias: Boolean = true, wRegularizer: Regularizer[T] = null, uRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null): RnnCell[T]

  230. def createRoiAlign(spatial_scale: Double, sampling_ratio: Int, pooled_h: Int, pooled_w: Int): RoiAlign[T]

  231. def createRoiHFlip(normalized: Boolean = true): RoiHFlip

  232. def createRoiNormalize(): RoiNormalize

  233. def createRoiPooling(pooled_w: Int, pooled_h: Int, spatial_scale: Double): RoiPooling[T]

  234. def createRoiProject(needMeetCenterConstraint: Boolean): RoiProject

  235. def createRoiResize(normalized: Boolean): RoiResize

  236. def createSGD(learningRate: Double = 1e-3, learningRateDecay: Double = 0.0, weightDecay: Double = 0.0, momentum: Double = 0.0, dampening: Double = Double.MaxValue, nesterov: Boolean = false, leaningRateSchedule: LearningRateSchedule = SGD.Default(), learningRates: JTensor = null, weightDecays: JTensor = null): SGD[T]

  237. def createSReLU(shape: ArrayList[Int], shareAxes: ArrayList[Int] = null): SReLU[T]

  238. def createSaturation(deltaLow: Double, deltaHigh: Double): Saturation

  239. def createScale(size: List[Int]): Scale[T]

  240. def createSelect(dimension: Int, index: Int): Select[T]

  241. def createSelectTable(dimension: Int): SelectTable[T]

  242. def createSequenceBeamSearch(vocabSize: Int, beamSize: Int, alpha: Float, decodeLength: Int, eosId: Float, paddingValue: Float, numHiddenLayers: Int, hiddenSize: Int): SequenceBeamSearch[T]

  243. def createSequential(): Container[Activity, Activity, T]

  244. def createSequentialSchedule(iterationPerEpoch: Int): SequentialSchedule

  245. def createSeveralIteration(interval: Int): Trigger

  246. def createSigmoid(): Sigmoid[T]

  247. def createSmoothL1Criterion(sizeAverage: Boolean = true): SmoothL1Criterion[T]

  248. def createSmoothL1CriterionWithWeights(sigma: Double, num: Int = 0): SmoothL1CriterionWithWeights[T]

  249. def createSoftMarginCriterion(sizeAverage: Boolean = true): SoftMarginCriterion[T]

  250. def createSoftMax(pos: Int = 1): SoftMax[T]

  251. def createSoftMin(): SoftMin[T]

  252. def createSoftPlus(beta: Double = 1.0): SoftPlus[T]

  253. def createSoftShrink(lambda: Double = 0.5): SoftShrink[T]

  254. def createSoftSign(): SoftSign[T]

  255. def createSoftmaxWithCriterion(ignoreLabel: Integer = null, normalizeMode: String = "VALID"): SoftmaxWithCriterion[T]

  256. def createSparseJoinTable(dimension: Int): SparseJoinTable[T]

  257. def createSparseLinear(inputSize: Int, outputSize: Int, withBias: Boolean, backwardStart: Int = 1, backwardLength: Int = 1, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, initWeight: JTensor = null, initBias: JTensor = null, initGradWeight: JTensor = null, initGradBias: JTensor = null): SparseLinear[T]

  258. def createSpatialAveragePooling(kW: Int, kH: Int, dW: Int = 1, dH: Int = 1, padW: Int = 0, padH: Int = 0, globalPooling: Boolean = false, ceilMode: Boolean = false, countIncludePad: Boolean = true, divide: Boolean = true, format: String = "NCHW"): SpatialAveragePooling[T]

  259. def createSpatialBatchNormalization(nOutput: Int, eps: Double = 1e-5, momentum: Double = 0.1, affine: Boolean = true, initWeight: JTensor = null, initBias: JTensor = null, initGradWeight: JTensor = null, initGradBias: JTensor = null, dataFormat: String = "NCHW"): SpatialBatchNormalization[T]

  260. def createSpatialContrastiveNormalization(nInputPlane: Int = 1, kernel: JTensor = null, threshold: Double = 1e-4, thresval: Double = 1e-4): SpatialContrastiveNormalization[T]

  261. def createSpatialConvolution(nInputPlane: Int, nOutputPlane: Int, kernelW: Int, kernelH: Int, strideW: Int = 1, strideH: Int = 1, padW: Int = 0, padH: Int = 0, nGroup: Int = 1, propagateBack: Boolean = true, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, initWeight: JTensor = null, initBias: JTensor = null, initGradWeight: JTensor = null, initGradBias: JTensor = null, withBias: Boolean = true, dataFormat: String = "NCHW"): SpatialConvolution[T]

  262. def createSpatialConvolutionMap(connTable: JTensor, kW: Int, kH: Int, dW: Int = 1, dH: Int = 1, padW: Int = 0, padH: Int = 0, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null): SpatialConvolutionMap[T]

  263. def createSpatialCrossMapLRN(size: Int = 5, alpha: Double = 1.0, beta: Double = 0.75, k: Double = 1.0, dataFormat: String = "NCHW"): SpatialCrossMapLRN[T]

  264. def createSpatialDilatedConvolution(nInputPlane: Int, nOutputPlane: Int, kW: Int, kH: Int, dW: Int = 1, dH: Int = 1, padW: Int = 0, padH: Int = 0, dilationW: Int = 1, dilationH: Int = 1, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null): SpatialDilatedConvolution[T]

  265. def createSpatialDivisiveNormalization(nInputPlane: Int = 1, kernel: JTensor = null, threshold: Double = 1e-4, thresval: Double = 1e-4): SpatialDivisiveNormalization[T]

  266. def createSpatialDropout1D(initP: Double = 0.5): SpatialDropout1D[T]

  267. def createSpatialDropout2D(initP: Double = 0.5, dataFormat: String = "NCHW"): SpatialDropout2D[T]

  268. def createSpatialDropout3D(initP: Double = 0.5, dataFormat: String = "NCHW"): SpatialDropout3D[T]

  269. def createSpatialFullConvolution(nInputPlane: Int, nOutputPlane: Int, kW: Int, kH: Int, dW: Int = 1, dH: Int = 1, padW: Int = 0, padH: Int = 0, adjW: Int = 0, adjH: Int = 0, nGroup: Int = 1, noBias: Boolean = false, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null): SpatialFullConvolution[T]

  270. def createSpatialMaxPooling(kW: Int, kH: Int, dW: Int, dH: Int, padW: Int = 0, padH: Int = 0, ceilMode: Boolean = false, format: String = "NCHW"): SpatialMaxPooling[T]

  271. def createSpatialSeparableConvolution(nInputChannel: Int, nOutputChannel: Int, depthMultiplier: Int, kW: Int, kH: Int, sW: Int = 1, sH: Int = 1, pW: Int = 0, pH: Int = 0, withBias: Boolean = true, dataFormat: String = "NCHW", wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, pRegularizer: Regularizer[T] = null): SpatialSeparableConvolution[T]

  272. def createSpatialShareConvolution(nInputPlane: Int, nOutputPlane: Int, kernelW: Int, kernelH: Int, strideW: Int = 1, strideH: Int = 1, padW: Int = 0, padH: Int = 0, nGroup: Int = 1, propagateBack: Boolean = true, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, initWeight: JTensor = null, initBias: JTensor = null, initGradWeight: JTensor = null, initGradBias: JTensor = null, withBias: Boolean = true): SpatialShareConvolution[T]

  273. def createSpatialSubtractiveNormalization(nInputPlane: Int = 1, kernel: JTensor = null): SpatialSubtractiveNormalization[T]

  274. def createSpatialWithinChannelLRN(size: Int = 5, alpha: Double = 1.0, beta: Double = 0.75): SpatialWithinChannelLRN[T]

  275. def createSpatialZeroPadding(padLeft: Int, padRight: Int, padTop: Int, padBottom: Int): SpatialZeroPadding[T]

  276. def createSplitTable(dimension: Int, nInputDims: Int = 1): SplitTable[T]

  277. def createSqrt(): Sqrt[T]

  278. def createSquare(): Square[T]

  279. def createSqueeze(dim: Int = Int.MinValue, numInputDims: Int = Int.MinValue): Squeeze[T]

  280. def createStep(stepSize: Int, gamma: Double): Step

  281. def createSum(dimension: Int = 1, nInputDims: Int = 1, sizeAverage: Boolean = false, squeeze: Boolean = true): Sum[T]

  282. def createTableOperation(operationLayer: AbstractModule[Table, Tensor[T], T]): TableOperation[T]

  283. def createTanh(): Tanh[T]

  284. def createTanhShrink(): TanhShrink[T]

  285. def createTemporalConvolution(inputFrameSize: Int, outputFrameSize: Int, kernelW: Int, strideW: Int = 1, propagateBack: Boolean = true, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, initWeight: JTensor = null, initBias: JTensor = null, initGradWeight: JTensor = null, initGradBias: JTensor = null): TemporalConvolution[T]

  286. def createTemporalMaxPooling(kW: Int, dW: Int): TemporalMaxPooling[T]

  287. def createThreshold(th: Double = 1e-6, v: Double = 0.0, ip: Boolean = false): Threshold[T]

  288. def createTile(dim: Int, copies: Int): Tile[T]

  289. def createTimeDistributed(layer: TensorModule[T]): TimeDistributed[T]

  290. def createTimeDistributedCriterion(critrn: TensorCriterion[T], sizeAverage: Boolean = false, dimension: Int = 2): TimeDistributedCriterion[T]

  291. def createTimeDistributedMaskCriterion(critrn: TensorCriterion[T], paddingValue: Int = 0): TimeDistributedMaskCriterion[T]

  292. def createTop1Accuracy(): ValidationMethod[T]

  293. def createTop5Accuracy(): ValidationMethod[T]

  294. def createTrainSummary(logDir: String, appName: String): TrainSummary

  295. def createTransformer(vocabSize: Int, hiddenSize: Int, numHeads: Int, filterSize: Int, numHiddenlayers: Int, postprocessDropout: Double, attentionDropout: Double, reluDropout: Double): Transformer[T]

  296. def createTransformerCriterion(criterion: AbstractCriterion[Activity, Activity, T], inputTransformer: AbstractModule[Activity, Activity, T] = null, targetTransformer: AbstractModule[Activity, Activity, T] = null): TransformerCriterion[T]

  297. def createTranspose(permutations: List[List[Int]]): Transpose[T]

  298. def createTreeNNAccuracy(): ValidationMethod[T]

  299. def createTriggerAnd(first: Trigger, others: List[Trigger]): Trigger

  300. def createTriggerOr(first: Trigger, others: List[Trigger]): Trigger

  301. def createUnsqueeze(pos: List[Int], numInputDims: Int = Int.MinValue): Unsqueeze[T]

  302. def createUpSampling1D(length: Int): UpSampling1D[T]

  303. def createUpSampling2D(size: List[Int], dataFormat: String): UpSampling2D[T]

  304. def createUpSampling3D(size: List[Int]): UpSampling3D[T]

  305. def createValidationSummary(logDir: String, appName: String): ValidationSummary

  306. def createView(sizes: List[Int], num_input_dims: Int = 0): View[T]

  307. def createVolumetricAveragePooling(kT: Int, kW: Int, kH: Int, dT: Int, dW: Int, dH: Int, padT: Int = 0, padW: Int = 0, padH: Int = 0, countIncludePad: Boolean = true, ceilMode: Boolean = false): VolumetricAveragePooling[T]

  308. def createVolumetricConvolution(nInputPlane: Int, nOutputPlane: Int, kT: Int, kW: Int, kH: Int, dT: Int = 1, dW: Int = 1, dH: Int = 1, padT: Int = 0, padW: Int = 0, padH: Int = 0, withBias: Boolean = true, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null): VolumetricConvolution[T]

  309. def createVolumetricFullConvolution(nInputPlane: Int, nOutputPlane: Int, kT: Int, kW: Int, kH: Int, dT: Int = 1, dW: Int = 1, dH: Int = 1, padT: Int = 0, padW: Int = 0, padH: Int = 0, adjT: Int = 0, adjW: Int = 0, adjH: Int = 0, nGroup: Int = 1, noBias: Boolean = false, wRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null): VolumetricFullConvolution[T]

  310. def createVolumetricMaxPooling(kT: Int, kW: Int, kH: Int, dT: Int, dW: Int, dH: Int, padT: Int = 0, padW: Int = 0, padH: Int = 0): VolumetricMaxPooling[T]

  311. def createWarmup(delta: Double): Warmup

  312. def createXavier(): Xavier.type

  313. def createZeros(): Zeros.type

  314. def criterionBackward(criterion: AbstractCriterion[Activity, Activity, T], input: List[_ <: AnyRef], inputIsTable: Boolean, target: List[_ <: AnyRef], targetIsTable: Boolean): List[JTensor]

  315. def criterionForward(criterion: AbstractCriterion[Activity, Activity, T], input: List[_ <: AnyRef], inputIsTable: Boolean, target: List[_ <: AnyRef], targetIsTable: Boolean): T

  316. def disableClip(optimizer: Optimizer[T, MiniBatch[T]]): Unit

  317. def distributedImageFrameRandomSplit(imageFrame: DistributedImageFrame, weights: List[Double]): Array[ImageFrame]

  318. def distributedImageFrameToImageTensorRdd(imageFrame: DistributedImageFrame, floatKey: String = ImageFeature.floats, toChw: Boolean = true): JavaRDD[JTensor]

  319. def distributedImageFrameToLabelTensorRdd(imageFrame: DistributedImageFrame): JavaRDD[JTensor]

  320. def distributedImageFrameToPredict(imageFrame: DistributedImageFrame, key: String): JavaRDD[List[Any]]

  321. def distributedImageFrameToSample(imageFrame: DistributedImageFrame, key: String): JavaRDD[Sample]

  322. def distributedImageFrameToUri(imageFrame: DistributedImageFrame, key: String): JavaRDD[String]

  323. def dlClassifierModelTransform(dlClassifierModel: DLClassifierModel[T], dataSet: DataFrame): DataFrame

  324. def dlImageTransform(dlImageTransformer: DLImageTransformer, dataSet: DataFrame): DataFrame

  325. def dlModelTransform(dlModel: DLModel[T], dataSet: DataFrame): DataFrame

  326. def dlReadImage(path: String, sc: JavaSparkContext, minParitions: Int): DataFrame

  327. final def eq(arg0: AnyRef): Boolean

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

    Definition Classes
    AnyRef → Any
  329. def evaluate(module: AbstractModule[Activity, Activity, T]): AbstractModule[Activity, Activity, T]

  330. def featureTransformDataset(dataset: DataSet[ImageFeature], transformer: FeatureTransformer): DataSet[ImageFeature]

  331. def finalize(): Unit

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

  333. def fitClassifier(classifier: DLClassifier[T], dataSet: DataFrame): DLModel[T]

  334. def fitEstimator(estimator: DLEstimator[T], dataSet: DataFrame): DLModel[T]

  335. def freeze(model: AbstractModule[Activity, Activity, T], freezeLayers: List[String]): AbstractModule[Activity, Activity, T]

  336. final def getClass(): Class[_]

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

  338. def getEngineType(): String

  339. def getFlattenModules(module: Container[Activity, Activity, T], includeContainer: Boolean): List[AbstractModule[Activity, Activity, T]]

  340. def getHiddenState(rec: Recurrent[T]): JActivity

  341. def getNodeAndCoreNumber(): Array[Int]

  342. def getOptimizerVersion(): String

  343. def getRealClassNameOfJValue(module: AbstractModule[Activity, Activity, T]): String

  344. def getRunningMean(module: BatchNormalization[T]): JTensor

  345. def getRunningStd(module: BatchNormalization[T]): JTensor

  346. def getWeights(model: AbstractModule[Activity, Activity, T]): List[JTensor]

  347. def hashCode(): Int

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

  349. def imageFeatureToImageTensor(imageFeature: ImageFeature, floatKey: String = ImageFeature.floats, toChw: Boolean = true): JTensor

  350. def imageFeatureToLabelTensor(imageFeature: ImageFeature): JTensor

  351. def initEngine(): Unit

  352. def isDistributed(imageFrame: ImageFrame): Boolean

  353. final def isInstanceOf[T0]: Boolean

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

  355. def isWithWeights(module: Module[T]): Boolean

  356. def jTensorsToActivity(input: List[_ <: AnyRef], isTable: Boolean): Activity

  357. def loadBigDL(path: String): AbstractModule[Activity, Activity, T]

  358. def loadBigDLModule(modulePath: String, weightPath: String): AbstractModule[Activity, Activity, T]

  359. def loadCaffe(model: AbstractModule[Activity, Activity, T], defPath: String, modelPath: String, matchAll: Boolean = true): AbstractModule[Activity, Activity, T]

  360. def loadCaffeModel(defPath: String, modelPath: String): AbstractModule[Activity, Activity, T]

  361. def loadOptimMethod(path: String): OptimMethod[T]

  362. def loadTF(path: String, inputs: List[String], outputs: List[String], byteOrder: String, binFile: String = null, generatedBackward: Boolean = true): AbstractModule[Activity, Activity, T]

  363. def loadTorch(path: String): AbstractModule[Activity, Activity, T]

  364. def localImageFrameToImageTensor(imageFrame: LocalImageFrame, floatKey: String = ImageFeature.floats, toChw: Boolean = true): List[JTensor]

  365. def localImageFrameToLabelTensor(imageFrame: LocalImageFrame): List[JTensor]

  366. def localImageFrameToPredict(imageFrame: LocalImageFrame, key: String): List[List[Any]]

  367. def localImageFrameToSample(imageFrame: LocalImageFrame, key: String): List[Sample]

  368. def localImageFrameToUri(imageFrame: LocalImageFrame, key: String): List[String]

  369. def modelBackward(model: AbstractModule[Activity, Activity, T], input: List[_ <: AnyRef], inputIsTable: Boolean, gradOutput: List[_ <: AnyRef], gradOutputIsTable: Boolean): List[JTensor]

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

  371. def modelEvaluateImageFrame(model: AbstractModule[Activity, Activity, T], imageFrame: ImageFrame, batchSize: Int, valMethods: List[ValidationMethod[T]]): List[EvaluatedResult]

  372. def modelForward(model: AbstractModule[Activity, Activity, T], input: List[_ <: AnyRef], inputIsTable: Boolean): List[JTensor]

  373. def modelGetParameters(model: AbstractModule[Activity, Activity, T]): Map[Any, Map[Any, List[List[Any]]]]

  374. def modelPredictClass(model: AbstractModule[Activity, Activity, T], dataRdd: JavaRDD[Sample]): JavaRDD[Int]

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

  376. def modelPredictRDD(model: AbstractModule[Activity, Activity, T], dataRdd: JavaRDD[Sample], batchSize: Int = 1): JavaRDD[JTensor]

  377. def modelSave(module: AbstractModule[Activity, Activity, T], path: String, overWrite: Boolean): Unit

  378. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  379. final def notify(): Unit

    Definition Classes
    AnyRef
  380. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  381. def predictLocal(model: AbstractModule[Activity, Activity, T], features: List[JTensor], batchSize: Int = 1): List[JTensor]

  382. def predictLocalClass(model: AbstractModule[Activity, Activity, T], features: List[JTensor]): List[Int]

  383. def quantize(module: AbstractModule[Activity, Activity, T]): Module[T]

  384. def read(path: String, sc: JavaSparkContext, minPartitions: Int): ImageFrame

  385. def readParquet(path: String, sc: JavaSparkContext): DistributedImageFrame

  386. def redirectSparkLogs(logPath: String): Unit

  387. def saveBigDLModule(module: AbstractModule[Activity, Activity, T], modulePath: String, weightPath: String, overWrite: Boolean): Unit

  388. def saveCaffe(module: AbstractModule[Activity, Activity, T], prototxtPath: String, modelPath: String, useV2: Boolean = true, overwrite: Boolean = false): Unit

  389. def saveGraphTopology(model: Graph[T], logPath: String): Graph[T]

  390. def saveOptimMethod(method: OptimMethod[T], path: String, overWrite: Boolean = false): Unit

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

  392. def saveTensorDictionary(tensors: HashMap[String, JTensor], path: String): Unit

    Save tensor dictionary to a Java hashmap object file

  393. def seqFilesToImageFrame(url: String, sc: JavaSparkContext, classNum: Int, partitionNum: Int): ImageFrame

  394. def setBatchSizeDLClassifier(classifier: DLClassifier[T], batchSize: Int): DLClassifier[T]

  395. def setBatchSizeDLClassifierModel(dlClassifierModel: DLClassifierModel[T], batchSize: Int): DLClassifierModel[T]

  396. def setBatchSizeDLEstimator(estimator: DLEstimator[T], batchSize: Int): DLEstimator[T]

  397. def setBatchSizeDLModel(dlModel: DLModel[T], batchSize: Int): DLModel[T]

  398. def setCheckPoint(optimizer: Optimizer[T, MiniBatch[T]], trigger: Trigger, checkPointPath: String, isOverwrite: Boolean): Unit

  399. def setConstantClip(optimizer: Optimizer[T, MiniBatch[T]], min: Float, max: Float): Unit

  400. def setCriterion(optimizer: Optimizer[T, MiniBatch[T]], criterion: Criterion[T]): Unit

  401. def setFeatureSizeDLClassifierModel(dlClassifierModel: DLClassifierModel[T], featureSize: ArrayList[Int]): DLClassifierModel[T]

  402. def setFeatureSizeDLModel(dlModel: DLModel[T], featureSize: ArrayList[Int]): DLModel[T]

  403. def setInitMethod(layer: Initializable, initMethods: ArrayList[InitializationMethod]): layer.type

  404. def setInitMethod(layer: Initializable, weightInitMethod: InitializationMethod, biasInitMethod: InitializationMethod): layer.type

  405. def setInputFormats(graph: StaticGraph[T], inputFormat: List[Int]): StaticGraph[T]

  406. def setL2NormClip(optimizer: Optimizer[T, MiniBatch[T]], normValue: Float): Unit

  407. def setLabel(labelMap: Map[String, Float], imageFrame: ImageFrame): Unit

  408. def setLearningRateDLClassifier(classifier: DLClassifier[T], lr: Double): DLClassifier[T]

  409. def setLearningRateDLEstimator(estimator: DLEstimator[T], lr: Double): DLEstimator[T]

  410. def setMaxEpochDLClassifier(classifier: DLClassifier[T], maxEpoch: Int): DLClassifier[T]

  411. def setMaxEpochDLEstimator(estimator: DLEstimator[T], maxEpoch: Int): DLEstimator[T]

  412. def setModelSeed(seed: Long): Unit

  413. def setOptimizerVersion(version: String): Unit

  414. def setOutputFormats(graph: StaticGraph[T], outputFormat: List[Int]): StaticGraph[T]

  415. def setRunningMean(module: BatchNormalization[T], runningMean: JTensor): Unit

  416. def setRunningStd(module: BatchNormalization[T], runningStd: JTensor): Unit

  417. def setStopGradient(model: Graph[T], layers: List[String]): Graph[T]

  418. def setTrainData(optimizer: Optimizer[T, MiniBatch[T]], trainingRdd: JavaRDD[Sample], batchSize: Int): Unit

  419. def setTrainSummary(optimizer: Optimizer[T, MiniBatch[T]], summary: TrainSummary): Unit

  420. def setValSummary(optimizer: Optimizer[T, MiniBatch[T]], summary: ValidationSummary): Unit

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

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

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

  424. def setWeights(model: AbstractModule[Activity, Activity, T], weights: List[JTensor]): Unit

  425. def showBigDlInfoLogs(): Unit

  426. def summaryReadScalar(summary: Summary, tag: String): List[List[Any]]

  427. def summarySetTrigger(summary: TrainSummary, summaryName: String, trigger: Trigger): TrainSummary

  428. final def synchronized[T0](arg0: ⇒ T0): T0

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

  430. def testTensor(jTensor: JTensor): JTensor

  431. def toGraph(sequential: Sequential[T]): StaticGraph[T]

  432. def toJSample(psamples: RDD[Sample]): RDD[dataset.Sample[T]]

  433. def toJSample(record: Sample): dataset.Sample[T]

  434. def toJTensor(tensor: Tensor[T]): JTensor

  435. def toPySample(sample: dataset.Sample[T]): Sample

  436. def toSampleArray(Xs: List[Tensor[T]], y: Tensor[T] = null): Array[dataset.Sample[T]]

  437. def toString(): String

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

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

  440. def transformImageFeature(transformer: FeatureTransformer, feature: ImageFeature): ImageFeature

  441. def transformImageFrame(transformer: FeatureTransformer, imageFrame: ImageFrame): ImageFrame

  442. def unFreeze(model: AbstractModule[Activity, Activity, T], names: List[String]): AbstractModule[Activity, Activity, T]

  443. def uniform(a: Double, b: Double, size: List[Int]): JTensor

  444. def updateParameters(model: AbstractModule[Activity, Activity, T], lr: Double): Unit

  445. final def wait(): Unit

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  448. def writeParquet(path: String, output: String, sc: JavaSparkContext, partitionNum: Int = 1): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped