PythonBigDL

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. final def asInstanceOf[T0]: T0

   Definition Classes

   Any

8. def clone(): AnyRef

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( ... )

9. def createAbs(): Abs[T]

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

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

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

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

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

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

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

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

18. 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]

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

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

21. def createBilinearFiller(): BilinearFiller.type

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

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

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

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

26. def createCDivTable(): CDivTable[T]

27. def createCMaxTable(): CMaxTable[T]

28. def createCMinTable(): CMinTable[T]

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

30. def createCMulTable(): CMulTable[T]

31. def createCSubTable(): CSubTable[T]

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

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

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

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

36. def createConcatTable(): ConcatTable[T]

37. def createConstInitMethod(value: Double): ConstInitMethod

38. def createContiguous(): Contiguous[T]

39. def createConvLSTMPeephole2D(inputSize: Int, outputSize: Int, kernelI: Int, kernelC: Int, stride: Int = 1, wRegularizer: Regularizer[T] = null, uRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null, withPeephole: Boolean = true): ConvLSTMPeephole2D[T]

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

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

42. def createCosineDistance(): CosineDistance[T]

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

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

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

46. def createDefault(): Default

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

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

49. def createDotProduct(): DotProduct[T]

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

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

52. def createEcho(): Echo[T]

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

54. def createEveryEpoch(): Trigger

55. def createExp(): Exp[T]

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

57. def createFlattenTable(): FlattenTable[T]

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

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

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

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

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

63. def createIdentity(): Identity[T]

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

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

66. def createInput(): ModuleNode[T]

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

68. def createL1Cost(): L1Cost[T]

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

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

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

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

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

74. 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]

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

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

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

78. 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]

79. def createLog(): Log[T]

80. def createLogSigmoid(): LogSigmoid[T]

81. def createLogSoftMax(): LogSoftMax[T]

82. 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]

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

84. def createMAE(): ValidationMethod[T]

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

86. def createMSECriterion: MSECriterion[T]

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

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

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

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

91. def createMaskedSelect(): MaskedSelect[T]

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

93. def createMaxEpoch(max: Int): Trigger

94. def createMaxIteration(max: Int): Trigger

95. def createMaxScore(max: Float): Trigger

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

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

98. def createMinLoss(min: Float): Trigger

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

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

101. def createMul(): Mul[T]

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

103. def createMultiCriterion(): MultiCriterion[T]

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

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

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

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

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

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

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

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

112. def createOnes(): Ones.type

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

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

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

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

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

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

119. def createParallelTable(): ParallelTable[T]

120. 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

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

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

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

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

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

126. def createRandomUniform(): InitializationMethod

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

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

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

130. def createRecurrent(): Recurrent[T]

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

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

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

134. def createRnnCell(inputSize: Int, hiddenSize: Int, activation: TensorModule[T], wRegularizer: Regularizer[T] = null, uRegularizer: Regularizer[T] = null, bRegularizer: Regularizer[T] = null): RnnCell[T]

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

136. 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]

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

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

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

140. def createSequential(): Sequential[T]

141. def createSeveralIteration(interval: Int): Trigger

142. def createSigmoid(): Sigmoid[T]

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

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

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

146. def createSoftMax(): SoftMax[T]

147. def createSoftMin(): SoftMin[T]

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

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

150. def createSoftSign(): SoftSign[T]

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

152. 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): SpatialAveragePooling[T]

153. 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): SpatialBatchNormalization[T]

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

155. 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): SpatialConvolution[T]

156. 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]

157. def createSpatialCrossMapLRN(size: Int = 5, alpha: Double = 1.0, beta: Double = 0.75, k: Double = 1.0): SpatialCrossMapLRN[T]

158. 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]

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

160. 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]

161. def createSpatialMaxPooling(kW: Int, kH: Int, dW: Int, dH: Int, padW: Int = 0, padH: Int = 0, ceilMode: Boolean = false): SpatialMaxPooling[T]

162. 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]

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

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

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

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

167. def createSqrt(): Sqrt[T]

168. def createSquare(): Square[T]

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

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

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

172. def createTanh(): Tanh[T]

173. def createTanhShrink(): TanhShrink[T]

174. 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]

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

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

177. def createTimeDistributedCriterion(critrn: TensorCriterion[T], sizeAverage: Boolean = false): TimeDistributedCriterion[T]

178. def createTop1Accuracy(): ValidationMethod[T]

179. def createTop5Accuracy(): ValidationMethod[T]

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

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

182. def createTreeNNAccuracy(): ValidationMethod[T]

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

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

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

186. 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): VolumetricConvolution[T]

187. 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]

188. def createXavier(): Xavier.type

189. def createZeros(): Zeros.type

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

191. def criterionForward(criterion: AbstractCriterion[Activity, Activity, T], input: List[JTensor], inputIsTable: Boolean, target: List[JTensor], targetIsTable: Boolean): T

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

     Definition Classes

     AnyRef

193. def equals(arg0: Any): Boolean

     Definition Classes

     AnyRef → Any

194. def finalize(): Unit

     Attributes

     protected[java.lang]

     Definition Classes

     AnyRef

     Annotations

     @throws( classOf[java.lang.Throwable] )

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

     Definition Classes

     AnyRef → Any

196. def getFinalStateAndCellStatus(rec: Recurrent[T]): List[JTensor]

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

198. def hashCode(): Int

     Definition Classes

     AnyRef → Any

199. def initEngine(): Unit

200. final def isInstanceOf[T0]: Boolean

     Definition Classes

     Any

201. def jTensorsToActivity(input: List[JTensor], isTable: Boolean): Activity

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

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

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

205. def loadTF(path: String, inputs: List[String], outputs: List[String], byteOrder: String): AbstractModule[Activity, Activity, T]

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

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

208. def modelForward(model: AbstractModule[Activity, Activity, T], input: List[JTensor], inputIsTable: Boolean): List[JTensor]

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

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

211. def modelPredictRDD(model: AbstractModule[Activity, Activity, T], dataRdd: JavaRDD[Sample]): JavaRDD[JTensor]

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

213. def modelTest(model: AbstractModule[Activity, Activity, T], valRDD: JavaRDD[Sample], batchSize: Int, valMethods: List[ValidationMethod[T]]): List[TestResult]

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

     Definition Classes

     AnyRef

215. final def notify(): Unit

     Definition Classes

     AnyRef

216. final def notifyAll(): Unit

     Definition Classes

     AnyRef

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

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

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

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

221. def setModelSeed(seed: Long): Unit

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

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

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

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

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

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

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

     Definition Classes

     AnyRef

229. def testTensor(jTensor: JTensor): JTensor

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

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

232. def toSample(record: Sample): dataset.Sample[T]

233. def toString(): String

     Definition Classes

     AnyRef → Any

234. def toTensor(jTensor: JTensor): Tensor[T]

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

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

237. final def wait(): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

238. final def wait(arg0: Long, arg1: Int): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

239. final def wait(arg0: Long): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )