proto

type AveragingConfig struct {
	// Types that are valid to be assigned to Config:
	//	*AveragingConfig_AverageLastNTrees
	//	*AveragingConfig_AverageLastPercentTrees
	Config isAveragingConfig_Config `protobuf_oneof:"config"`
}

type AveragingConfig_AverageLastNTrees struct {
	AverageLastNTrees float32 `protobuf:"fixed32,1,opt,name=average_last_n_trees,json=averageLastNTrees,oneof"`
}

type AveragingConfig_AverageLastPercentTrees struct {
	AverageLastPercentTrees float32 `protobuf:"fixed32,2,opt,name=average_last_percent_trees,json=averageLastPercentTrees,oneof"`
}

type CategoricalIdBinarySplit struct {
	// Categorical feature column and Id describing
	// the rule feature == Id.
	FeatureColumn int32 `protobuf:"varint,1,opt,name=feature_column,json=featureColumn" json:"feature_column,omitempty"`
	FeatureId     int64 `protobuf:"varint,2,opt,name=feature_id,json=featureId" json:"feature_id,omitempty"`
	// Node children indexing into a contiguous
	// vector of nodes starting from the root.
	LeftId  int32 `protobuf:"varint,3,opt,name=left_id,json=leftId" json:"left_id,omitempty"`
	RightId int32 `protobuf:"varint,4,opt,name=right_id,json=rightId" json:"right_id,omitempty"`
}

type CategoricalIdSetMembershipBinarySplit struct {
	// Categorical feature column and Id describing
	// the rule feature ∈ feature_ids.
	FeatureColumn int32 `protobuf:"varint,1,opt,name=feature_column,json=featureColumn" json:"feature_column,omitempty"`
	// Sorted list of Ids in the set.
	FeatureIds []int64 `protobuf:"varint,2,rep,packed,name=feature_ids,json=featureIds" json:"feature_ids,omitempty"`
	// Node children indexing into a contiguous
	// vector of nodes starting from the root.
	LeftId  int32 `protobuf:"varint,3,opt,name=left_id,json=leftId" json:"left_id,omitempty"`
	RightId int32 `protobuf:"varint,4,opt,name=right_id,json=rightId" json:"right_id,omitempty"`
}

type DecisionTreeConfig struct {
	Nodes []*TreeNode `protobuf:"bytes,1,rep,name=nodes" json:"nodes,omitempty"`
}

type DecisionTreeEnsembleConfig struct {
	Trees        []*DecisionTreeConfig   `protobuf:"bytes,1,rep,name=trees" json:"trees,omitempty"`
	TreeWeights  []float32               `protobuf:"fixed32,2,rep,packed,name=tree_weights,json=treeWeights" json:"tree_weights,omitempty"`
	TreeMetadata []*DecisionTreeMetadata `protobuf:"bytes,3,rep,name=tree_metadata,json=treeMetadata" json:"tree_metadata,omitempty"`
	// Metadata that is used during the training.
	GrowingMetadata *GrowingMetadata `protobuf:"bytes,4,opt,name=growing_metadata,json=growingMetadata" json:"growing_metadata,omitempty"`
}

type DecisionTreeMetadata struct {
	// How many times tree weight was updated (due to reweighting of the final
	// ensemble, dropout, shrinkage etc).
	NumTreeWeightUpdates int32 `protobuf:"varint,1,opt,name=num_tree_weight_updates,json=numTreeWeightUpdates" json:"num_tree_weight_updates,omitempty"`
	// Number of layers grown for this tree.
	NumLayersGrown int32 `protobuf:"varint,2,opt,name=num_layers_grown,json=numLayersGrown" json:"num_layers_grown,omitempty"`
	// Whether the tree is finalized in that no more layers can be grown.
	IsFinalized bool `protobuf:"varint,3,opt,name=is_finalized,json=isFinalized" json:"is_finalized,omitempty"`
}

type DenseFloatBinarySplit struct {
	// Float feature column and split threshold describing
	// the rule feature <= threshold.
	FeatureColumn int32   `protobuf:"varint,1,opt,name=feature_column,json=featureColumn" json:"feature_column,omitempty"`
	Threshold     float32 `protobuf:"fixed32,2,opt,name=threshold" json:"threshold,omitempty"`
	// Node children indexing into a contiguous
	// vector of nodes starting from the root.
	LeftId  int32 `protobuf:"varint,3,opt,name=left_id,json=leftId" json:"left_id,omitempty"`
	RightId int32 `protobuf:"varint,4,opt,name=right_id,json=rightId" json:"right_id,omitempty"`
}

type GrowingMetadata struct {
	// Number of trees that we have attempted to build. After pruning, these
	// trees might have been removed.
	NumTreesAttempted int64 `protobuf:"varint,1,opt,name=num_trees_attempted,json=numTreesAttempted" json:"num_trees_attempted,omitempty"`
	// Number of layers that we have attempted to build. After pruning, these
	// layers might have been removed.
	NumLayersAttempted int64 `protobuf:"varint,2,opt,name=num_layers_attempted,json=numLayersAttempted" json:"num_layers_attempted,omitempty"`
}

type Leaf struct {
	// Types that are valid to be assigned to Leaf:
	//	*Leaf_Vector
	//	*Leaf_SparseVector
	Leaf isLeaf_Leaf `protobuf_oneof:"leaf"`
}

type Leaf_SparseVector struct {
	SparseVector *SparseVector `protobuf:"bytes,2,opt,name=sparse_vector,json=sparseVector,oneof"`
}

type Leaf_Vector struct {
	Vector *Vector `protobuf:"bytes,1,opt,name=vector,oneof"`
}

type LearnerConfig struct {
	// Number of classes.
	NumClasses uint32 `protobuf:"varint,1,opt,name=num_classes,json=numClasses" json:"num_classes,omitempty"`
	// Fraction of features to consider in each tree sampled randomly
	// from all available features.
	//
	// Types that are valid to be assigned to FeatureFraction:
	//	*LearnerConfig_FeatureFractionPerTree
	//	*LearnerConfig_FeatureFractionPerLevel
	FeatureFraction isLearnerConfig_FeatureFraction `protobuf_oneof:"feature_fraction"`
	// Regularization.
	Regularization *TreeRegularizationConfig `protobuf:"bytes,4,opt,name=regularization" json:"regularization,omitempty"`
	// Constraints.
	Constraints *TreeConstraintsConfig `protobuf:"bytes,5,opt,name=constraints" json:"constraints,omitempty"`
	// Pruning.
	PruningMode LearnerConfig_PruningMode `` /* 152-byte string literal not displayed */
	// Growing Mode.
	GrowingMode LearnerConfig_GrowingMode `` /* 152-byte string literal not displayed */
	// Learning rate.
	LearningRateTuner *LearningRateConfig `protobuf:"bytes,6,opt,name=learning_rate_tuner,json=learningRateTuner" json:"learning_rate_tuner,omitempty"`
	// Multi-class strategy.
	MultiClassStrategy LearnerConfig_MultiClassStrategy `` /* 183-byte string literal not displayed */
	// If you want to average the ensembles (for regularization), provide the
	// config below.
	AveragingConfig *AveragingConfig `protobuf:"bytes,11,opt,name=averaging_config,json=averagingConfig" json:"averaging_config,omitempty"`
}

type LearnerConfig_FeatureFractionPerLevel struct {
	FeatureFractionPerLevel float32 `protobuf:"fixed32,3,opt,name=feature_fraction_per_level,json=featureFractionPerLevel,oneof"`
}

type LearnerConfig_FeatureFractionPerTree struct {
	FeatureFractionPerTree float32 `protobuf:"fixed32,2,opt,name=feature_fraction_per_tree,json=featureFractionPerTree,oneof"`
}

type LearnerConfig_GrowingMode int32

type LearnerConfig_MultiClassStrategy int32

type LearnerConfig_PruningMode int32

type LearningRateConfig struct {
	// Types that are valid to be assigned to Tuner:
	//	*LearningRateConfig_Fixed
	//	*LearningRateConfig_Dropout
	//	*LearningRateConfig_LineSearch
	Tuner isLearningRateConfig_Tuner `protobuf_oneof:"tuner"`
}

type LearningRateConfig_Dropout struct {
	Dropout *LearningRateDropoutDrivenConfig `protobuf:"bytes,2,opt,name=dropout,oneof"`
}

type LearningRateConfig_Fixed struct {
	Fixed *LearningRateFixedConfig `protobuf:"bytes,1,opt,name=fixed,oneof"`
}

type LearningRateConfig_LineSearch struct {
	LineSearch *LearningRateLineSearchConfig `protobuf:"bytes,3,opt,name=line_search,json=lineSearch,oneof"`
}

type LearningRateDropoutDrivenConfig struct {
	// Probability of dropping each tree in an existing so far ensemble.
	DropoutProbability float32 `protobuf:"fixed32,1,opt,name=dropout_probability,json=dropoutProbability" json:"dropout_probability,omitempty"`
	// When trees are built after dropout happen, they don't "advance" to the
	// optimal solution, they just rearrange the path. However you can still
	// choose to skip dropout periodically, to allow a new tree that "advances"
	// to be added.
	// For example, if running for 200 steps with probability of dropout 1/100,
	// you would expect the dropout to start happening for sure for all iterations
	// after 100. However you can add probability_of_skipping_dropout of 0.1, this
	// way iterations 100-200 will include approx 90 iterations of dropout and 10
	// iterations of normal steps.Set it to 0 if you want just keep building
	// the refinement trees after dropout kicks in.
	ProbabilityOfSkippingDropout float32 `` /* 144-byte string literal not displayed */
	// Between 0 and 1.
	LearningRate float32 `protobuf:"fixed32,3,opt,name=learning_rate,json=learningRate" json:"learning_rate,omitempty"`
}

type LearningRateFixedConfig struct {
	LearningRate float32 `protobuf:"fixed32,1,opt,name=learning_rate,json=learningRate" json:"learning_rate,omitempty"`
}

type LearningRateLineSearchConfig struct {
	// Max learning rate. Must be strictly positive.
	MaxLearningRate float32 `protobuf:"fixed32,1,opt,name=max_learning_rate,json=maxLearningRate" json:"max_learning_rate,omitempty"`
	// Number of learning rate values to consider between [0, max_learning_rate).
	NumSteps int32 `protobuf:"varint,2,opt,name=num_steps,json=numSteps" json:"num_steps,omitempty"`
}

type QuantileConfig struct {
	// Maximum eps error when computing quantile summaries.
	Eps float64 `protobuf:"fixed64,1,opt,name=eps" json:"eps,omitempty"`
	// Number of quantiles to generate.
	NumQuantiles int64 `protobuf:"varint,2,opt,name=num_quantiles,json=numQuantiles" json:"num_quantiles,omitempty"`
}

type QuantileEntry struct {
	// Value for the entry.
	Value float32 `protobuf:"fixed32,1,opt,name=value" json:"value,omitempty"`
	// Weight for the entry.
	Weight float32 `protobuf:"fixed32,2,opt,name=weight" json:"weight,omitempty"`
	// We need the minimum and maximum rank possible for this entry.
	// Rank is 0.0 for the absolute minimum and sum of the weights for the maximum
	// value in the input.
	MinRank float32 `protobuf:"fixed32,3,opt,name=min_rank,json=minRank" json:"min_rank,omitempty"`
	MaxRank float32 `protobuf:"fixed32,4,opt,name=max_rank,json=maxRank" json:"max_rank,omitempty"`
}

type QuantileStreamState struct {
	Summaries []*QuantileSummaryState `protobuf:"bytes,1,rep,name=summaries" json:"summaries,omitempty"`
}

type QuantileSummaryState struct {
	Entries []*QuantileEntry `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"`
}

type SparseFloatBinarySplitDefaultLeft struct {
	Split *DenseFloatBinarySplit `protobuf:"bytes,1,opt,name=split" json:"split,omitempty"`
}

type SparseFloatBinarySplitDefaultRight struct {
	Split *DenseFloatBinarySplit `protobuf:"bytes,1,opt,name=split" json:"split,omitempty"`
}

type SparseVector struct {
	Index []int32   `protobuf:"varint,1,rep,packed,name=index" json:"index,omitempty"`
	Value []float32 `protobuf:"fixed32,2,rep,packed,name=value" json:"value,omitempty"`
}

type TreeConstraintsConfig struct {
	// Maximum depth of the trees.
	MaxTreeDepth uint32 `protobuf:"varint,1,opt,name=max_tree_depth,json=maxTreeDepth" json:"max_tree_depth,omitempty"`
	// Min hessian weight per node.
	MinNodeWeight float32 `protobuf:"fixed32,2,opt,name=min_node_weight,json=minNodeWeight" json:"min_node_weight,omitempty"`
}

type TreeNode struct {
	// Types that are valid to be assigned to Node:
	//	*TreeNode_Leaf
	//	*TreeNode_DenseFloatBinarySplit
	//	*TreeNode_SparseFloatBinarySplitDefaultLeft
	//	*TreeNode_SparseFloatBinarySplitDefaultRight
	//	*TreeNode_CategoricalIdBinarySplit
	//	*TreeNode_CategoricalIdSetMembershipBinarySplit
	Node         isTreeNode_Node   `protobuf_oneof:"node"`
	NodeMetadata *TreeNodeMetadata `protobuf:"bytes,777,opt,name=node_metadata,json=nodeMetadata" json:"node_metadata,omitempty"`
}

type TreeNodeMetadata struct {
	// The gain associated with this node.
	Gain float32 `protobuf:"fixed32,1,opt,name=gain" json:"gain,omitempty"`
	// The original leaf node before this node was split.
	OriginalLeaf *Leaf `protobuf:"bytes,2,opt,name=original_leaf,json=originalLeaf" json:"original_leaf,omitempty"`
}

type TreeNode_CategoricalIdBinarySplit struct {
	CategoricalIdBinarySplit *CategoricalIdBinarySplit `protobuf:"bytes,5,opt,name=categorical_id_binary_split,json=categoricalIdBinarySplit,oneof"`
}

type TreeNode_CategoricalIdSetMembershipBinarySplit struct {
	CategoricalIdSetMembershipBinarySplit *CategoricalIdSetMembershipBinarySplit `protobuf:"bytes,6,opt,name=categorical_id_set_membership_binary_split,json=categoricalIdSetMembershipBinarySplit,oneof"`
}

type TreeNode_DenseFloatBinarySplit struct {
	DenseFloatBinarySplit *DenseFloatBinarySplit `protobuf:"bytes,2,opt,name=dense_float_binary_split,json=denseFloatBinarySplit,oneof"`
}

type TreeNode_Leaf struct {
	Leaf *Leaf `protobuf:"bytes,1,opt,name=leaf,oneof"`
}

type TreeNode_SparseFloatBinarySplitDefaultLeft struct {
	SparseFloatBinarySplitDefaultLeft *SparseFloatBinarySplitDefaultLeft `protobuf:"bytes,3,opt,name=sparse_float_binary_split_default_left,json=sparseFloatBinarySplitDefaultLeft,oneof"`
}

type TreeNode_SparseFloatBinarySplitDefaultRight struct {
	SparseFloatBinarySplitDefaultRight *SparseFloatBinarySplitDefaultRight `protobuf:"bytes,4,opt,name=sparse_float_binary_split_default_right,json=sparseFloatBinarySplitDefaultRight,oneof"`
}

type TreeRegularizationConfig struct {
	// Classic L1/L2.
	L1 float32 `protobuf:"fixed32,1,opt,name=l1" json:"l1,omitempty"`
	L2 float32 `protobuf:"fixed32,2,opt,name=l2" json:"l2,omitempty"`
	// Tree complexity penalizes overall model complexity effectively
	// limiting how deep the tree can grow in regions with small gain.
	TreeComplexity float32 `protobuf:"fixed32,3,opt,name=tree_complexity,json=treeComplexity" json:"tree_complexity,omitempty"`
}

type Vector struct {
	Value []float32 `protobuf:"fixed32,1,rep,packed,name=value" json:"value,omitempty"`
}