a jC @sdZddlZddlZddlmZddlmZddlmZm Z ddl m Z ddl m Z mZmZmZmZmZmZmZddlmZddlZddlmZd d lmZmZmZm Z m!Z!d d l"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3d d l4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mee*e-e.fZ?ee*e-fZ@ee*e.fZAeejBe1e2ejCfZDeeejEeejFeejGeejHfZIGdddZJeeJeKfdddZLGdddeZMee&e&dddZNe&eeOeeeOe'feeOeKffdddZPeeDeDdddZQe eee ddd ZRe6eeOe6d!d"d#ZSeeOe fee6eeeOeDfeOeKeKeTeKeJe ee6d$ d%d&ZUe?eTeeDd'd(d)ZVeOeeOeeOeKfd*d+d,ZWd@e&e@e?eeOe fee6eeAee?eeAeeee@e?feeeOeeeAeeeeXeOfeee?eeeAee:eeeeKeeKd-ffe e6d.d/d0ZYeDe6eTeTeTeTe eDd1d2d3ZZd4d4d4d4ejEfe6e@e&eTeTeTeTeIe ee*ee*fd5 d6d7Z[Gd8d9d9Z\Gd:d;d;e5e\Z]Gdd?d?e7e\Z_dS)AzDistributed training with LightGBM and dask.distributed. This module enables you to perform distributed training with LightGBM on dask.Array and dask.DataFrame collections. It is based on dask-lightgbm, which was based on dask-xgboost. N) defaultdict)deepcopy)Enumauto)partial)AnyDictIterableListOptionalTupleTypeUnion)urlparse) LightGBMError_choose_param_value_ConfigAliases _log_info _log_warning)DASK_INSTALLEDPANDAS_INSTALLEDSKLEARN_INSTALLEDClientFutureLGBMNotFittedErrorconcat dask_Arraydask_array_from_delayeddask_bag_from_delayeddask_DataFrame dask_Seriesdefault_clientdelayed pd_DataFrame pd_Serieswait) LGBMClassifier LGBMModel LGBMRanker LGBMRegressor#_LGBM_ScikitCustomObjectiveFunction_LGBM_ScikitEvalMetricType_lgbmmodel_doc_custom_eval_note_lgbmmodel_doc_fit_lgbmmodel_doc_predict)DaskLGBMClassifierDaskLGBMRankerDaskLGBMRegressorc@s(eZdZedddZddddZdS) _RemoteSocketreturncCs@ttjtj|_|jtjtjd|jd|jdS)Nr)r)socketAF_INET SOCK_STREAM setsockopt SOL_SOCKET SO_REUSEADDRbind getsocknameselfrA3E:\soccer\ml_env\Lib\site-packages\lightgbm/dask.pyacquireDs z_RemoteSocket.acquireNcCs|jdSN)r7closer?rArArBreleaseJsz_RemoteSocket.release)__name__ __module__ __qualname__intrCrFrArArArBr3Csr3r4cCst}|}||fSrD)r3rC)sportrArArB _acquire_portNsrMc@s(eZdZdZeZeZeZeZdS) _DatasetNameszPlaceholder names used by lightgbm.dask internals to say 'also evaluate the training data'. Avoid duplicating the training data when the validation set refers to elements of training data. N) rGrHrI__doc__rTRAINSET SAMPLE_WEIGHT INIT_SCOREGROUPrArArArBrNTs rN)clientr5cCs|durtS|SdS)zChoose a Dask client to use. Parameters ---------- client : dask.distributed.Client or None Dask client. Returns ------- client : dask.distributed.Client A Dask client. N)r"rTrArArB_get_dask_client`s rV)rTworkersr5cCs~i}|D]}|jt|gddd||<qi}i}|D]4\}}|td|||<|td|||<q6||}||fS)aAssign an open port to each worker. Returns ------- worker_to_socket_future: dict mapping from worker address to a future pointing to the remote socket. worker_to_port: dict mapping from worker address to an open port in the worker's host. F)rWallow_other_workerspurerr)submitrMitemsoperator itemgettergather)rTrWZworker_to_futureworkerworker_to_socket_futureZworker_to_port_futureZ socket_futureZworker_to_portrArArB_assign_open_ports_to_workersss  ra)seqr5cCsxt|dtjrtj|ddSt|dttfrz3_remove_list_padding...rA)rqargrArArBrsrtz(_remove_list_padding..rA)rprArArB_remove_list_paddingsrv) lgbm_modelrequired_namesr5cCs6|D],}||jvri|j|<||jvri|j|<q|S)aAppend missing (key, value) pairs to a LightGBM model's evals_result_ and best_score_ OrderedDict attrs based on a set of required eval_set names. Allows users to rely on expected eval_set names being present when fitting DaskLGBM estimators with ``eval_set``. )Z evals_result_Z best_score_)rwrxZ eval_namerArArB_pad_eval_namess     ry) params model_factory list_of_partsmachineslocal_listen_port num_machines return_modeltime_out remote_socketkwargsr5c ( sT||||d} || t|t} tdd|D} tdd|D} d|dvrftdd|D}nd}d|dvrtd d|D}nd}d |dvrtd d|D}nd}td d |D}| dd| dd}d}d}d}d}|rtdd |D}tdd |D}g}g}|r*g}|r4g}| r>g}gt|D]}g}g}g}g}g}|D]P} | ds~qhr|}!n d|}!| d|}"|"t j ur| | d| | dn| |"d| |"d|!|vr| |!| d}#|#r<|#|t j ur.| | dn| |#|| d}$|$rz|$|t jurl| | d n| |$|| d}%|%rh|%|t jur| | dn| |%|qht|||||\}}}}}|r| t|t|fn |qJ|r| t||r*| t||rJ| t|qJfddt|D}&rpfdd|&D}rfdd|&D| d<|fi|}'|dur|zl| r|'j| | f||||||||d| n"|'j| | f||||||d| Wt|'dd r4|'jnt|'dd r2|'j0|rFt|'|d!}'|rP|'SdS)"N)r}r~rrcSsg|] }|dqS)datarArqxrArArBrsrtz_train_part..cSsg|] }|dqS)labelrArrArArBrsrtweightrcSsg|] }|dqS)rrArrArArBrsrtgroupcSsg|] }|dqS)rrArrArArBrsrt init_scorecSsg|] }|dqS)rrArrArArBrsrtcss|]}t|dgVqdS)eval_setN)lengetrrArArB rtz_train_part.. eval_nameseval_class_weightcss|]}|dduVqdS)eval_sample_weightNrrrArArBrrtcss|]}|dduVqdS)eval_init_scoreNrrrArArBrrtrZvalid_rrrrr eval_groupcsg|]}|vr|qSrArArqi)missing_eval_component_idxrArBrs;rtcsg|] }|qSrArAr)rrArBrs=rtcsg|] }|qSrArAr)rrArBrs?rt) sample_weightrrrrrrr)rrrrrrfitted_F)rx)update issubclassr)romaxpopranyrangerNrPappendextendrQrRrSrvrFfitgetattrZbooster_Z free_networkry)(rzr{r|r}r~rrrrrZnetwork_paramsZ is_rankerrrrrrZn_evalsZlocal_eval_setZlocal_eval_namesZlocal_eval_sample_weightZlocal_eval_init_scoreZlocal_eval_groupZhas_eval_sample_weightZhas_eval_init_scoreZevals_result_namesrx_ey_ew_e init_score_eg_epartZevals_result_namerZ eval_weightrrZeval_component_idxmodelrA)rrrrB _train_parts                           r)r is_matrixr5cCsX|}t|tjrT|r,|jddksHJn|jdksH|jddksHJ|}|S)Nr) to_delayedrgrhrishapendimflattentolist)rrpartsrArArB_split_to_partsks  r)r}worker_addressesr5c Cs|d}tt|t|kr.td|dtt}|D]$}|d\}}||t|q:i}|D]2}t|j}|std|d|| ||<qh|S)aCreate a worker_map from machines list. Given ``machines`` and a list of Dask worker addresses, return a mapping where the keys are ``worker_addresses`` and the values are ports from ``machines``. Parameters ---------- machines : str A comma-delimited list of workers, of the form ``ip1:port,ip2:port``. worker_addresses : list of str An iterable of Dask worker addresses, of the form ``{protocol}{hostname}:{port}``, where ``port`` is the port Dask's scheduler uses to talk to that worker. Returns ------- result : Dict[str, int] Dictionary where keys are work addresses in the form expected by Dask and values are a port for LightGBM to use. ,z Found duplicates in 'machines' (zA). Each entry in 'machines' must be a unique IP-port combination.:z/Could not parse host name from worker address '') splitrset ValueErrorraddrJrhostnamer) r}rZmachine_addressesZmachine_to_portaddresshostrLoutZ worker_hostrArArB_machines_to_worker_mapvs    r.)rTrrrzr{rrrrrrrrr eval_metriceval_atrr5cA sttfddtdD}tfddtdD}tdddhd }d|vr~td dd dd<td d D]&}|vrtd|d|qt|dd}t|dd}ddt||D}t |}|durt|dd}t |D]}||||d<q|durRt|dd}t |D]}||||d<q:|durt|dd}t |D]}||||d<qp|rt dd|D}t t }| rt t }| rt t } | rt t }!t|D]\}\}"}#|"j}$|"|ur$|#|ur$t |D]}%||%tjq nt|"dd}&t|#dd}'t |D]}(|(|}%|(|$krl|&|(})|'|(}*nd})d}*|(|kr||%|)g|*gfn,||%dd|)||%dd|*qD| rj| ||urt |D]}%||%tjqnnt| |dd}+t |D]T}(|(|$kr,|+|(},nd},|(|}%|(|krT||%|,gn||%d|,q| r| ||urt |D]}%|!|%tjqnnt| |dd}-t |D]T}(|(|$kr|-|(}.nd}.|(|}%|(|kr|!|%|.gn|!|%d|.q| r| ||urDt |D]}%| |%tjq*nnt| |dd}/t |D]T}(|(|$krt|/|(}0nd}0|(|}%|(|kr| |%|0gn| |%d|0q\q|D]X\}%}1|1||%d<| r||%||%d<| r|!|%||%d<| r| |%||%d <qt tt|}|}t||D]}2|2jd!kr<|2Sqd6d|>D}>|>d}?|stdD]}@|?j(|@dq|stdD]}@|?j(|@dqtd d7D]}@|?j(|@dq|?S)8aInner train routine. Parameters ---------- client : dask.distributed.Client Dask client. data : Dask Array or Dask DataFrame of shape = [n_samples, n_features] Input feature matrix. label : Dask Array, Dask DataFrame or Dask Series of shape = [n_samples] The target values (class labels in classification, real numbers in regression). params : dict Parameters passed to constructor of the local underlying model. model_factory : lightgbm.LGBMClassifier, lightgbm.LGBMRegressor, or lightgbm.LGBMRanker class Class of the local underlying model. sample_weight : Dask Array or Dask Series of shape = [n_samples] or None, optional (default=None) Weights of training data. Weights should be non-negative. init_score : Dask Array or Dask Series of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task), or Dask Array or Dask DataFrame of shape = [n_samples, n_classes] (for multi-class task), or None, optional (default=None) Init score of training data. group : Dask Array or Dask Series or None, optional (default=None) Group/query data. Only used in the learning-to-rank task. sum(group) = n_samples. For example, if you have a 100-document dataset with ``group = [10, 20, 40, 10, 10, 10]``, that means that you have 6 groups, where the first 10 records are in the first group, records 11-30 are in the second group, records 31-70 are in the third group, etc. eval_set : list of (X, y) tuples of Dask data collections, or None, optional (default=None) List of (X, y) tuple pairs to use as validation sets. Note, that not all workers may receive chunks of every eval set within ``eval_set``. When the returned lightgbm estimator is not trained using any chunks of a particular eval set, its corresponding component of ``evals_result_`` and ``best_score_`` will be empty dictionaries. eval_names : list of str, or None, optional (default=None) Names of eval_set. eval_sample_weight : list of Dask Array or Dask Series, or None, optional (default=None) Weights for each validation set in eval_set. Weights should be non-negative. eval_class_weight : list of dict or str, or None, optional (default=None) Class weights, one dict or str for each validation set in eval_set. eval_init_score : list of Dask Array, Dask Series or Dask DataFrame (for multi-class task), or None, optional (default=None) Initial model score for each validation set in eval_set. eval_group : list of Dask Array or Dask Series, or None, optional (default=None) Group/query for each validation set in eval_set. eval_metric : str, callable, list or None, optional (default=None) If str, it should be a built-in evaluation metric to use. If callable, it should be a custom evaluation metric, see note below for more details. If list, it can be a list of built-in metrics, a list of custom evaluation metrics, or a mix of both. In either case, the ``metric`` from the Dask model parameters (or inferred from the objective) will be evaluated and used as well. Default: 'l2' for DaskLGBMRegressor, 'binary(multi)_logloss' for DaskLGBMClassifier, 'ndcg' for DaskLGBMRanker. eval_at : list or tuple of int, optional (default=None) The evaluation positions of the specified ranking metric. **kwargs Other parameters passed to ``fit`` method of the local underlying model. Returns ------- model : lightgbm.LGBMClassifier, lightgbm.LGBMRegressor, or lightgbm.LGBMRanker class Returns fitted underlying model. Note ---- This method handles setting up the following network parameters based on information about the Dask cluster referenced by ``client``. * ``local_listen_port``: port that each LightGBM worker opens a listening socket on, to accept connections from other workers. This can differ from LightGBM worker to LightGBM worker, but does not have to. * ``machines``: a comma-delimited list of all workers in the cluster, in the form ``ip:port,ip:port``. If running multiple Dask workers on the same host, use different ports for each worker. For example, for ``LocalCluster(n_workers=3)``, you might pass ``"127.0.0.1:12400,127.0.0.1:12401,127.0.0.1:12402"``. * ``num_machines``: number of LightGBM workers. * ``timeout``: time in minutes to wait before closing unused sockets. The default behavior of this function is to generate ``machines`` from the list of Dask workers which hold some piece of the training data, and to search for an open port on each worker to be used as ``local_listen_port``. If ``machines`` is provided explicitly in ``params``, this function uses the hosts and ports in that list directly, and does not do any searching. This means that if any of the Dask workers are missing from the list or any of those ports are not free when training starts, training will fail. If ``local_listen_port`` is provided in ``params`` and ``machines`` is not, this function constructs ``machines`` from the list of Dask workers which hold some piece of the training data, assuming that each one will use the same ``local_listen_port``. c3s|]}|vVqdSrDrArqaliasrzrArBrrtz_train..r~c3s|]}|vVqdSrDrArrrArBr rtr}Z tree_learnerr)Zmain_param_namerz default_value>rZ data_parallelZvoting_parallelZvotingfeatureZfeature_parallelzParameter tree_learner set to z/, which is not allowed. Using "data" as defaultr num_threadsz Parameter z will be ignored.T)rrFcSsg|]\}}||dqS))rrrA)rqryrArArBrs+rtz_train..Nrrrcss|]}|djVqdS)rN) npartitionsrrArArBrBrtrrrrrrerrorcSsi|] }|j|qSrA)key)rqrrArArB rtz_train..zWorker z was not allocated eval_set data. Therefore evals_result_ and best_score_ data may be unreliable. Try rebalancing data across workers.rrrrip0z$Using passed-in 'machines' parameter)r}rz3Using passed-in 'local_listen_port' for all workerscSsh|]}t|jqSrArr)rqarArArB rtz_train..z'local_listen_port' was provided in Dask training parameters, but at least one machine in the cluster has multiple Dask worker processes running on it. Please omit 'local_listen_port' or pass 'machines'.csi|] }|qSrArA)rqr)r~rArBrrtz%Finding random open ports for workersrcSs$g|]\}}t|jd|qS)rr)rqZworker_addressrLrArArBrs rtcsfg|]^\}}jtfid|i||dd |d|k|gddd qS)rrxNF) r{rzr|r}r~rrrrrWrXrY)rZrr)rqr_r|) rTrr} master_workerr{rrzworker_address_to_port worker_ncoresr`rArBrss&  cSsg|] }|r|qSrArA)rqvrArArBrs,rttimeout))rrrrrrrrziprrrrlist enumeraterrrNrPrQrRrSr[mapr#computer&statuswho_hasnextiterresultZncoreskeysrrrrajoinr^ _other_params)ArTrrrzr{rrrrrrrrrrrrZlisten_port_in_paramsZmachines_in_paramsZallowed_tree_learnersZ param_aliasZ data_partsZ label_partsrZn_partsZ weight_partsrZ group_partsZinit_score_partsZn_largest_eval_partsZ eval_setsZeval_sample_weightsZ eval_groupsZeval_init_scoresZX_evalZy_evalZn_this_eval_partsZ parts_idxZ eval_x_partsZ eval_y_partsjrrZ eval_w_partsrZeval_init_score_partsrZ eval_g_partsrZe_setrZkey_to_part_dictrZ worker_maprrWr_Z has_eval_setrZ unique_hostsmsgZfutures_classifiersresultsrparamrA) rTrr~r}rr{rrzrrr`rB_trainsg                                                  r)rr raw_score pred_proba pred_leaf pred_contribrr5cKs|jddkrtg}n:|r:|j|f|||d|}n|j|f|||d|}t|trt|jdkr|t||jd}nt ||jdd}|S)Nr)rrr)indexZ predictions)rname) rrharray predict_probapredictrgr$rrr%)rrrrrrrrrArArB _predict_partAs4   rF) rrrTrrrrdtyperr5cKsvttttfstdt|tr@|jtf|||||d|j St|t r\|j } | dkr|rt|j t jrttf|d|ddd|} |} t| dddf} tttttdd d } | | }|jd }|jd}d d t| D}|j }t|D]D\}}t| D]0}t| |||||f|d}|||qqt|t jrjtt jdd}n$t|t jrtt jdd}nt j}g}t| D]0}|tt||||jd|f|dq|S| |dg!}ttf|||||d|}||}|jdf}i}t"|jd kr:||jd f7}nd |d<|j#|f|||d|St$dt%|j&ddS)aInner predict routine. Parameters ---------- model : lightgbm.LGBMClassifier, lightgbm.LGBMRegressor, or lightgbm.LGBMRanker class Fitted underlying model. data : Dask Array or Dask DataFrame of shape = [n_samples, n_features] Input feature matrix. raw_score : bool, optional (default=False) Whether to predict raw scores. pred_proba : bool, optional (default=False) Should method return results of ``predict_proba`` (``pred_proba=True``) or ``predict`` (``pred_proba=False``). pred_leaf : bool, optional (default=False) Whether to predict leaf index. pred_contrib : bool, optional (default=False) Whether to predict feature contributions. dtype : np.dtype, optional (default=np.float32) Dtype of the output. **kwargs Other parameters passed to ``predict`` or ``predict_proba`` method. Returns ------- predicted_result : Dask Array of shape = [n_samples] or shape = [n_samples, n_classes] The predicted values. X_leaves : Dask Array of shape = [n_samples, n_trees] or shape = [n_samples, n_trees * n_classes] If ``pred_leaf=True``, the predicted leaf of every tree for each sample. X_SHAP_values : Dask Array of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes] or (if multi-class and using sparse inputs) a list of ``n_classes`` Dask Arrays of shape = [n_samples, n_features + 1] If ``pred_contrib=True``, the feature contributions for each sample. ._extractrcSsg|]}gqSrArA)rq_rArArBrsrtz_predict..)valuermetarcrdZcscZ drop_axis)chunksrrz6Data must be either Dask Array or Dask DataFrame. Got rf)'allrrrrrgr Zmap_partitionsrvaluesrZ _n_classes_metarjrkrrrr#r rrJZ n_features_rrrrrZ csr_matrixrlZ csc_matrixrrrrZ map_blocksrmrnrG)rrrTrrrrrrZ num_classesZpredict_functionZdelayed_chunksZbagrpredsZnum_colsZnrows_per_chunkrZ pred_metar partitionrrZ concat_fnZ out_arraysZdata_rowZ predict_fnZpred_rowrZmap_blocks_kwargsrArArB_predicths)             rc@seZdZeedddZeeefdddZde e e e e ee e e ee eee e fe eee eee eeeefe ee e eee ee eeeeedffeddd d Ze e e d d d Zeede fede fddddZdS)_DaskLGBMModelr4cCs t|ddstdt|jdS)z:obj:`dask.distributed.Client`: Dask client. This property can be passed in the constructor or updated with ``model.set_params(client=client)``. rFz4Cannot access property client_ before calling fit().rU)rrrVrTr?rArArBclient_s z_DaskLGBMModel.client_cCs>|jdd}|jddt|j}|ddi||_|S)z4Remove un-picklable attributes before serialization.rTN)__dict__rrrrrT)r@rTrrArArB_lgb_dask_getstate s  z!_DaskLGBMModel._lgb_dask_getstateN.)r{Xrrrrrrrrrrrrrr5cKsts tdttttfs"td|d}|ddtft|j |||||||||| | | | | |d|}|j fi|| |||S)Nz"dask is required for lightgbm.daskrTrT)rTrrrzr{rrrrrrrrrrr) rrrrr get_paramsrrrVrTZ set_params_lgb_dask_copy_extra_params)r@r{rrrrrrrrrrrrrrrzrrArArB _lgb_dask_fits:   z_DaskLGBMModel._lgb_dask_fit)r{r5cCs@|}|dd|fi|}||||jdd|S)NrT)rrrr)r@r{rzrrArArB_lgb_dask_to_localEs   z!_DaskLGBMModel._lgb_dask_to_local)sourcedestr5cCsB|}|j}t||}|D]}t||||q(dSrD)rrrr differencesetattr)r r rz attributesZextra_param_namesrrArArBrMs z*_DaskLGBMModel._lgb_dask_copy_extra_params) NNNNNNNNNNN)rGrHrIpropertyrrrrrr r(_DaskMatrixLike_DaskCollectionr _DaskVectorLiker r strrdictr,rJr r  staticmethodrrArArArBrsL      3  rcsleZdZdZddddddddd d d d d d d d dddddeeeeeeeeee feee efeeeeeeeeeeee j j dfeeeeeedfddZejjZed\ZZZdeddddeede_eeefdddZd>eeeeeeeeeeefeeeeeeeeee efeeeeeedd ddZe j!d d!d"d#d$d%d&d%d'Zede"d(ee"d)dZede"d*ee"d+dZede"d,d-e#de_d?ee$eeee$e$e$ee%d/ d0d1Z&e'j!d2d d3d4d5d6d7e&_d@ee$eeee$e$e$ee%d/ d8d9Z(e'j!d:d d;d4d5d6d7e(_eddr?r@rArBr4cCs|SrDrCr?rArArBrDbszDaskLGBMRegressor.__getstate__) rrrrrrrrrrr5c Ks*|jft||||||||| d | |S)z;Docstring is inherited from the lightgbm.LGBMRegressor.fit.) r{rrrrrrrrr)r r*) r@rrrrrrrrrrrArArBres  zDaskLGBMRegressor.fitrErFrGrHrIrJrLrMeval_class_weight :eval_init_score :rNrOrPz**kwargs Other parameters passed through to ``LGBMRegressor.fit()``. Returns ------- self : lightgbm.DaskLGBMRegressor Returns self. FrQc Ks,tf||t|j||||||d |S)z?Docstring is inherited from the lightgbm.LGBMRegressor.predict. rrrTrrRrSrrrTr[rVrArArBrs  zDaskLGBMRegressor.predictrWrX!Dask Array of shape = [n_samples]*Dask Array of shape = [n_samples, n_trees]1Dask Array of shape = [n_samples, n_features + 1]rYcCs |tS)zCreate regular version of lightgbm.LGBMRegressor from the distributed version. Returns ------- model : lightgbm.LGBMRegressor Local underlying model. )r r*r?rArArBrUszDaskLGBMRegressor.to_local)NNNNNNN)FrNFFF)*rGrHrIrOrrJr\r rr+rrhr]r^rrr9r*r_rr`rarbrrDrrrr r r,rr.rercr-rdrrr/rUrerArAr;rBr2%s2      $$$   r2cs^eZdZdZddddddddd d d d d d d d dddddeeeeeeeeee feee efeeeeeeeeeeee j j dfeeeeeedfddZejjZed\ZZZdeddddeede_eeefdddZdr1z+Distributed version of lightgbm.LGBMRanker.rrrrrrNrrrrrrr r4r5c sD||_tjf||||||||| | | | | ||||||d|dS)z=Docstring is inherited from the lightgbm.LGBMRanker.__init__.r6Nr7r:r;rArBr9s0zDaskLGBMRanker.__init__r=r>r?r@rArBr4cCs|SrDrCr?rArArBrD szDaskLGBMRanker.__getstate__rr.)rrrrrrrrrrrrrr5c Ks0|jft||||||||| | | | d | |S)z8Docstring is inherited from the lightgbm.LGBMRanker.fit.) r{rrrrrrrrrrrr)r r))r@rrrrrrrrrrrrrrArArBr s$zDaskLGBMRanker.fitrErFrGrHrIrJrfrgzfeature_name :zCeval_at : list or tuple of int, optional (default=(1, 2, 3, 4, 5)) 8z2The evaluation positions of the specified metric. rPz**kwargs Other parameters passed through to ``LGBMRanker.fit()``. Returns ------- self : lightgbm.DaskLGBMRanker Returns self. FrQc Ks,tf||t|j||||||d |S)zs   (  L,   (   $   6 .      ' + ]M)