H2OMOJOModel

abstract def inputColumnNames: Array[String]

abstract def outputColumnName: String

abstract def transform(dataset: Dataset[_]): DataFrame

abstract def transformSchema(schema: StructType): StructType

abstract val uid: String

final def !=(arg0: Any): Boolean

final def ##(): Int

final def $[T](param: Param[T]): T

final def ==(arg0: Any): Boolean

def applyPredictionUdf(dataset: Dataset[_], udfConstructor: (Array[String]) ⇒ UserDefinedFunction): DataFrame

def applyPredictionUdfToFlatDataFrame(flatDataFrame: DataFrame, udfConstructor: (Array[String]) ⇒ UserDefinedFunction, inputs: Array[String]): DataFrame

final def asInstanceOf[T0]: T0

final def clear(param: Param[_]): H2OMOJOModel.this.type

def clone(): AnyRef

final val coefficients: NullableDataFrameParam

final val convertInvalidNumbersToNa: BooleanParam

final val convertUnknownCategoricalLevelsToNa: BooleanParam

def copy(extra: ParamMap): H2OMOJOModel

def copyValues[T <: Params](to: T, extra: ParamMap): T

final val crossValidationMetrics: MapStringDoubleParam

final val crossValidationMetricsObject: NullableMetricsParam

final val crossValidationMetricsSummary: NullableDataFrameParam

var crossValidationModels: Array[H2OMOJOModel]

var crossValidationModelsScoringHistory: NullableDataFrameArrayParam

final val dataFrameSerializer: Param[String]

final def defaultCopy[T <: Params](extra: ParamMap): T

final val defaultThreshold: DoubleParam

final val endTime: LongParam

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def explainParam(param: Param[_]): String

def explainParams(): String

def extractCoefficients(outputJson: JsonObject): DataFrame

def extractCrossValidationMetricsSummary(modelJson: JsonObject): DataFrame

def extractFeatureImportances(outputJson: JsonObject): DataFrame

def extractFeatureTypes(outputJson: JsonObject): Map[String, String]

def extractJsonFieldValue[T](outputJson: JsonObject, fieldName: String, getValue: (JsonElement) ⇒ T, defaultValue: T): T

def extractJsonTables(outputJson: JsonObject, fieldName: String): Array[DataFrame]

def extractMetrics(json: JsonObject, metricType: String): Map[String, Double]

def extractMetricsObject(json: JsonObject, metricType: String, algoName: String, modelCategory: internals.H2OModelCategory.Value, dataFrameSerializerGetter: () ⇒ String): H2OMetrics

def extractModelCategory(outputJson: JsonObject): internals.H2OModelCategory.Value

def extractModelSummary(outputJson: JsonObject): DataFrame

final def extractParamMap(): ParamMap

final def extractParamMap(extra: ParamMap): ParamMap

def extractParams(modelJson: JsonObject): Map[String, String]

def extractScoringHistory(outputJson: JsonObject): DataFrame

final val featureImportances: NullableDataFrameParam

final val featureTypes: MapStringStringParam

def finalize(): Unit

final def get[T](param: Param[T]): Option[T]

final def getClass(): Class[_]

def getCoefficients(): DataFrame

def getConvertInvalidNumbersToNa(): Boolean

def getConvertUnknownCategoricalLevelsToNa(): Boolean

def getCrossValidationMetrics(): Map[String, Double]

Returns a map of all combined cross-validation holdout metrics of the Double type.

def getCrossValidationMetricsObject(): H2OMetrics

Returns an object holding all metrics of the Double type and also more complex performance information combined from cross-validation holdouts.

def getCrossValidationMetricsSummary(): DataFrame

Returns a data frame with information about performance of individual folds according to various model metrics.

def getCrossValidationModels(): Seq[H2OMOJOModel.this.type]

def getCrossValidationModelsScoringHistory(): Array[DataFrame]

def getCurrentMetrics(): Map[String, Double]

Returns a map of all metrics of the Double type.

def getCurrentMetricsObject(): H2OMetrics

Returns an object holding all metrics of the Double type and also more complex performance information.

def getDataFrameSerializer(): String

final def getDefault[T](param: Param[T]): Option[T]

def getDefaultThreshold(): Double

def getDomainValues(): Map[String, Array[String]]

def getEndTime(): Long

def getFeatureImportances(): DataFrame

def getFeatureTypes(): Map[String, String]

def getModelCategory(): String

def getModelDetails(): String

def getModelDetails(modelJson: JsonObject): String

def getModelJson(mojo: File): JsonObject

def getModelSummary(): DataFrame

final def getOrDefault[T](param: Param[T]): T

def getParam(paramName: String): Param[Any]

def getRelevantColumnNames(flatDataFrame: DataFrame, inputs: Array[String]): Array[String]

def getRunTime(): Long

def getScoringHistory(): DataFrame

def getStartTime(): Long

def getTrainingMetrics(): Map[String, Double]

Returns a map of all metrics of the Double type calculated on the training dataset.

def getTrainingMetricsObject(): H2OMetrics

Returns an object holding all metrics of the Double type and also more complex performance information calculated on the training dataset.

def getTrainingParams(): Map[String, String]

def getValidationMetrics(): Map[String, Double]

Returns a map of all metrics of the Double type calculated on the validation dataset.

def getValidationMetricsObject(): H2OMetrics

Returns an object holding all metrics of the Double type and also more complex performance information calculated on the validation dataset.

final def hasDefault[T](param: Param[T]): Boolean

def hasParam(paramName: String): Boolean

def hasParent: Boolean

def hashCode(): Int

def initializeLogIfNecessary(isInterpreter: Boolean): Unit

final def isDefined(param: Param[_]): Boolean

final def isInstanceOf[T0]: Boolean

final def isSet(param: Param[_]): Boolean

def isTraceEnabled(): Boolean

def jsonFieldToDataFrame(outputJson: JsonObject, fieldName: String): DataFrame

def jsonFieldToDoubleArray(outputJson: JsonObject, fieldName: String): Array[Double]

def log: Logger

def logDebug(msg: ⇒ String, throwable: Throwable): Unit

def logDebug(msg: ⇒ String): Unit

def logError(msg: ⇒ String, throwable: Throwable): Unit

def logError(msg: ⇒ String): Unit

def logInfo(msg: ⇒ String, throwable: Throwable): Unit

def logInfo(msg: ⇒ String): Unit

def logName: String

def logTrace(msg: ⇒ String, throwable: Throwable): Unit

def logTrace(msg: ⇒ String): Unit

def logWarning(msg: ⇒ String, throwable: Throwable): Unit

def logWarning(msg: ⇒ String): Unit

final val modelCategory: NullableStringParam

final val modelDetails: NullableStringParam

final val modelSummary: NullableDataFrameParam

final def ne(arg0: AnyRef): Boolean

def nestedJsonFieldToDataFrame(outputJson: JsonObject, parentFieldName: String, fieldName: String): DataFrame

val nonSerializableField: AnyRef

final def notify(): Unit

final def notifyAll(): Unit

def nullableDataFrameParam(name: String, doc: String): NullableDataFrameParam

lazy val params: Array[Param[_]]

var parent: Estimator[H2OMOJOModel]

final val runTime: LongParam

def save(path: String): Unit

final val scoringHistory: NullableDataFrameParam

final def set(paramPair: ParamPair[_]): H2OMOJOModel.this.type

final def set(param: String, value: Any): H2OMOJOModel.this.type

final def set[T](param: Param[T], value: T): H2OMOJOModel.this.type

def setDataFrameSerializer(fullClassName: String): H2OMOJOModel.this.type

final def setDefault(paramPairs: ParamPair[_]*): H2OMOJOModel.this.type

final def setDefault[T](param: Param[T], value: T): H2OMOJOModel.this.type

def setMojo(mojo: File): H2OMOJOModel.this.type

def setMojo(mojo: InputStream, mojoName: String): H2OMOJOModel.this.type

def setMojo(mojo: InputStream): H2OMOJOModel.this.type

def setParent(parent: Estimator[H2OMOJOModel]): H2OMOJOModel

final val startTime: LongParam

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

def toString(): String

final val trainingMetrics: MapStringDoubleParam

final val trainingMetricsObject: NullableMetricsParam

final val trainingParams: MapStringStringParam

def transform(dataset: Dataset[_], paramMap: ParamMap): DataFrame

def transform(dataset: Dataset[_], firstParamPair: ParamPair[_], otherParamPairs: ParamPair[_]*): DataFrame

def transformSchema(schema: StructType, logging: Boolean): StructType

def unwrapMojoModel(): MojoModel

The method returns an internal H2O-3 mojo model, which can be subsequently used with EasyPredictModelWrapper to perform predictions on individual rows.

final val validationMetrics: MapStringDoubleParam

final val validationMetricsObject: NullableMetricsParam

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def write: MLWriter