AVh"/J*dZddlZddlmZddlmZddlmZddlm Z ddl m Z ddlmZdd l mZdd l mZdd l mZdd lmZdd lmZddlmZddlmZm Z m!Z!ddl"m#Z#dde#e!ejHfde#e!ejJfde#e!ejJfde#e!ejHfde&de&de#e!ejJffdZ'edejPe'Z)de#e!ejHfde#e!ejJfde#e!ejJfde#e!ejHfde&de&de#e!ejJffdZ*dde#e e!ejJfde#e e!ejJffdZ+edejPe+Z,de#e e!ejJfde#e e!ejJffdZ-ej\d gd!Z/dd"e#e!ejHfd#e#e!ejJfd$e#e!ejJfd%e#e!ejJfd&e#e!ejJfd'e#e!ejJfd(e&d)e0fd*Z1ed+ejPe1Z2d"e#e!ejHfd#e#e!ejJfd$e#e!ejJfd%e#e!ejJfd&e#e!ejJfd'e#e!ejJfd(e&d)e0fd,Z3ej\d-gd.Z4dd"e#e!ejHfd/e#e e!ejJfd0e#e!ejjfd1e#e!ejHfd$e#e!ejJfd%e#e!ejJfd&e#e!ejJfd'e#e!ejJfd(e&fd2Z6ed3ejPe6Z7d"e#e!ejHfd/e#e e!ejJfd0e#e!ejjfd1e#e!ejHfd$e#e!ejJfd%e#e!ejJfd&e#e!ejJfd'e#e!ejJfd(e&fd4Z8ej\d5gd6Z9dd"e#e!ejHfd7e#e e!ejJfd$e#e!ejJfd%e#e!ejJfd&e#e!ejJfd'e#e!ejJfde&fd8Z:ed9ejPe:Z;d"e#e!ejHfd7e#e e!ejJfd$e#e!ejJfd%e#e!ejJfd&e#e!ejJfd'e#e!ejJfde&fd:ZZ?ed?ejPe?Z@d;e#e!ejzfd= 1`. int; the maximum number of splits possible in the whole tree. num_buckets: An `int` that is `>= 1`. int; equals to the maximum possible value of bucketized feature. name: A name for the operation (optional). Returns: A `Tensor` of type `float32`. BoostedTreesAggregateStatsrrNrrnamectx)rrrrrrr)_contextr_thread_local_datais_eagerrTFE_Py_FastPathExecute_core_NotOkStatusException_opsraise_from_not_ok_status_FallbackException,boosted_trees_aggregate_stats_eager_fallback_SymbolicException_executemake_int_op_def_library_apply_op_helpermust_record_gradient _get_attr_intinputsrecord_gradient)rrrrrrr_ctxtld_resulte__op_outputs_attrs _inputs_flats [/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/gen_boosted_trees_ops.pyboosted_trees_aggregate_statsr<s.    0h..0$ #\\  11 *D(I'<]gn  \:*!!+}=+'88$x9/71;2=D J!QX QK' ""$C--l;] .0F::L $lFGE (' .5  & &- ##At,,  # #    9 IxZ!$88  # #   s0 DE)EEE!E44F  F z"raw_ops.BoostedTreesAggregateStatsc,tj|d}tj|d}tj|tj }tj|tj }tj|tj }tj|tj }||||g}d|d|f} tjdd|| ||} tjrtjd|| | | \} | S)NrrsBoostedTreesAggregateStatsr0attrsrrr) r*r+r%convert_to_tensor_dtypesint32float32rr.r1) rrrrrrrrr:r9r4s r;r(r(Xs  \:*!!+}=+  # #Hgmm <($$Y@)  # #Hgoo >(  " "7GMM :'Ix9, *m[ A&   :A$0C"& ('""$ $lFGE (' . float_valuesbucket_boundariescrtjxstj}|j}|jr t j |d|||}|St|ttfst!d|zt#|}t|ttfst!d|zt#||k7rt%dt#||fzt'j(d|||\}}} } | dd}t+j,r7d| j/df} | j0} t+j2d| | ||S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYZwxYw) aBucketize each feature based on bucket boundaries. An op that returns a list of float tensors, where each tensor represents the bucketized values for a single feature. Args: float_values: A list of `Tensor` objects with type `float32`. float; List of Rank 1 Tensor each containing float values for a single feature. bucket_boundaries: A list with the same length as `float_values` of `Tensor` objects with type `float32`. float; List of Rank 1 Tensors each containing the bucket boundaries for a single feature. name: A name for the operation (optional). Returns: A list with the same length as `float_values` of `Tensor` objects with type `int32`. BoostedTreesBucketizeNrrRExpected list for 'float_values' argument to 'boosted_trees_bucketize' Op, not %r.WExpected list for 'bucket_boundaries' argument to 'boosted_trees_bucketize' Op, not %r.List argument 'bucket_boundaries' to 'boosted_trees_bucketize' Op with length %d must match length %d of argument 'float_values'.)rFrGr num_features)rrr r!rr"r#r$r%r&r'&boosted_trees_bucketize_eager_fallbackr) isinstancelisttuple TypeErrorlen ValueErrorr,r-r*r.r/r0r1) rFrGrr2r3r4r5_attr_num_featuresr6r7r8r9r:s r;boosted_trees_bucketizerWks"    0h..0$ #\\ 11 %t\;LNg n L4- 0  02> ? @@<( %e} 5  02C D EE 11  ;  !34 5 66(88l3D&*,!QX QK' ""$c//? @F::L vw@ .E  & &- ##At,,  # #    3 )$@@  # #   s0EF E33F  F FF65F6zraw_ops.BoostedTreesBucketizecNt|ttfstd|zt |}t|ttfstd|zt ||k7rt dt ||fzt j|tj}t j|tj}t|t|z}d|f}tjd|||||}tjrtjd||||S)NrKrLrMrNsBoostedTreesBucketizer?rI)rPrQrRrSrTrUr%convert_n_to_tensorrBrDr*rr.r1)rFrGrrrVr:r9r4s r;rOrOs7 L4- 0  02> ? @@<( %e} 5  02C D EE 11  ;  !34 5 66)),H,../@'//Rl#d+<&==, . /&   57I$0C"& ('""$ vw@ .rE%BoostedTreesCalculateBestFeatureSplit)rgainsfeature_dimensions thresholdsleft_node_contribsright_node_contribssplit_with_default_directions node_id_range stats_summaryl1l2tree_complexitymin_node_weightlogits_dimension split_typec |tjxstj} | j} | jr9 t j | d|||||||d|d| } t j| } | Stj |d}|d}tj"|d}t%j&d||||||||| \} } }}|dd} tj(rHd|j+dd|j-df}|j.}tj0d||| t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t||||||||||  S#tj$rYBwxYw)ar Calculates gains for each feature and returns the best possible split information for the feature. The split information is the best threshold (bucket id), gains and left/right node contributions per node for each feature. It is possible that not all nodes can be split on each feature. Hence, the list of possible nodes can differ between the features. Therefore, we return `node_ids_list` for each feature, containing the list of nodes that this feature can be used to split. In this manner, the output is the best split per features and per node, so that it needs to be combined later to produce the best split for each node (among all possible features). The output shapes are compatible in a way that the first dimension of all tensors are the same and equal to the number of possible split nodes for each feature. Args: node_id_range: A `Tensor` of type `int32`. A Rank 1 tensor (shape=[2]) to specify the range [first, last) of node ids to process within `stats_summary_list`. The nodes are iterated between the two nodes specified by the tensor, as like `for node_id in range(node_id_range[0], node_id_range[1])` (Note that the last index node_id_range[1] is exclusive). stats_summary: A `Tensor` of type `float32`. A Rank 4 tensor (#shape=[max_splits, feature_dims, bucket, stats_dims]) for accumulated stats summary (gradient/hessian) per node, per dimension, per buckets for each feature. The first dimension of the tensor is the maximum number of splits, and thus not all elements of it will be used, but only the indexes specified by node_ids will be used. l1: A `Tensor` of type `float32`. l1 regularization factor on leaf weights, per instance based. l2: A `Tensor` of type `float32`. l2 regularization factor on leaf weights, per instance based. tree_complexity: A `Tensor` of type `float32`. adjustment to the gain, per leaf based. min_node_weight: A `Tensor` of type `float32`. minimum avg of hessians in a node before required for the node to be considered for splitting. logits_dimension: An `int` that is `>= 1`. The dimension of logit, i.e., number of classes. split_type: An optional `string` from: `"inequality", "equality"`. Defaults to `"inequality"`. A string indicating if this Op should perform inequality split or equality split. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (node_ids, gains, feature_dimensions, thresholds, left_node_contribs, right_node_contribs, split_with_default_directions). node_ids: A `Tensor` of type `int32`. gains: A `Tensor` of type `float32`. feature_dimensions: A `Tensor` of type `int32`. thresholds: A `Tensor` of type `int32`. left_node_contribs: A `Tensor` of type `float32`. right_node_contribs: A `Tensor` of type `float32`. split_with_default_directions: A `Tensor` of type `string`. rZrgrhNrgrhrr inequality) rarbrcrdrerfrgrhr)rrr r!rr",_BoostedTreesCalculateBestFeatureSplitOutput_maker#r$r%r&r'9boosted_trees_calculate_best_feature_split_eager_fallbackr)r*r+make_strr,r-r.r/get_attrr0r1)rarbrcrdrerfrgrhrr2r3r4r5r6r7r8r9r:s r;*boosted_trees_calculate_best_feature_splitrqsT    0h..0$ #\\  11 5t]r2,lJHg=BB7Kg n&&'79KLJ  \:*'88/}?L462APAPBR >w G' .C  & &- ##At,,  # #    F B ,<d66  # #   s07EF E22F  F F$$F;:F;z-raw_ops.BoostedTreesCalculateBestFeatureSplitc tj|d}|d}tj|d}tj|t j }tj|t j}tj|t j}tj|t j}tj|t j}tj|t j}||||||g} d|d|f} tjdd| | | |} tjrtjd| | | tj| } | S)Nrgrkrhs%BoostedTreesCalculateBestFeatureSplitr?rZ) r*r+ror%rArBrCrDrr.r1rlrm) rarbrcrdrerfrgrhrrr:r9r4s r;rnrn$s3&&'79KLJ  \:*(( F-((H- b'//2" b'//2"**?GOOL/**?GOOL/BY,  0, K&   Eq$0C"& ('""$ /vwP 8 > >w G' .rE'BoostedTreesCalculateBestFeatureSplitV2)rr[ feature_idsr\r]r^r_r`stats_summaries_list split_typescandidate_feature_idsc tjxstj} | j} | jr9 t j | d| ||||||||d| } t j| } | St|t t"fst%d|zt'|}t)j*|d}t-j.d||||||||||  \}}}}|dd} t)j0rHd|j3dd|j3df}|j4}t)j6d||| t j| } | S#tj$r } tj| | Yd} ~ nd} ~ wtj$rYnwxYw t|||||||||| |  S#tj$rYYwxYw)a Calculates gains for each feature and returns the best possible split information for each node. However, if no split is found, then no split information is returned for that node. The split information is the best threshold (bucket id), gains and left/right node contributions per node for each feature. It is possible that not all nodes can be split on each feature. Hence, the list of possible nodes can differ between the features. Therefore, we return `node_ids_list` for each feature, containing the list of nodes that this feature can be used to split. In this manner, the output is the best split per features and per node, so that it needs to be combined later to produce the best split for each node (among all possible features). The output shapes are compatible in a way that the first dimension of all tensors are the same and equal to the number of possible split nodes for each feature. Args: node_id_range: A `Tensor` of type `int32`. A Rank 1 tensor (shape=[2]) to specify the range [first, last) of node ids to process within `stats_summary_list`. The nodes are iterated between the two nodes specified by the tensor, as like `for node_id in range(node_id_range[0], node_id_range[1])` (Note that the last index node_id_range[1] is exclusive). stats_summaries_list: A list of at least 1 `Tensor` objects with type `float32`. A list of Rank 4 tensor (#shape=[max_splits, feature_dims, bucket, stats_dims]) for accumulated stats summary (gradient/hessian) per node, per dimension, per buckets for each feature. The first dimension of the tensor is the maximum number of splits, and thus not all elements of it will be used, but only the indexes specified by node_ids will be used. split_types: A `Tensor` of type `string`. A Rank 1 tensor indicating if this Op should perform inequality split or equality split per feature. candidate_feature_ids: A `Tensor` of type `int32`. Rank 1 tensor with ids for each feature. This is the real id of the feature. l1: A `Tensor` of type `float32`. l1 regularization factor on leaf weights, per instance based. l2: A `Tensor` of type `float32`. l2 regularization factor on leaf weights, per instance based. tree_complexity: A `Tensor` of type `float32`. adjustment to the gain, per leaf based. min_node_weight: A `Tensor` of type `float32`. minimum avg of hessians in a node before required for the node to be considered for splitting. logits_dimension: An `int` that is `>= 1`. The dimension of logit, i.e., number of classes. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (node_ids, gains, feature_ids, feature_dimensions, thresholds, left_node_contribs, right_node_contribs, split_with_default_directions). node_ids: A `Tensor` of type `int32`. gains: A `Tensor` of type `float32`. feature_ids: A `Tensor` of type `int32`. feature_dimensions: A `Tensor` of type `int32`. thresholds: A `Tensor` of type `int32`. left_node_contribs: A `Tensor` of type `float32`. right_node_contribs: A `Tensor` of type `float32`. split_with_default_directions: A `Tensor` of type `string`. rtrgNrgrrpExpected list for 'stats_summaries_list' argument to 'boosted_trees_calculate_best_feature_split_v2' Op, not %r.) rarvrwrxrcrdrerfrgrrN)rrr r!rr"._BoostedTreesCalculateBestFeatureSplitV2Outputrmr#r$r%r&r'!QX QK' ""$c//? #"3"34F"GIF::L 1<R : @ @ I' .I  & &- ##At,,  # #    I -{ R/+$DBB  # #   s07EF!-FF! F!%F;;GGz/raw_ops.BoostedTreesCalculateBestFeatureSplitV2c t|ttfstd|zt |} t j |d}tj|tj}tj|tj}tj|tj}tj|tj}tj|tj}tj|tj}tj|tj}tj|tj}|gt|z||||||gz} d| d|f} t jdd| | | | }t jrt j d| | |t"j%|}|S)Nr{rgrNs'BoostedTreesCalculateBestFeatureSplitV2r?rt)rPrQrRrSrTr*r+r%rArBrCrYrDstringrr.r1r|rm)rarvrwrxrcrdrerfrgrrrVr:r9r4s r;r}r}s (4- 8  FH\ ] ^^/0&&'79KL(( F-112FX&&{GNNC+001F V b'//2" b'//2"**?GOOL/**?GOOL/4(<#==Ncegikm|NAOO, .0B &   G$0C"& ('""$ 1<R : @ @ I' .rE(BoostedTreesCalculateBestGainsPerFeature) node_ids_list gains_listthresholds_listleft_node_contribs_listright_node_contribs_liststats_summary_listc ^tjxstj}|j} | jr7 t j |d|||||||d| } t j| } | St|t t"fst%d|zt'|} t)j*|d}t-j.d|||||||| \} } }}|dd} t)j0rHd|j3dd|j3df}|j4}t)j6d||| | d| g| | dz} | dd| dd| zgz| d| zdz} | dd | d d | zgz| d | zdz} | dd | d d | zgz| d | zdz} | dd | d dgz} t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t||||||||| S#tj$rYwxYw) a Calculates gains for each feature and returns the best possible split information for the feature. The split information is the best threshold (bucket id), gains and left/right node contributions per node for each feature. It is possible that not all nodes can be split on each feature. Hence, the list of possible nodes can differ between the features. Therefore, we return `node_ids_list` for each feature, containing the list of nodes that this feature can be used to split. In this manner, the output is the best split per features and per node, so that it needs to be combined later to produce the best split for each node (among all possible features). The length of output lists are all of the same length, `num_features`. The output shapes are compatible in a way that the first dimension of all tensors of all lists are the same and equal to the number of possible split nodes for each feature. Args: node_id_range: A `Tensor` of type `int32`. A Rank 1 tensor (shape=[2]) to specify the range [first, last) of node ids to process within `stats_summary_list`. The nodes are iterated between the two nodes specified by the tensor, as like `for node_id in range(node_id_range[0], node_id_range[1])` (Note that the last index node_id_range[1] is exclusive). stats_summary_list: A list of at least 1 `Tensor` objects with type `float32`. A list of Rank 3 tensor (#shape=[max_splits, bucket, 2]) for accumulated stats summary (gradient/hessian) per node per buckets for each feature. The first dimension of the tensor is the maximum number of splits, and thus not all elements of it will be used, but only the indexes specified by node_ids will be used. l1: A `Tensor` of type `float32`. l1 regularization factor on leaf weights, per instance based. l2: A `Tensor` of type `float32`. l2 regularization factor on leaf weights, per instance based. tree_complexity: A `Tensor` of type `float32`. adjustment to the gain, per leaf based. min_node_weight: A `Tensor` of type `float32`. minimum avg of hessians in a node before required for the node to be considered for splitting. max_splits: An `int` that is `>= 1`. the number of nodes that can be split in the whole tree. Used as a dimension of output tensors. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (node_ids_list, gains_list, thresholds_list, left_node_contribs_list, right_node_contribs_list). node_ids_list: A list with the same length as `stats_summary_list` of `Tensor` objects with type `int32`. gains_list: A list with the same length as `stats_summary_list` of `Tensor` objects with type `float32`. thresholds_list: A list with the same length as `stats_summary_list` of `Tensor` objects with type `int32`. left_node_contribs_list: A list with the same length as `stats_summary_list` of `Tensor` objects with type `float32`. right_node_contribs_list: A list with the same length as `stats_summary_list` of `Tensor` objects with type `float32`. rrN)rrroExpected list for 'stats_summary_list' argument to 'boosted_trees_calculate_best_gains_per_feature' Op, not %r.)rarrcrdrerfrrrNr>)rrr r!rr"/_BoostedTreesCalculateBestGainsPerFeatureOutputrmr#r$r%r&r'=boosted_trees_calculate_best_gains_per_feature_eager_fallbackr)rPrQrRrSrTr*r+r,r-r.r/r0r1)rarrcrdrerfrrr2r3r4r5rVr6r7r8r9r:s r;.boosted_trees_calculate_best_gains_per_featurersL    0h..0$ #\\  11 8$ BO_j"g@EEgNg n &u 6  GI[ \ ]]-.  \:*'882-GY79bDSDS?I9=?!QX QK' ""$C--l;^/1F::L 2L&'S (( ) *W5G5H-I I' BQK71Q);%;<= =L^H^H_@` `' BQK71Q);%;<= =L^H^H_@` `' BQK71Q);%;<= =L^H^H_@` `' BQK712;- '' ; A A' J' .M  & &- ##At,,  # #    J +R_ jtGG  # #   s05F66G= G$$G=<G=HH,+H,z0raw_ops.BoostedTreesCalculateBestGainsPerFeaturec t|ttfstd|zt |} t j |d}tj|tj}tj|tj}tj|tj}tj|tj}tj|tj}tj|tj}|gt|z||||gz} d|d| f} t jd| | z| z| z| z| | ||} t jrt jd| | | | d| g| | dz} | dd| dd| zgz| d| zdz} | dd| dd| zgz| d| zdz} | dd | d d | zgz| d | zdz} | dd | d dgz} t j#| } | S) NrrrNs(BoostedTreesCalculateBestGainsPerFeaturer?rr>rrr)rPrQrRrSrTr*r+r%rArBrCrYrDrr.r1rrm) rarrcrdrerfrrrrVr:r9r4s r;rrsO &u 6  GI[ \ ]]-.  \:*(( F-//0BGOOT b'//2" b'//2"**?GOOL/**?GOOL/4(:#;;r2Xg>hh, *n6H I&   H/2DD/02DE/08D#)s  ?' ""$ 2L&'S (( ) *W5G5H-I I' BQK71Q);%;<= =L^H^H_@` `' BQK71Q);%;<= =L^H^H_@` `' BQK71Q);%;<= =L^H^H_@` `' BQK712;- '' ; A A' J' .rEtree_ensemble_handlemean_gradients mean_hessiansc ttjxstj}|j}|jr t j |d||||||}|Stjd||||||\} } } } | dd}tj r&d} | j"}tj$d|| ||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rYwxYw)aECalculates the prior from the training data (the bias) and fills in the first node with the logits' prior. Returns a boolean indicating whether to continue centering. Args: tree_ensemble_handle: A `Tensor` of type `resource`. Handle to the tree ensemble. mean_gradients: A `Tensor` of type `float32`. A tensor with shape=[logits_dimension] with mean of gradients for a first node. mean_hessians: A `Tensor` of type `float32`. A tensor with shape=[logits_dimension] mean of hessians for a first node. l1: A `Tensor` of type `float32`. l1 regularization factor on leaf weights, per instance based. l2: A `Tensor` of type `float32`. l2 regularization factor on leaf weights, per instance based. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. BoostedTreesCenterBiasNrJ)rrrrcrdr)rrr r!rr"r#r$r%r&r'(boosted_trees_center_bias_eager_fallbackr)r,r-r*r.r0r1)rrrrcrdrr2r3r4r5r6r7r8r9r:s r;boosted_trees_center_biasr;sN&    0h..0$ #\\ 11 &.B r2/gn(88 7K1?0="'+ -!QX QK' ""$ F::L  ,A (' ./  & &- ##At,,  # #    5  r2  # #   s0CD C22D  D D!!D76D7zraw_ops.BoostedTreesCenterBiasctj|tj}tj|tj}tj|tj}tj|tj}tj|tj}|||||g}d}t j dd||||} t jrt jd||| | \} | S)NsBoostedTreesCenterBiasr>r?r) r%rArBresourcerDr*rr.r1) rrrrcrdrrr:r9r4s r;rrrs//0DgFVFVW)).'//J.((H- b'//2" b'//2"& r2N, &   6$0C"& ('""$  ,A (' .rE stamp_tokentree_ensemble_serializedctjxstj}|j}|jr t j |d||||}|Stjd||||\}}} } | S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aCreates a tree ensemble model and returns a handle to it. Args: tree_ensemble_handle: A `Tensor` of type `resource`. Handle to the tree ensemble resource to be created. stamp_token: A `Tensor` of type `int64`. Token to use as the initial value of the resource stamp. tree_ensemble_serialized: A `Tensor` of type `string`. Serialized proto of the tree ensemble. name: A name for the operation (optional). Returns: The created Operation. BoostedTreesCreateEnsembleNrJrrrr)rrr r!rr"r#r$r%r&r',boosted_trees_create_ensemble_eager_fallbackr)r,r- rrrrr2r3r4r5r6r7r8s r;boosted_trees_create_ensemblers    0h..0$ #\\ 11 *D2F-/gn(88$;O2=?W+/ 1!QX *!  & &- ##At,,  # #    9  -E  # #   0A==CB++CCCC.-C.z"raw_ops.BoostedTreesCreateEnsemblec&tj|tj}tj|tj}tj|tj }|||g}d}t jdd||||}d}|S)NsBoostedTreesCreateEnsemblerr?r%rArBrint64rr*rrrrrrr:r9r4s r;rrs//0DgFVFVW&&{GMMB+!334Lgnn]& 5MN, &   :A$0C"& (' ' .rEquantile_stream_resource_handleepsilon num_streams max_elementsc tjxstj}|j}|jr t j |d||||d|}|S|d}tj|d}tj d|||||\} } } } | S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rYwxYw)aCreate the Resource for Quantile Streams. Args: quantile_stream_resource_handle: A `Tensor` of type `resource`. resource; Handle to quantile stream resource. epsilon: A `Tensor` of type `float32`. float; The required approximation error of the stream resource. num_streams: A `Tensor` of type `int64`. int; The number of streams managed by the resource that shares the same epsilon. max_elements: An optional `int`. Defaults to `1099511627776`. int; The maximum number of data points that can be fed to the stream. name: A name for the operation (optional). Returns: The created Operation. (BoostedTreesCreateQuantileStreamResourcerN)rrr)rrrrr)rrr r!rr"r#r$r%r&r'  -E  # #   rz'raw_ops.BoostedTreesDeserializeEnsemblec&tj|tj}tj|tj}tj|tj }|||g}d}t jdd||||}d}|S)NsBoostedTreesDeserializeEnsemblerr?rrs r;rr+s//0DgFVFVW&&{GMMB+!334Lgnn]& 5MN, &   ?$0C"& (' ' .rE container shared_namec tjxstj}|j}|jr t j |d|d|d|}|S|d}tj|d}|d}tj|d}tj d|||\}}}} | dd}tj"rHd|j%dd|j%df} |j&} tj(d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rY)wxYw)a Creates a handle to a BoostedTreesEnsembleResource Args: container: An optional `string`. Defaults to `""`. shared_name: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A `Tensor` of type `resource`. $BoostedTreesEnsembleResourceHandleOprrNrrrrrrr)rrr r!rr"r#r$r%r&r'8boosted_trees_ensemble_resource_handle_op_eager_fallbackr)r*ror,r-r.rpr0r1 rrrr2r3r4r5r6r7r8r9r:s r;)boosted_trees_ensemble_resource_handle_opr8s    0h..0$ #\\ 11 4dK=+/gnI ;7)K!!+}=+'88.)r?rr*rorr.r1rrrrr:r9r4s r;rrlsI ;7)K!!+}=+, M; ?&   Da$0C"& ('""$ . fgO (' .rEbucketized_featuresc :tjxstj}|j}|jr t j |d|||d|}|St|ttfst!d|zt#|}t%j&|d}t)j*d||||\} } } } | dd}t%j,rHd| j/dd| j/df} | j0} t%j2d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYQ R SS#&&9":&&'79KL'88)@T?Rr?rrPrQrRrSrTr*r+r%rArBrrYrCrr.r1 rrrgrrrr:r9r4s r;rrs '$ 7  <>Q R SS#&&9":&&'79KL//0DgFVFVW001DgmmT&'$/B*CC, %'D& (&   ?$0C"& ('""$ )<J (' .rErNctjxstj}|j}|jr t j |d||d|}|Stj|d}tj d|||\}}}} | dd}|s|Stj"r7d|j%df} |j&} tj(d| | ||S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)a:Flush the quantile summaries from each quantile stream resource. An op that outputs a list of quantile summaries of a quantile stream resource. Each summary Tensor is rank 2, containing summaries (value, weight, min_rank, max_rank) for a single feature. Args: quantile_stream_resource_handle: A `Tensor` of type `resource`. resource handle referring to a QuantileStreamResource. num_features: An `int` that is `>= 0`. name: A name for the operation (optional). Returns: A list of `num_features` `Tensor` objects with type `float32`. "BoostedTreesFlushQuantileSummariesrNNrNrrrrNr)rrr r!rr"r#r$r%r&r'5boosted_trees_flush_quantile_summaries_eager_fallbackr)r*r+r,r-r.r/r0r1 rrNrr2r3r4r5r6r7r8r9r:s r;&boosted_trees_flush_quantile_summariesrs`    0h..0$ #\\ 11 2D'Ggn""<@,'88,Nm;G379!QX QK'  J ""$c//? @F::L ,lFGM .1  & &- ##At,,  # #    B )   # #   0C&&D-9DD-,D-1EEEz*raw_ops.BoostedTreesFlushQuantileSummariesctj|d}tj|tj }|g}d|f}tj d|||||}tjrtjd||||S)NrNs"BoostedTreesFlushQuantileSummariesr?r r*r+r%rArBrrr.r1rrNrrr:r9r4s r;rr s""<@,$($:$:;Z\c\l\l$m!12, L )&   B),f!$4 1'""$ ,lFGM .rEBoostedTreesGetEnsembleStates)r num_treesnum_finalized_treesnum_attempted_layerslast_layer_nodes_rangectjxstj}|j}|jr0 t j |d||}t j|}|Stj d||\}}}}|dd}t#j$r&d} |j&} t#j(d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t|||S#tj$rYwxYw)auRetrieves the tree ensemble resource stamp token, number of trees and growing statistics. Args: tree_ensemble_handle: A `Tensor` of type `resource`. Handle to the tree ensemble. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (stamp_token, num_trees, num_finalized_trees, num_attempted_layers, last_layer_nodes_range). stamp_token: A `Tensor` of type `int64`. num_trees: A `Tensor` of type `int32`. num_finalized_trees: A `Tensor` of type `int32`. num_attempted_layers: A `Tensor` of type `int32`. last_layer_nodes_range: A `Tensor` of type `int32`. rNrJrrr)rrr r!rr"$_BoostedTreesGetEnsembleStatesOutputrmr#r$r%r&r'0boosted_trees_get_ensemble_states_eager_fallbackr)r,r-r*r.r0r1 rrr2r3r4r5r6r7r8r9r:s r;!boosted_trees_get_ensemble_statesrsH"    0h..0$ #\\ 11 -t5IKg4::7Cg n(88'>R.24!QX QK' ""$ F::L 'vwH 0 6 6w ?' .)  & &- ##At,,  # #    = Tt55  # #   0.C""D)5DD)(D)- D;;EEz%raw_ops.BoostedTreesGetEnsembleStatesctj|tj}|g}d}t j dd||||}t j rt jd|||tj|}|S)NsBoostedTreesGetEnsembleStatesr?r) r%rArBrr*rr.r1rrmrrrr:r9r4s r;rrN//0DgFVFVW&', &   =q$0C"& ('""$ 'vwH 0 6 6w ?' .rEexample_weightsctjxstj}|j}|jr t j |d||||}|St|ttfst!d|zt#|}t%j&d||||\} } } } | dd}t)j*r7d| j-df} | j.} t)j0d| | ||S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aMakes the summary of quantiles for the batch. An op that takes a list of tensors (one tensor per feature) and outputs the quantile summaries for each tensor. Args: float_values: A list of `Tensor` objects with type `float32`. float; List of Rank 1 Tensors each containing values for a single feature. example_weights: A `Tensor` of type `float32`. float; Rank 1 Tensor with weights per instance. epsilon: A `Tensor` of type `float32`. float; The required maximum approximation error. name: A name for the operation (optional). Returns: A list with the same length as `float_values` of `Tensor` objects with type `float32`. !BoostedTreesMakeQuantileSummariesNrJ`Expected list for 'float_values' argument to 'boosted_trees_make_quantile_summaries' Op, not %r.)rFrrrrN)rrr r!rr"r#r$r%r&r'4boosted_trees_make_quantile_summaries_eager_fallbackr)rPrQrRrSrTr,r-r*r.r/r0r1)rFrrrr2r3r4r5rVr6r7r8r9r:s r;%boosted_trees_make_quantile_summariesr\s$    0h..0$ #\\ 11 14"gn L4- 0  >@L M NN<('88+,=L5<4I!QX QK' ""$c//? @F::L +\67L .3  & &- ##At,,  # #    A tGG  # #   s0C<<ED**EEEE.-E.z)raw_ops.BoostedTreesMakeQuantileSummariesct|ttfstd|zt |}t j |tj}t j|tj}t j|tj}t|||gz}d|f}tjd|||||}tjrtjd||||S)NrrNs!BoostedTreesMakeQuantileSummariesr?r)rPrQrRrSrTr%rYrBrDrAr*rr.r1) rFrrrrrVr:r9r4s r;rrs L4- 0  >@L M NN<()),H,**?GOOL/  " "7GOO <'l#&@@, . /&   A/ #)s ?'""$ +\67L .rEbucketized_features_listc tjxstj}|j}|jr" t j |d|||||d|d| } | St|ttfst!d|zt#|} t%j&|d}t%j&|d}t)j*d|||||||\} } } }|dd} t%j,rYd| j/dd| j/dd| j/df}| j0}t%j2d||| | \} | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t||||||||S#t j$rYiwxYw) a!Makes the summary of accumulated stats for the batch. The summary stats contains gradients and hessians accumulated into the corresponding node and bucket for each example. Args: node_ids: A `Tensor` of type `int32`. int32 Rank 1 Tensor containing node ids, which each example falls into for the requested layer. gradients: A `Tensor` of type `float32`. float32; Rank 2 Tensor (shape=[#examples, 1]) for gradients. hessians: A `Tensor` of type `float32`. float32; Rank 2 Tensor (shape=[#examples, 1]) for hessians. bucketized_features_list: A list of at least 1 `Tensor` objects with type `int32`. int32 list of Rank 1 Tensors, each containing the bucketized feature (for each feature column). max_splits: An `int` that is `>= 1`. int; the maximum number of splits possible in the whole tree. num_buckets: An `int` that is `>= 1`. int; equals to the maximum possible value of bucketized feature. name: A name for the operation (optional). Returns: A `Tensor` of type `float32`. BoostedTreesMakeStatsSummaryrrNrgExpected list for 'bucketized_features_list' argument to 'boosted_trees_make_stats_summary' Op, not %r.)rrrrrrrrN)rrr r!rr"r#r$r%r&r'/boosted_trees_make_stats_summary_eager_fallbackr)rPrQrRrSrTr*r+r,r-r.r/r0r1)rrrrrrrr2r3r4r5rVr6r7r8r9r:s r; boosted_trees_make_stats_summaryrs.    0h..0$ #\\  11 ,dHi*L*{$gn ,tUm <  9;S T UU34  \:*!!+}=+'88&2;19AY3=4?d L!QX QK' ""$C--l;] ./1F::L & fgG (' .E  & &- ##At,,  # #    < Ix)A[tOO  # #   s0 EF)FFF!F44G  G z$raw_ops.BoostedTreesMakeStatsSummaryct|ttfstd|zt |}t j |d}t j |d}tj|tj}tj|tj}tj|tj}tj|tj}|||gt|z} d|d|d|f} t jdd| | ||} t jrt jd| | | | \} | S) NrrrrNsBoostedTreesMakeStatsSummaryr>r?r)rPrQrRrSrTr*r+r%rArBrCrDrYrr.r1) rrrrrrrrrVr:r9r4s r;rrs; ,tUm <  9;S T UU34  \:*!!+}=+  # #Hgmm <($$Y@)  # #Hgoo >(!556NPWP]P]^Ix048P3QQ, *m[$ &&    (' .=  & &- ##At,,  # #    1  3+$DBB  # #   rzraw_ops.BoostedTreesPredictct|ttfstd|zt |}t j |d}tj|tj}tj|tj}|gt|z}d|d|f}t jdd||||}t jrt jd||||\}|S)NrrgrsBoostedTreesPredictr>r?rrrs r;rrFs '$ 7  .0C D EE#&&9":&&'79KL//0DgFVFVW001DgmmT&'$/B*CC, %'D& (&   3Q|#)s ?' ""$ |VW> (' .rE summariesc:tjxstj}|j}|jr t j |d|||}|St|ttfst!d|zt#|}t%j&d|||\}}} } | S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)awAdd the quantile summaries to each quantile stream resource. An op that adds a list of quantile summaries to a quantile stream resource. Each summary Tensor is rank 2, containing summaries (value, weight, min_rank, max_rank) for a single feature. Args: quantile_stream_resource_handle: A `Tensor` of type `resource`. resource handle referring to a QuantileStreamResource. summaries: A list of `Tensor` objects with type `float32`. string; List of Rank 2 Tensor each containing the summaries for a single feature. name: A name for the operation (optional). Returns: The created Operation. .BoostedTreesQuantileStreamResourceAddSummariesNrJlExpected list for 'summaries' argument to 'boosted_trees_quantile_stream_resource_add_summaries' Op, not %r.)rrr)rrr r!rr"r#r$r%r&r'Cboosted_trees_quantile_stream_resource_add_summaries_eager_fallbackr)rPrQrRrSrTr,r-) rrrr2r3r4r5rVr6r7r8s r;4boosted_trees_quantile_stream_resource_add_summariesr[s0"    0h..0$ #\\ 11 >'4gn Ie} -  MOX Y ZZ9~'888ZyDM?CE!QX *'  & &- ##At,,  # #    P )94TKK  # #   0B**C1=CC10C15DDDz6raw_ops.BoostedTreesQuantileStreamResourceAddSummariescTt|ttfstd|zt |}t j |tj}t j|tj}|gt|z}d|f}tjdd||||}d}|S)NrrNs.BoostedTreesQuantileStreamResourceAddSummariesrr? rPrQrRrSrTr%rArBrrYrDr*r)rrrrrVr:r9r4s r;rrs Ie} -  MOX Y ZZ9~$($:$:;Z\c\l\l$m!&&y'//B)12T)_D, . /&   N|6s"& (' ' .rEc:tjxstj}|j}|jr t j |d|||}|St|ttfst!d|zt#|}t%j&d|||\}}} } | S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aIDeserialize bucket boundaries and ready flag into current QuantileAccumulator. An op that deserializes bucket boundaries and are boundaries ready flag into current QuantileAccumulator. Args: quantile_stream_resource_handle: A `Tensor` of type `resource`. resource handle referring to a QuantileStreamResource. bucket_boundaries: A list of at least 1 `Tensor` objects with type `float32`. float; List of Rank 1 Tensors each containing the bucket boundaries for a feature. name: A name for the operation (optional). Returns: The created Operation. -BoostedTreesQuantileStreamResourceDeserializeNrJrExpected list for 'bucket_boundaries' argument to 'boosted_trees_quantile_stream_resource_deserialize' Op, not %r.)rrGr)rrr r!rr"r#r$r%r&r'Aboosted_trees_quantile_stream_resource_deserialize_eager_fallbackr)rPrQrRrSrTr,r-) rrGrr2r3r4r5_attr_num_streamsr6r7r8s r;2boosted_trees_quantile_stream_resource_deserializers6    0h..0$ #\\ 11 =t'):BD!QX *)  & &- ##At,,  # #    N )+<4  # #   r z5raw_ops.BoostedTreesQuantileStreamResourceDeserializecTt|ttfstd|zt |}t j |tj}t j|tj}|gt|z}d|f}tjdd||||}d}|S)Nrrs-BoostedTreesQuantileStreamResourceDeserializerr?r )rrGrrrr:r9r4s r;rrs %e} 5  KM^ _ ``+,$($:$:;Z\c\l\l$m!../@'//R12T:K5LL, , -&   M|6s"& (' ' .rEgenerate_quantilesc tjxstj}|j}|jr t j |d|||d|}|S|d}tj|d}tj d||||\}}} } | S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)aFlush the summaries for a quantile stream resource. An op that flushes the summaries for a quantile stream resource. Args: quantile_stream_resource_handle: A `Tensor` of type `resource`. resource handle referring to a QuantileStreamResource. num_buckets: A `Tensor` of type `int64`. int; approximate number of buckets unless using generate_quantiles. generate_quantiles: An optional `bool`. Defaults to `False`. bool; If True, the output will be the num_quantiles for each stream where the ith entry is the ith quantile of the input with an approximation error of epsilon. Duplicate values may be present. If False, the output will be the points in the histogram that we got which roughly translates to 1/epsilon boundaries and without any duplicates. Default to False. name: A name for the operation (optional). Returns: The created Operation. 'BoostedTreesQuantileStreamResourceFlushrN)rrrF)rrrr)rrr r!rr"r#r$r%r&r';boosted_trees_quantile_stream_resource_flush_eager_fallbackr)r* make_boolr,r-) rrrrr2r3r4r5r6r7r8s r;,boosted_trees_quantile_stream_resource_flushrs&,    0h..0$ #\\  11 7'6Jgn))*<>RS'881Sr?JFX8< >!QX *'  & &- ##At,,  # #    H );/dFF  # #   s0BC+CCC#C33D D z/raw_ops.BoostedTreesQuantileStreamResourceFlushc|d}tj|d}tj|tj }tj|tj }||g}d|f}tjdd||||}d}|S)NFrs'BoostedTreesQuantileStreamResourceFlushrr?)r*rr%rArBrrr)rrrrrr:r9r4s r;rrs))*<>RS$($:$:;Z\c\l\l$m!&&{GMMB+1;?, "4 5&   G$0C"& (' ' .rEctjxstj}|j}|jr t j |d||d|}|Stj|d}tj d|||\}}}} | dd}|s|Stj"r7d|j%df} |j&} tj(d| | ||S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)acGenerate the bucket boundaries for each feature based on accumulated summaries. An op that returns a list of float tensors for a quantile stream resource. Each tensor is Rank 1 containing bucket boundaries for a single feature. Args: quantile_stream_resource_handle: A `Tensor` of type `resource`. resource handle referring to a QuantileStreamResource. num_features: An `int` that is `>= 0`. inferred int; number of features to get bucket boundaries for. name: A name for the operation (optional). Returns: A list of `num_features` `Tensor` objects with type `float32`. 5BoostedTreesQuantileStreamResourceGetBucketBoundariesrNNrr)rrr r!rr"r#r$r%r&r'Kboosted_trees_quantile_stream_resource_get_bucket_boundaries_eager_fallbackr)r*r+r,r-r.r/r0r1rs r;r?r rrs r;r!r!sI ;7)K!!+}=+, M; ?&   JA$0C"& ('""$ 4lFGU (' .rEBoostedTreesSerializeEnsemblectjxstj}|j}|jr0 t j |d||}t j|}|Stj d||\}}}}|dd}t#j$r&d} |j&} t#j(d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t|||S#tj$rYwxYw)a}Serializes the tree ensemble to a proto. Args: tree_ensemble_handle: A `Tensor` of type `resource`. Handle to the tree ensemble. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (stamp_token, tree_ensemble_serialized). stamp_token: A `Tensor` of type `int64`. tree_ensemble_serialized: A `Tensor` of type `string`. r$NrJrr)rrr r!rr"$_BoostedTreesSerializeEnsembleOutputrmr#r$r%r&r'/boosted_trees_serialize_ensemble_eager_fallbackr)r,r-r*r.r0r1rs r; boosted_trees_serialize_ensembler(sH    0h..0$ #\\ 11 -t5IKg4::7Cg n(88'>R.24!QX QK' ""$ F::L 'vwH 0 6 6w ?' .)  & &- ##At,,  # #    < Tt55  # #   rz%raw_ops.BoostedTreesSerializeEnsemblectj|tj}|g}d}t j dd||||}t j rt jd|||tj|}|S)NsBoostedTreesSerializeEnsemblerr?r$) r%rArBrr*rr.r1r&rmrs r;r'r'rrE BoostedTreesSparseAggregateStats)stats_summary_indicesstats_summary_valuesstats_summary_shapefeature_indicesfeature_values feature_shapec ttjxstj} | j} | jr9 t j | d|||||||d|d| } t j| } | Stj |d}tj |d}t#j$d||||||||| \} } }}|dd} tj&rHd|j)dd|j)df}|j*}tj,d||| t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t||||||||||  S#tj$rY>wxYw)aAggregates the summary of accumulated stats for the batch. The summary stats contains gradients and hessians accumulated for each node, bucket and dimension id. Args: node_ids: A `Tensor` of type `int32`. int32; Rank 1 Tensor containing node ids for each example, shape [batch_size]. gradients: A `Tensor` of type `float32`. float32; Rank 2 Tensor (shape=[batch_size, logits_dimension]) with gradients for each example. hessians: A `Tensor` of type `float32`. float32; Rank 2 Tensor (shape=[batch_size, hessian_dimension]) with hessians for each example. feature_indices: A `Tensor` of type `int32`. int32; Rank 2 indices of feature sparse Tensors (shape=[number of sparse entries, 2]). Number of sparse entries across all instances from the batch. The first value is the index of the instance, the second is dimension of the feature. The second axis can only have 2 values, i.e., the input dense version of Tensor can only be matrix. feature_values: A `Tensor` of type `int32`. int32; Rank 1 values of feature sparse Tensors (shape=[number of sparse entries]). Number of sparse entries across all instances from the batch. The first value is the index of the instance, the second is dimension of the feature. feature_shape: A `Tensor` of type `int32`. int32; Rank 1 dense shape of feature sparse Tensors (shape=[2]). The first axis can only have 2 values, [batch_size, feature_dimension]. max_splits: An `int` that is `>= 1`. int; the maximum number of splits possible in the whole tree. num_buckets: An `int` that is `>= 1`. int; equals to the maximum possible value of bucketized feature + 1. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (stats_summary_indices, stats_summary_values, stats_summary_shape). stats_summary_indices: A `Tensor` of type `int32`. stats_summary_values: A `Tensor` of type `float32`. stats_summary_shape: A `Tensor` of type `int32`. r*rrNr) rrrr.r/r0rrr)rrr r!rr"'_BoostedTreesSparseAggregateStatsOutputrmr#r$r%r&r'3boosted_trees_sparse_aggregate_stats_eager_fallbackr)r*r+r,r-r.r/r0r1)rrrr.r/r0rrrr2r3r4r5r6r7r8r9r:s r;$boosted_trees_sparse_aggregate_statsr4sJ    0h..0$ #\\  11 0$)/>=j->g8==gFg n  \:*!!+}=+'88*X6?5=(**?GMMJ/)).'--H.(( F-Ix.R_`, *m[ A&   @!$0C"& ('""$ *L&'K 3 9 9' B' .rE+BoostedTreesSparseCalculateBestFeatureSplitr+r,r-c tjxstj} | j} | jr; t j | d| ||||||||d|d| } t j| } | Stj |d}| d} tj"| d} t%j&d|||||||||| |  \}}}}|dd} tj(rHd|j+dd|j-df}|j.}tj0d||| t j| } | S#tj$r }tj|| Yd}~nd}~wtj$rYnwxYw t|||||||||| | |  S#tj$rYFwxYw)a Calculates gains for each feature and returns the best possible split information for the feature. The split information is the best threshold (bucket id), gains and left/right node contributions per node for each feature. It is possible that not all nodes can be split on each feature. Hence, the list of possible nodes can differ between the features. Therefore, we return `node_ids_list` for each feature, containing the list of nodes that this feature can be used to split. In this manner, the output is the best split per features and per node, so that it needs to be combined later to produce the best split for each node (among all possible features). The output shapes are compatible in a way that the first dimension of all tensors are the same and equal to the number of possible split nodes for each feature. Args: node_id_range: A `Tensor` of type `int32`. A Rank 1 tensor (shape=[2]) to specify the range [first, last) of node ids to process within `stats_summary_list`. The nodes are iterated between the two nodes specified by the tensor, as like `for node_id in range(node_id_range[0], node_id_range[1])` (Note that the last index node_id_range[1] is exclusive). stats_summary_indices: A `Tensor` of type `int32`. A Rank 2 int64 tensor of dense shape [N, 4] (N specifies the number of non-zero values) for accumulated stats summary (gradient/hessian) per node per bucket for each feature. The second dimension contains node id, feature dimension, bucket id, and stats dim. stats dim is the sum of logits dimension and hessian dimension, hessian dimension can either be logits dimension if diagonal hessian is used, or logits dimension^2 if full hessian is used. stats_summary_values: A `Tensor` of type `float32`. A Rank 1 float tensor of dense shape [N] (N specifies the number of non-zero values), which supplies the values for each element in summary_indices. stats_summary_shape: A `Tensor` of type `int32`. A Rank 1 float tensor of dense shape [4], which specifies the dense shape of the sparse tensor, which is [num tree nodes, feature dimensions, num buckets, stats dim]. l1: A `Tensor` of type `float32`. l1 regularization factor on leaf weights, per instance based. l2: A `Tensor` of type `float32`. l2 regularization factor on leaf weights, per instance based. tree_complexity: A `Tensor` of type `float32`. adjustment to the gain, per leaf based. min_node_weight: A `Tensor` of type `float32`. minimum avg of hessians in a node before required for the node to be considered for splitting. logits_dimension: An `int` that is `>= 1`. The dimension of logit, i.e., number of classes. split_type: An optional `string` from: `"inequality"`. Defaults to `"inequality"`. A string indicating if this Op should perform inequality split or equality split. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (node_ids, gains, feature_dimensions, thresholds, left_node_contribs, right_node_contribs, split_with_default_directions). node_ids: A `Tensor` of type `int32`. gains: A `Tensor` of type `float32`. feature_dimensions: A `Tensor` of type `int32`. thresholds: A `Tensor` of type `int32`. left_node_contribs: A `Tensor` of type `float32`. right_node_contribs: A `Tensor` of type `float32`. split_with_default_directions: A `Tensor` of type `string`. r6rgrhNrjrk) rar+r,r-rcrdrerfrgrhr)rrr r!rr"2_BoostedTreesSparseCalculateBestFeatureSplitOutputrmr#r$r%r&r'@boosted_trees_sparse_calculate_best_feature_split_eager_fallbackr)r*r+ror,r-r.r/rpr0r1)rar+r,r-rcrdrerfrgrhrr2r3r4r5r6r7r8r9r:s r;1boosted_trees_sparse_calculate_best_feature_splitr:]s\    0h..0$ #\\  11 ;T,.BR_o,lJ Hg CHHQg n&&'79KLJ  \:*'885]MbL`K^:<GVGVHXBL<@ B!QX QK' ""$ #"3"34F"GCLL68F::L 5|VWV > D DW M' .I  & &- ##At,,  # #    M .0D r2+    # #   s09EFE66FFF**GGz3raw_ops.BoostedTreesSparseCalculateBestFeatureSplitc ~tj|d}| d} tj| d} tj|t j }tj|t j }tj|t j}tj|t j }tj|t j}tj|t j}tj|t j}tj|t j}||||||||g} d|d| f} tjdd| | | | }tjrtjd| | |tj|}|S)Nrgrkrhs+BoostedTreesSparseCalculateBestFeatureSplitrsr?r6) r*r+ror%rArBrCrDrr.r1r8rm)rar+r,r-rcrdrerfrgrhrrr:r9r4s r;r9r9sw&&'79KLJ  \:*(( F-001F V//0DgooV../BGMMR b'//2" b'//2"**?GOOL/**?GOOL/!68LNacegikz}LM,  0, K&   K|6s"& ('""$ 5|VWV > D DW M' .rEBoostedTreesTrainingPredict)partial_logitstree_idsrcached_tree_idscached_node_idsc tjxstj}|j}|jr5 t j |d|||||d| }t j|}|St|t t"fst%d|zt'|} t)j*|d}t-j.d||||||\} } } } | dd}t)j0rHd| j3dd| j3df}| j4}t)j6d|||t j|}|S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t|||||||S#tj$rYQwxYw)aRuns multiple additive regression ensemble predictors on input instances and computes the update to cached logits. It is designed to be used during training. It traverses the trees starting from cached tree id and cached node id and calculates the updates to be pushed to the cache. Args: tree_ensemble_handle: A `Tensor` of type `resource`. cached_tree_ids: A `Tensor` of type `int32`. Rank 1 Tensor containing cached tree ids which is the starting tree of prediction. cached_node_ids: A `Tensor` of type `int32`. Rank 1 Tensor containing cached node id which is the starting node of prediction. bucketized_features: A list of at least 1 `Tensor` objects with type `int32`. A list of rank 1 Tensors containing bucket id for each feature. logits_dimension: An `int`. scalar, dimension of the logits, to be used for partial logits shape. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (partial_logits, tree_ids, node_ids). partial_logits: A `Tensor` of type `float32`. tree_ids: A `Tensor` of type `int32`. node_ids: A `Tensor` of type `int32`. r<rgNrz`Expected list for 'bucketized_features' argument to 'boosted_trees_training_predict' Op, not %r.)rr?r@rrgrr)rrr r!rr""_BoostedTreesTrainingPredictOutputrmr#r$r%r&r'-boosted_trees_training_predict_eager_fallbackr)rPrQrRrSrTr*r+r,r-r.r/r0r1)rr?r@rrgrr2r3r4r5rr6r7r8r9r:s r;boosted_trees_training_predictrEs<    0h..0$ #\\  11 +T3G*=,.g388Ag n '$ 7  79L M NN#&&9":&&'79KL'88%= 0`. 0-No pruning, 1-Pre-pruning, 2-Post-pruning. name: A name for the operation (optional). Returns: The created Operation. BoostedTreesUpdateEnsemblerIN)rIrrTExpected list for 'node_ids' argument to 'boosted_trees_update_ensemble' Op, not %r.QExpected list for 'gains' argument to 'boosted_trees_update_ensemble' Op, not %r.wList argument 'gains' to 'boosted_trees_update_ensemble' Op with length %d must match length %d of argument 'node_ids'.VExpected list for 'thresholds' argument to 'boosted_trees_update_ensemble' Op, not %r.|List argument 'thresholds' to 'boosted_trees_update_ensemble' Op with length %d must match length %d of argument 'node_ids'.^Expected list for 'left_node_contribs' argument to 'boosted_trees_update_ensemble' Op, not %r.List argument 'left_node_contribs' to 'boosted_trees_update_ensemble' Op with length %d must match length %d of argument 'node_ids'._Expected list for 'right_node_contribs' argument to 'boosted_trees_update_ensemble' Op, not %r.List argument 'right_node_contribs' to 'boosted_trees_update_ensemble' Op with length %d must match length %d of argument 'node_ids'.) rrurr[r]r^r_rGrHrIr)rrr r!rr"r#r$r%r&r',boosted_trees_update_ensemble_eager_fallbackr)rPrQrRrSrTrUr*r+r,r-)rrurr[r]r^r_rGrHrIrr2r3r4r5rVr6r7r8s r;boosted_trees_update_ensemblerVCs L    0h..0$ #\\  11 *D2FXuj2DY ~ g n HtUm ,  68@ A BB8} ED%= )  68= > ?? Z%%  7 U'( ) ** Ju .  68B C DD _**  7 Z,- . // &u 6  68J K LL  22  7  "45 6 77 '$ 7  68K L MM !33  7 !#56 7 88""<@,'88$;O2=/7u1;9K:M094A3?d L!QX *A  & &- ##At,,  # #    9  Xuj 19m#$D::  # #   s0#G==IH++IIII65I6z"raw_ops.BoostedTreesUpdateEnsemblec @t|ttfstd|zt |} t|ttfstd|zt || k7rt dt || fzt|ttfstd|zt || k7rt dt || fzt|ttfstd|zt || k7rt dt || fzt|ttfstd|zt || k7rt d t || fzt j| d } tj|tj}tj|tj}tj|tj}tj|tj}tj|tj}tj|tj}tj|tj}tj|tj}tj|tj}||gt|zt|zt|zt|zt|z||gz} d | d | f}t jd d | || | }d}|S)NrLrMrNrOrPrQrRrSrTrIrNsBoostedTreesUpdateEnsemblerr?)rPrQrRrSrTrUr*r+r%rArBrrCrYrDr)rrurr[r]r^r_rGrHrIrrrVr:r9r4s r;rUrUsO HtUm ,  68@ A BB8} ED%= )  68= > ?? Z%%  7 U'( ) ** Ju .  68B C DD _**  7 Z,- . // &u 6  68J K LL  22  7  "45 6 77 '$ 7  68K L MM !33  7 !#56 7 88""<@,//0DgFVFVW&&{GMMB+  % %h >(  " "5'// :%'' GMMB*//0BGOOT001DgooV$$Y >)((H-& 4tH~EU SVZ[eVffimoAjBBEIJ]E^^bkmza{{, L.:L M&   :A$0C"& (' ' .rE dimension_idsctjxstj}|j}|jr( t j |d| |||||||||| | | d| }|St|ttfst!d|zt#|}t|ttfst!d|zt#||k7rt%dt#||fzt|ttfst!d|zt#||k7rt%d t#||fzt|ttfst!d |zt#||k7rt%d t#||fzt|ttfst!d |zt#||k7rt%d t#||fzt|ttfst!d|zt#||k7rt%dt#||fzt|ttfst!d|zt#||k7rt%dt#||fzt|ttfst!d|zt#|}| d} t'j(| d} t+j,d|||||||||| | | | | \}}}}|S#t j$r }tj|| Yd}~nd}~wt j$rYnwxYw t|||||||||| | | | | |S#t j$rYwxYw)a' Updates the tree ensemble by adding a layer to the last tree being grown or by starting a new tree. Args: tree_ensemble_handle: A `Tensor` of type `resource`. Handle to the ensemble variable. feature_ids: A list of at least 1 `Tensor` objects with type `int32`. Rank 1 tensor with ids for each feature. This is the real id of the feature that will be used in the split. dimension_ids: A list of `Tensor` objects with type `int32`. List of rank 1 tensors representing the dimension in each feature. node_ids: A list with the same length as `dimension_ids` of `Tensor` objects with type `int32`. List of rank 1 tensors representing the nodes for which this feature has a split. gains: A list with the same length as `dimension_ids` of `Tensor` objects with type `float32`. List of rank 1 tensors representing the gains for each of the feature's split. thresholds: A list with the same length as `dimension_ids` of `Tensor` objects with type `int32`. List of rank 1 tensors representing the thesholds for each of the feature's split. left_node_contribs: A list with the same length as `dimension_ids` of `Tensor` objects with type `float32`. List of rank 2 tensors with left leaf contribs for each of the feature's splits. Will be added to the previous node values to constitute the values of the left nodes. right_node_contribs: A list with the same length as `dimension_ids` of `Tensor` objects with type `float32`. List of rank 2 tensors with right leaf contribs for each of the feature's splits. Will be added to the previous node values to constitute the values of the right nodes. split_types: A list with the same length as `dimension_ids` of `Tensor` objects with type `string`. List of rank 1 tensors representing the split type for each feature. max_depth: A `Tensor` of type `int32`. Max depth of the tree to build. learning_rate: A `Tensor` of type `float32`. shrinkage const for each new tree. pruning_mode: A `Tensor` of type `int32`. 0-No pruning, 1-Pre-pruning, 2-Post-pruning. logits_dimension: An optional `int`. Defaults to `1`. scalar, dimension of the logits name: A name for the operation (optional). Returns: The created Operation. BoostedTreesUpdateEnsembleV2rgNrz\Expected list for 'dimension_ids' argument to 'boosted_trees_update_ensemble_v2' Op, not %r.WExpected list for 'node_ids' argument to 'boosted_trees_update_ensemble_v2' Op, not %r.List argument 'node_ids' to 'boosted_trees_update_ensemble_v2' Op with length %d must match length %d of argument 'dimension_ids'.TExpected list for 'gains' argument to 'boosted_trees_update_ensemble_v2' Op, not %r.List argument 'gains' to 'boosted_trees_update_ensemble_v2' Op with length %d must match length %d of argument 'dimension_ids'.YExpected list for 'thresholds' argument to 'boosted_trees_update_ensemble_v2' Op, not %r.List argument 'thresholds' to 'boosted_trees_update_ensemble_v2' Op with length %d must match length %d of argument 'dimension_ids'.aExpected list for 'left_node_contribs' argument to 'boosted_trees_update_ensemble_v2' Op, not %r.List argument 'left_node_contribs' to 'boosted_trees_update_ensemble_v2' Op with length %d must match length %d of argument 'dimension_ids'.bExpected list for 'right_node_contribs' argument to 'boosted_trees_update_ensemble_v2' Op, not %r.List argument 'right_node_contribs' to 'boosted_trees_update_ensemble_v2' Op with length %d must match length %d of argument 'dimension_ids'.ZExpected list for 'split_types' argument to 'boosted_trees_update_ensemble_v2' Op, not %r.List argument 'split_types' to 'boosted_trees_update_ensemble_v2' Op with length %d must match length %d of argument 'dimension_ids'.ZExpected list for 'feature_ids' argument to 'boosted_trees_update_ensemble_v2' Op, not %r.r>)rrurXrr[r]r^r_rwrGrHrIrgr)rrr r!rr"r#r$r%r&r'/boosted_trees_update_ensemble_v2_eager_fallbackr)rPrQrRrSrTrUr*r+r,r-)rrurXrr[r]r^r_rwrGrHrIrgrr2r3r4r5rV_attr_num_groupsr6r7r8s r; boosted_trees_update_ensemble_v2rks2X    0h..0$ #\\  11 ,d4H]HeZ/i|%79I Kg n MD%= 1  9;H I JJ=) HtUm ,  9;C D EE ]((  < X*+ , -- ED%= )  9;@ A BB Z%%  < U'( ) ** Ju .  9;E F GG _**  < Z,- . // &u 6  9;M N OO  22  <  "45 6 77 '$ 7  9;N O PP !33  < !#56 7 88 K$ /  9;F G HH ++  < [ -. / 00 K$ /  9;F G HH%&&'79KL'88&=Q4?6C193=;MrgrN num_groupssBoostedTreesUpdateEnsembleV2rr?)rPrQrRrSrTrUr*r+r%rArBrrYrCrDrr)rrurXrr[r]r^r_rwrGrHrIrgrrrVrjr:r9r4s r;riri s MD%= 1  9;H I JJ=) HtUm ,  9;C D EE ]((  < X*+ , -- ED%= )  9;@ A BB Z%%  < U'( ) ** Ju .  9;E F GG _**  < Z,- . // &u 6  9;M N OO  22  <  "45 6 77 '$ 7  9;N O PP !33  < !#56 7 88 K$ /  9;F G HH ++  < [ -. / 00 K$ /  9;F G HH%&&'79KL//0DgFVFVW((gmmD+**='--H-  % %h >(  " "5'// :%'' GMMB*//0BGOOT001DgooV((gnnE+$$Y >)((H-'' gmmD,&'${*;;d=>QQTXYaTbbeijoeppswyCtDDGKL^G__bfgzb{{~BCN~OOS\^kmyRzz, .0BL"2 4&   r?ror%rArBrr*rr.r1rs r;rprp sz//0DgFVFVW&', &   A1$0C"& ('""$ +\67L (' .rEc\tjxstj}|j}|jr t j |d||}|Stjd||\}}}}|dd}tj r&d} |j"} tj$d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||S#t j$rYwxYw)acChecks whether a quantile stream has been initialized. An Op that checks if quantile stream resource is initialized. Args: quantile_stream_resource_handle: A `Tensor` of type `resource`. resource; The reference to quantile stream resource handle. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. /IsBoostedTreesQuantileStreamResourceInitializedNrJ)rrr)rrr r!rr"r#r$r%r&r'Dis_boosted_trees_quantile_stream_resource_initialized_eager_fallbackr)r,r-r*r.r0r1) rrr2r3r4r5r6r7r8r9r:s r;5is_boosted_trees_quantile_stream_resource_initializedrx s4    0h..0$ #\\ 11 ?')gn(889[z@DF!QX QK' ""$ F::L 9<QXZ (' .)  & &- ##At,,  # #    Q )$@@  # #   rrz7raw_ops.IsBoostedTreesQuantileStreamResourceInitializedctj|tj}|g}d}t j dd||||}t j rt jd||||\}|S)Ns/IsBoostedTreesQuantileStreamResourceInitializedr>r?rvrt)rrrr:r9r4s r;rwrwM s|$($:$:;Z\c\l\l$m!12, &   O|6s"& ('""$ 9<QXZ (' .rE)N)rkN)rN)rrN)FN)r>N)__doc__ collectionstensorflow.pythonrtensorflow.python.eagerrrrr#rr*tensorflow.python.frameworkrrBtensorflow.security.fuzzing.pyr_atypesr _op_def_registryr r%r r,"tensorflow.python.util.deprecationr tensorflow.python.utilr _dispatch tensorflow.python.util.tf_exportrtypingrrrtyping_extensionsrInt32Float32intr< to_raw_oprr(rWrIrO namedtuplerlstrrqrZrnr|Stringr~rtr}rrrrResourceBoolrrrInt64rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rboolrrrrrrr"r r!r&r(r$r'r2r4r*r3r8r:r6r9rCrEr<rDrVrKrUrkrZrirqrorprxrvrwrrEr;rs4 67179FK3IC86%%':Ic7==6H,I:V_`celetet`tVu:BKLOQXQ`Q`L`Ba:luvy{B{H{HvHlI:WZ:il:|EFIKRKZKZFZ|[:xMY'KL^T^^\yMz{9S'--EW;Xenort{uDuDpDfEQZ[^`g`o`o[oQp{DEHJQJWJWEW{Xfix{KTUXZaZiZiUiKj&:)DIw4N*O:dmnrsvnwzAzIzIoIeJ:xC "AB>4>>RiCjk49gooC]9^s|~BCF~GIPIXIX~XtY60F{/E/E+L0M, UiW]]HZ>[Uluvy|C|K|KwKmLUR[\_ahapap\pRqUw@ADFMFUFUAUwVUirsvxxGxGsGiHU[dehjqjyjyey[zUNQU^aUn)c 2a(bcqcgcqcqs]d^)_%YWZ\c\i\iWiMj|EFIKRKZKZFZ|[ajknpwppka@FOPSU\UdUdPdFexABEGNGVGVBVxWjstwy@yHyHtHjI]`nq,2H1G1G-[2\. \3PWP]P]K]A^\vAEFIAJLSL[L[A[w\\ktuxzAzHzHuHkI\bkloqxq~q~l~b\ENORT[TcTcOcEd\jstwy@yHyHtHjI\\efikrkzkzfz\{\NWX[]d]l]lXlNm\AD\|+g)4e*fgugkguguwdhe+f'PYZ]_f_l_lZlPmFOPTUXPY[b[j[jPjFkzCDGIPIWIWDWzXqz{~@G@M@M{MqNT]^acjcrcr^rTsyBCFHOHWHWCWyXktuxzAzIzIuIkJ]fgjlsl{l{g{]|PS63I+2H2H.m3o/ V)CQXQ^Q^L^B_Vu~@DEH@IKRKZKZ@Zv[Vajknpwppka@VFOPSU\UdUdPdFeVxABEGNGVGVBVxWVjstwy@yHyHtHjIVWZVp,i95g+hiwimiwiwygjh,i(QZ[^`g`m`m[mQnENOSTWOXZaZiZiOiEjpyz}FNNzNpOU^_bdkdsds_sUtGPQTV]VeVeQeGfyBCFHOHWHWCWyXfi@2Ic7CSCS>S4T2fopsu|vEvEqEgF2W`adfmfufuauWv2|EFIKRKZKZFZ|[2ajknpwppka@2PYZ]_f_k_kZkPl2hE#CD^T^^TmEno9SRYRbRbMbCcu~@CELETET@TvUfopsu|uDuDpDfEKTUXZaZiZiUiKjpyz}FNNzNpO_hilnunznziz_{$' #wGWGWBW8X' gpqtv}wDwDrDhE' ajknpwp~p~k~a' PMY'KL^T^^\yMz{ yQTV]VfVfQfGg vADFMFSFSASwT pyz}FMMzMpN . S\]`bibrbr]rSs. HILNUN]N]I]^. mvwz|C|I|IwImJ. Y\. ^,i95g+hiwimiwiwyfjg,h( bkloqxrBrBmBcC NWX[]d]l]lXlNm |EFIKRKXKXFX|Y il  ) YsGL\L\G\=]) luvy|C|I|IwImJ) fopsu|uCuCpCfD) T#W),U"VWeW[WeWegIXJ#K IVY[b[k[kVkLl |EFIKRKXKXFX|Y u~BDKDRDRRuS //C/bkloqxrBrBmBcC/b(ay1_'`aoaeaoaoqZb[(\$Z]mvwz}D}M}MxMnN&;iWM]M]H]>^;u~@DEH@IKRKXKX@XvY;mp;@IJMOVO]O]J]@^;z#W),U"VWeW[WeWegJXK#LYWZ\c\l\lWlMmENOSTWOXZaZgZgOgEh|OXY\^e^l^lYlOm,0IVY[b[k[kVkLl0|0d&]Y/[%\]k]a]k]kmS^T&U" [dehjqjzjzez[{ LO (>{'='=#i(k$ -Ic7K[K[F[<\-^!S *Q RSaSWSaSacDTE!F 9UXZaZjZjUjKk 3 $s)W__B\8]3pyz}@G@O@O{OqP3[dehjqjyjyey[z3j%[I.Y$Z[i[_[i[ikP\Q%R!yQUVYQZ\c\k\kQkGl@IJMOVO^O^J^@_jstwy@yHyHtHjI(Bygmm9K/LBYbcfhohwhwcwYxBENORT[TcTcOcEdB@IJNORJSU\UbUbJb@cBqtBCFBV_`celetet`tVuBH Qy)OPQ_QUQ_Q_aARB CiW]]HZ>[hqruw~xGxGsGiHT]^acjcrcr^rTsOXY]^aYbdkdqdqYqOr@CRUenort{tCtCoCeD29 #w?O?O:O0P9gpquvyqz}D}J}JrJhK9_b9r{|AHAPAP|PrQ9v?i =>~t~~Nc?deygN^N^I^?_vAEFIAJLSLYLYAYwZnqAJKNPWP_P_K_A`*, ZcdgipiyiydyZz, HQRVWZR[]d]l]lRlHm, Z2u;s1tvDuyvDvDEyvz2{.irsvxyIyItIjJW`aefiajlsl{l{a{W|"+ XabegngwgwbwXx+ NWX\]`XacjcrcrXrNs+ X1s :q0rtBswtBtBCutv1w-gpqtv}wGwGrGhH]fgklogpryrArAgA]B"2 R[\_ahaqaq\qRr2 BKLOQXQ^Q^L^B_2 tx2 f+g)4e*fgugkguguwchd+e' ajknpwqAqAlAbB QZ[^`g`m`m[mQn DH 0bkloqxrBrBmBcC0SV0d9C CB9CDRDHDRDRSODP9Q5 qz{~AHAQAQ|QrR be /s/SV/irsvxyIyItIjJ/b.mY7k-lm{mqm{m{}mnn.o*sadt}BDKDTDTTuU$(>{'='=#./(1$ *9S'JZJZEZ;[*X!S *Q RSaSWSaSacCTD!E )TWY`YiYiTiJj +A+*@*@&L+N' O9S'--=O3PO]fgjlsl{l{g{]|OIRSVX_XgXgSgIhO{DEHJQJWJWEW{XOjstwy@yFyFtFjGOXabegngtgtbtXuOCFOUXOb$Y9-W#XYgY]YgYgiMZN$O )CQXQ^Q^L^B_luvy|C|K|KwKmLXabegngvgvbvXwJSTWY`YfYfTfJgyBCFHOHUHUCUyVgpqtv}vCvCqCgDRUdg(6L[5K5K1L6M2 ]YsT[TaTaOaEb]|EFIKRKXKXFX|Y]qz{~@G@O@O{OqP]gpqtv}vCvCqCgD]JSTWY`YhYhThJi]oxy|~E~M~MyMoN]ajknpwppka@]S\]`bibqbq]qSr]FI]VY]~/oi8m.no}oso}o}ppq/r+T]^acjcpcp^pTqKTUXZaZgZgUgKh@IJMOVO^O^J^@_v@CELERER@RvSYbcfhohwhwcwYx~GHKMTM\M\H\~]pyz}FNNzNpObkloqxq@q@l@bAUXfi0&<[%;%;!.&0" J3HXHXCX9YJluvy|C|I|IwImJJ]fgjlslylygy]zJQZ[_`c[dfmfsfs[sQtJHKJXOi(MN~t~~^|O}~ RUW^WgWgRgHh|EFIKRKXKXFX|Yluvy{B{H{HvHlI`ijnorjsu|uBuBjB`CWZ0p #wGWGWBW8Xp gpqtv}wDwDrDhEp QZ[_`c[dfmfsfs[sQtp }FGKLOGPRYRaRaGa}bp pyz~BzCELERERzRpSp irswx{s|~E~M~MsMiNp enostwoxzAzIzIoIeJp W`adfmfsfsasWtp ENORT[TcTcOcEdp twp bMY'KL^T^^\yMz{:yQTV]VfVfQfGg:vADFMFSFSASwT:`ijnorjsu|uBuBjB`C:LUVZ[^V_ahapapVpLq:HIMNQIRT[TaTaIab:xABFGJBKMTM\M\B\x]:t}~BCF~GIPIXIX~XtY:fopsu|uBuBpBfC:T]^acjcrcr^rTs:CF:zT 9S'JZJZEZ;[T jstxy|t}@G@M@MuMkNT _himnqirt{tAtAiA_BT NWX\]`XacjcpcpXpNqT zCDHILDMOVO^O^D^z_T mvw{|w@BIBOBOwOmPT foptuxpy{B{J{JpJfKT bklpqtluw~wFwFlFbGT V_`deh`ikrkyky`yVzT GPQTV]VcVcQcGdT u~B D K D S D S S uT T d m n q s z s @ s @ n @ d A T T W T j Qy)OPQ_QUQ_Q_aARB CW)TWY`YiYiTiJjWzCDHILDMOVO\O\D\z]Wnwx|}@xACJCPCPxPnQW]fgklogpryrrg]@WIRSWX[S\^e^m^mSmInW|EFJKNFOQXQ^Q^F^|_Wu~CDGHJQJYJYYuZWqz{@C{DFMFUFU{UqVWenostwoxzAzHzHoHeIWV_`celerer`rVsWD M N Q S Z S b S b N b D c Ws | } @ B I B O B O } O s P Wd g Wt& #wO_O_J_@`&pyz}@G@L@L{LqM&P%[I.Y$Z[i[_[i[ikP\Q%R! yY\^e^n^nYnOo @IJMOVO[O[J[@\ )[dehjqjzjzez[{)LUVY[b[g[gVgLh)V3w)