GeneralRegressionModel

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def algorithmName: Option[String]

The algorithm name is free-type and can be any description for the specific algorithm that produced the model.

def anyMissing(series: Series): Boolean

Returns true if there are any missing values of all input fields in the specified series.

final def asInstanceOf[T0]: T0

val attributes: GeneralRegressionAttributes

Common attributes of this model

val baseCumHazardTables: Option[BaseCumHazardTables]

def baselineStrataVariable: Option[Field]

If modelType is CoxRegression, this variable is optional, if present it is used during scoring (see the description of scoring procedures below).

def candidateOutputFields: Array[OutputField]

def candidateOutputSchema: StructType

The schema of candidate outputs.

def classes(name: String): Array[Any]

Returns class labels of the specified target.

lazy val classes: Array[Any]

The class labels in a classification model.

def clone(): AnyRef

def combineOutputFields(listA: Array[OutputField], listB: Array[OutputField]): Array[OutputField]

def containInterResults: Boolean

val covariateList: Option[CovariateList]

def createOutputs(): ModelOutputs

Creates an object of GeneralRegressionOutputs that is for writing into an output series.

def cumulativeLink: Option[CumulativeLinkFunction]

Specifies the type of cumulative link function to use when ordinalMultinomial model type is specified.

var customOutputFields: Array[OutputField]

User-defined custom output fields, both the internal output of PMML and predefined output are ignored when the field is specified.

def dVersion: Double

Returns PMML version as a double value

def dataDictionary: DataDictionary

The data dictionary of this model.

def defaultOutputFields: Array[OutputField]

Returns all candidates output fields of this model when there is no output specified explicitly.

def distParameter: Option[Double]

Specifies an ancillary parameter value for the negative binomial distribution.

def distribution: Option[Distribution]

The probability distribution of the dependent variable for generalizedLinear model may be specified as normal, binomial, gamma, inverse Gaussian, negative binomial, or Poisson.

def encode(series: Series): DSeries

Encodes the input series.

def endTimeVariable: Option[Field]

If modelType is CoxRegression, this variable is required during scoring (see the description of scoring procedures below).

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val eventValues: Option[EventValues]

val extensions: Seq[Extension]

val factorList: Option[FactorList]

def field(name: String): Field

Returns the field of a given name.

def fieldsOfUsageType(typ: UsageType): Array[Field]

Get fields by its usage type: 'active', 'target', 'predicted', 'group' and so on

def findBaselineCell(baselineCells: Array[BaselineCell], endTime: Double): BaselineCell

def functionName: MiningFunction

Describe the kind of mining model, e.g., whether it is intended to be used for clustering or for classification.

final def getClass(): Class[_]

def getField(name: String): Option[Field]

Returns the field of a given name, None if a field with the given name does not exist.

def hasExtensions: Boolean

def hasTarget: Boolean

def hashCode(): Int

def header: Header

The header of this model.

lazy val implicitInputDerivedFields: Array[Field]

Implicit referenced derived fields for the sub-model except ones defined in the mining schema.

def importances: Map[String, Double]

Returns importances of predictors.

def inferClasses: Array[Any]

The sub-classes can override this method to provide classes of target inside model.

lazy val inputDerivedFields: Array[Field]

Referenced derived fields.

lazy val inputFields: Array[Field]

All input fields in an array.

lazy val inputNames: Array[String]

All input names in an array.

lazy val inputSchema: StructType

The schema of inputs.

def isAssociationRules: Boolean

Tests if this is a association rules model.

def isBinary: Boolean

Tests if the target is a binary field

def isClassification(name: String): Boolean

Tests if this is a classification model of the specified target, it's applicable for multiple targets.

def isClassification: Boolean

Tests if this is a classification model.

def isClustering: Boolean

Tests if this is a clustering model.

final def isInstanceOf[T0]: Boolean

def isMixed: Boolean

Tests if this is a mixed model.

def isOrdinal: Boolean

Tests if the target is an ordinal field

def isPredictionOnly: Boolean

def isRegression(name: String): Boolean

Tests if this is a regression model of the specified target, it's applicable for multiple targets.

def isRegression: Boolean

Tests if this is a regression model.

def isScorable: Boolean

Indicates if the model is valid for scoring.

def isSequences: Boolean

Tests if this is a sequences model.

def isSubModel: Boolean

def isTimeSeries: Boolean

Tests if this is a time series model.

def isTopLevelModel: Boolean

def linkFunction: Option[LinkFunction]

Specifies the type of link function to use when generalizedLinear model type is specified.

def linkParameter: Option[Double]

Specifies an additional number the following link functions need: oddspower and power.

val localTransformations: Option[LocalTransformations]

The optional local transformations.

val miningSchema: MiningSchema

def modelDF: Option[Double]

The value of degrees of freedom for the model.

def modelElement: ModelElement

Model element type.

val modelExplanation: Option[ModelExplanation]

def modelName: Option[String]

Identifies the model with a unique name in the context of the PMML file.

val modelStats: Option[ModelStats]

def modelType: GeneralModelType

Specifies the type of regression model in use.

val modelVerification: Option[ModelVerification]

def multiTargets: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

lazy val nullSeries: Series

A series with all null values is returned when can not produce a result.

def numClasses(name: String): Int

Returns the number of class labels of the specified target.

lazy val numClasses: Int

The number of class labels in a classification model.

def offsetValue: Option[Double]

If present, this value is used during scoring generalizedLinear, ordinalMultinomial, or multinomialLogistic models.

def offsetVariable: Option[Field]

If present, this variable is used during scoring generalizedLinear, ordinalMultinomial, or multinomialLogistic models (see the description of scoring procedures below).

def opType(name: String): OpType

Returns optype of the specified target.

lazy val opType: OpType

When Target specifies optype then it overrides the optype attribute in a corresponding MiningField, if it exists.

val output: Option[Output]

def outputFields: Array[OutputField]

def outputIndex(feature: ResultFeature, value: Option[Any] = None): Int

def outputNames: Array[String]

def outputSchema: StructType

The schema of final outputs.

val pCovMatrix: Option[PCovMatrix]

val paramMatrix: ParamMatrix

val parameterList: ParameterList

var parent: Model

The parent model.

def postClassification(name: String = null): (Any, Map[Any, Double])

def postPredictedValue(outputs: MutablePredictedValue, name: String = null): MutablePredictedValue

def postRegression(predictedValue: Any, name: String = null): Any

val ppMatrix: PPMatrix

def predict(values: Series): Series

Predicts values for a given data series.

def predict(it: Iterator[Series]): Iterator[Series]

def predict(json: String): String

Predicts one or multiple records in json format, there are two formats supported:

def predict(values: List[Any]): List[Any]

def predict[T](values: Array[T]): Array[Any]

Predicts values for a given Array, and the order of those values is supposed as same as the input fields list

def predict(values: (String, Any)*): Seq[(String, Any)]

Predicts values for a given list of key/value pairs.

def predict(values: Map[String, Any]): Map[String, Any]

Predicts values for a given data map of Java.

def predict(values: Map[String, Any]): Map[String, Any]

Predicts values for a given data map.

lazy val predictedValueIndex: Int

def prepare(series: Series): (Series, Boolean)

Pre-process the input series.

def probabilitiesSupported: Boolean

Tests if probabilities of categories of target can be produced by this model.

def result(series: Series, modelOutputs: ModelOutputs, fields: Array[OutputField] = Array.empty): Series

def setOutputFields(outputFields: Array[OutputField]): GeneralRegressionModel.this.type

def setParent(parent: Model): GeneralRegressionModel.this.type

def setSupplementOutput(value: Boolean): GeneralRegressionModel.this.type

def singleTarget: Boolean

def size: Int

def startTimeVariable: Option[Field]

If modelType is CoxRegression, this variable is optional, it is not used during scoring but is an important piece of information about model building.

def statusVariable: Option[Field]

If modelType is CoxRegression, this variable is optional.

def subjectIDVariable: Option[Field]

If modelType is CoxRegression, this variable is optional, it is not used during scoring but is an important piece of information about model building.

var supplementOutput: Boolean

A flag for whether to return those predefined output fields not exist in the output element explicitly.

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

lazy val targetClasses: Map[String, Array[Any]]

The class labels of all categorical targets.

lazy val targetField: Field

The first target field for the supervised model.

lazy val targetFields: Array[Field]

All target fields in an array.

def targetFieldsOfResidual: Array[Field]

Returns targets that are residual values to be computed, the input data must include target values.

def targetName: String

Name of the first target for the supervised model.

lazy val targetNames: Array[String]

All target names in an array.

def targetNamesOfResidual: Array[String]

def targetReferenceCategory: Option[String]

Used for specifying the reference category of the target variable in a multinomial classification model.

def targetVariableName: Option[String]

Name of the target variable (also called response variable).

val targets: Option[Targets]

def toString(): String

def transformationDictionary: Option[TransformationDictionary]

The optional transformation dictionary.

def trialsValue: Option[Int]

A positive integer used during scoring some generalizedLinear models (see the description of scoring procedure below).

def trialsVariable: Option[Field]

Specifies an additional variable used during scoring some generalizedLinear models (see the description of scoring procedure below).

def unionCandidateOutputFields: Array[OutputField]

def unionOutputFields: Array[OutputField]

lazy val usedFields: Array[Field]

Setup indices to retrieve data from series faster by index instead of name, the index is immutable when model is built because the model object could run in multiple threads, so it's important make sure the model object is totally immutable.

lazy val usedSchema: StructType

The schema of used fields.

def version: String

PMML version.

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit