0Ph`.dZddlZddlmZmZddlmZddlmZddl Z ddl m Z ddl mZddlmZd d lmZmZmZd d lmZd d lmZmZd d lmZmZd dlmZd dlm Z m!Z!m"Z"m#Z#m$Z$ddl%m&Z&m'Z'm%Z%ddgZ(ddZ)GddeeZ*GddeeZ+dS)z> This file contains preprocessing tools based on polynomials. N)chain combinations)combinations_with_replacement)Integral)sparse)BSplinecomb) BaseEstimatorTransformerMixin _fit_context) check_array)Interval StrOptions) parse_version sp_version_weighted_percentile) FLOAT_DTYPES_check_feature_names_in_check_sample_weightcheck_is_fitted validate_data)_calc_expanded_nnz_calc_total_nnz_csr_polynomial_expansionPolynomialFeaturesSplineTransformerc t|j||}t|||}|dkrdS|dz }|}tjtjj} t ||| k} | r tjn tj} ||z }ttdkr|dz | kr| stdtj ||j j } tj || } tj |jjd| }t|j |j|j|jd| | ||| t#j| | |f|jjddz |f|j S)zDHelper function for creating and appending sparse expansion matricesrNr1.8.0aXIn scipy versions `<1.8.0`, the function `scipy.sparse.hstack` sometimes produces negative columns when the output shape contains `n_cols` too large to be represented by a 32bit signed integer. To avoid this error, either use a version of scipy `>=1.8.0` or alter the `PolynomialFeatures` transformer to produce fewer than 2^31 output features.shapedtype)rindptrrnpiinfoint32maxint64rr ValueErroremptydatar%r$rindicesr csr_matrix)Xinteraction_onlydeg n_featurescumulative_size total_nnz expanded_col max_indices max_indptr max_int32 needs_int64 index_dtype expanded_dataexpanded_indicesexpanded_indptrs a/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/preprocessing/_polynomial.py_create_expansionrA*s *:C@@I%j2BCHHLqt"KJ""&Ik:..:K)7"((rxK |#O]7++++ a ) + + , G   H9AFLAAAMxi{CCChQX^A%6kJJJO            (/:x~a 1$l3g   ceZdZUdZeeddddgdgdgedd hgd Zee d < dd ddddZ e dZ e dZ edZddZedddZdZfdZxZS)ra Generate polynomial and interaction features. Generate a new feature matrix consisting of all polynomial combinations of the features with degree less than or equal to the specified degree. For example, if an input sample is two dimensional and of the form [a, b], the degree-2 polynomial features are [1, a, b, a^2, ab, b^2]. Read more in the :ref:`User Guide `. Parameters ---------- degree : int or tuple (min_degree, max_degree), default=2 If a single int is given, it specifies the maximal degree of the polynomial features. If a tuple `(min_degree, max_degree)` is passed, then `min_degree` is the minimum and `max_degree` is the maximum polynomial degree of the generated features. Note that `min_degree=0` and `min_degree=1` are equivalent as outputting the degree zero term is determined by `include_bias`. interaction_only : bool, default=False If `True`, only interaction features are produced: features that are products of at most `degree` *distinct* input features, i.e. terms with power of 2 or higher of the same input feature are excluded: - included: `x[0]`, `x[1]`, `x[0] * x[1]`, etc. - excluded: `x[0] ** 2`, `x[0] ** 2 * x[1]`, etc. include_bias : bool, default=True If `True` (default), then include a bias column, the feature in which all polynomial powers are zero (i.e. a column of ones - acts as an intercept term in a linear model). order : {'C', 'F'}, default='C' Order of output array in the dense case. `'F'` order is faster to compute, but may slow down subsequent estimators. .. versionadded:: 0.21 Attributes ---------- powers_ : ndarray of shape (`n_output_features_`, `n_features_in_`) `powers_[i, j]` is the exponent of the jth input in the ith output. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 n_output_features_ : int The total number of polynomial output features. The number of output features is computed by iterating over all suitably sized combinations of input features. See Also -------- SplineTransformer : Transformer that generates univariate B-spline bases for features. Notes ----- Be aware that the number of features in the output array scales polynomially in the number of features of the input array, and exponentially in the degree. High degrees can cause overfitting. See :ref:`examples/linear_model/plot_polynomial_interpolation.py ` Examples -------- >>> import numpy as np >>> from sklearn.preprocessing import PolynomialFeatures >>> X = np.arange(6).reshape(3, 2) >>> X array([[0, 1], [2, 3], [4, 5]]) >>> poly = PolynomialFeatures(2) >>> poly.fit_transform(X) array([[ 1., 0., 1., 0., 0., 1.], [ 1., 2., 3., 4., 6., 9.], [ 1., 4., 5., 16., 20., 25.]]) >>> poly = PolynomialFeatures(interaction_only=True) >>> poly.fit_transform(X) array([[ 1., 0., 1., 0.], [ 1., 2., 3., 6.], [ 1., 4., 5., 20.]]) rNleftclosed array-likebooleanCFdegreer2 include_biasorder_parameter_constraintsr FT)r2rMrNc>||_||_||_||_dSNrK)selfrLr2rMrNs r@__init__zPolynomialFeatures.__init__s& 0( rBc|rtnttd|}tjfdt ||dzD}|r'tt d|}|S)Nrc3JK|]}t|VdSrQ)range).0ir r4s r@ z3PolynomialFeatures._combinations..sH# # +,DDz""A & &# # # # # # rBr)rcombinations_w_rr*r from_iterablerV)r4 min_degree max_degreer2rMstartiterr s` @r@ _combinationsz PolynomialFeatures._combinationss 0E||5EAz"""# # # # # 05eZ!^0L0L# # #     ;eJ//33T::D rBc (|rItfdttd|t|dzD}n>t |z|ddz }|dkr |dz }|t |z|ddz z}|r|dz }|S)zCalculate number of terms in polynomial expansion This should be equivalent to counting the number of terms returned by _combinations(...) but much faster. c4g|]}t|dS)Texactr )rWrXr4s r@ z8PolynomialFeatures._num_combinations..s8Qd333rBrTrcr)sumrVr*minr )r4r\r]r2rMrds` r@_num_combinationsz$PolynomialFeatures._num_combinationss  H"3q*#5#5s:z7R7RUV7VWWLL Z 74PPPSTTLA~~NZ!^Qd C C Ca GG   A LrBctjjjjj}tjfd|DS)z.Exponent for each of the inputs in the output.r4r\r]r2rMcFg|]}tj|jS)) minlength)r'bincountn_features_in_)rWcrRs r@rez.PolynomialFeatures.powers_.. s+ Q Q QqR[d&9 : : : Q Q QrB) rr`ro _min_degree _max_degreer2rMr'vstack)rRrs` r@powers_zPolynomialFeatures.powers_sx ))*''!2* *  y Q Q Q QL Q Q Q   rBc b|j}t|g}|D]x}tj|d}t |r6dfdt |||D}nd}||ytj|tS)aGet output feature names for transformation. Parameters ---------- input_features : array-like of str or None, default=None Input features. - If `input_features is None`, then `feature_names_in_` is used as feature names in. If `feature_names_in_` is not defined, then the following input feature names are generated: `["x0", "x1", ..., "x(n_features_in_ - 1)"]`. - If `input_features` is an array-like, then `input_features` must match `feature_names_in_` if `feature_names_in_` is defined. Returns ------- feature_names_out : ndarray of str objects Transformed feature names. r c3TK|]"\}}|dkr d||fzn|V#dS)rz%s^%dN)rWindexpinput_featuress r@rYz;PolynomialFeatures.get_feature_names_out..(sb   !S!88 >##6"<<<+C0       rB1r%) rtrr'wherelenjoinzipappendasarrayobject)rRr{powers feature_namesrowindsnames ` r@get_feature_names_outz(PolynomialFeatures.get_feature_names_outs(0~FF  ' 'C8C==#D4yy xx     %(c$i$8$8       & & & &z-v6666rBprefer_skip_nested_validationc t||dj\}}t|jtr5|jdkr|jst dd|_|j|_nt|jtj j rt|jdkr|j\|_|_t|jtr5t|jtr|jdkr|j|jkst d|jd|jdkr|jst dnt d |jd| ||j|j|j|j |_|jt!jt jjkrd |jd t!jjjd |d|jd|jd|jd|jd}t jt jkr1|jt!jt jjkr|dz }t || |d|j|j|j |_|S)al Compute number of output features. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) The data. y : Ignored Not used, present here for API consistency by convention. Returns ------- self : object Fitted transformer. T) accept_sparserzWSetting degree to zero and include_bias to False would result in an empty output array.r zhdegree=(min_degree, max_degree) must be non-negative integers that fulfil min_degree <= max_degree, got .zoSetting both min_degree and max_degree to zero and include_bias to False would result in an empty output array.zIdegree must be a non-negative int or tuple (min_degree, max_degree), got rkzGThe output that would result from the current configuration would have z. features which is too large to be indexed by zj. Please change some or all of the following: - The number of features in the input, currently n_features=z1 - The range of degrees to calculate, currently [z, z9] - Whether to include only interaction terms, currently z- - Whether to include a bias term, currently z Note that the current Python runtime has a limited 32 bit address space and that this configuration would have been admissible if run on a 64 bit Python runtime.)rr$ isinstancerLrrMr,rqrr collectionsabcIterablerrir2n_output_features_r'r(intpr*r%rr)r+ _n_out_full)rRr1y_r4msgs r@fitzPolynomialFeatures.fit5s$&dATBBBH : dk8 , ,# {a(9 . !D #{D   t{KO$< = = BEdkBRBRVWBWBW15 .D d.4+X66 t/:: $))$(888 &{&&& !Q&&t/@& D ";"""  #'"8"8!''!2* #9# #   "RXbg%6%6%: : :H0HH!wyy3HH HH % HH *.)9 HH 261F HH483DHHH 28##+rx/A/A/EEED S// ! 11!'!2* 2   rBc j t|t||dtdd}|j\}}t jtjj}tj |r|j dkr|j dkr9| | Sg}|jrB|tjt j|df|j|jdkr |j d kr||t+d |D}t-td |j|j dzD]B}t/||j||| }|%||||jdz }Ct3|d krtj|d f|j} nt5d|D} t6t9dkr|j|kr| rt=dtj||jd} n]tj |rO|j dkrD|j dkr9| | Stj |r| ||j|j |j|j} g} | D]} | r=d}| D]"}|d d |gf!|}#| |Atj"t j|jd df}| |tj| |j } nt j#||j$f|j|j%} |jr d| d d d f<d}nd }|j d kr| S|| d d |||zf<tMt-|||z}||z }||t-d |j dzD]}g}|d}t-|D]}||}|||jr|||dz||z z }||z|z }||krnBt j!| d d ||f|d d ||dzf| d d ||fd|}|||}|jdkr|j$|j}}|jrJt j#||f| j|j%}d|d d d f<| d d ||z dzd f|d d dd f<n#| d d ||z d f'}|} | S)a<Transform data to polynomial features. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) The data to transform, row by row. Prefer CSR over CSC for sparse input (for speed), but CSC is required if the degree is 4 or higher. If the degree is less than 4 and the input format is CSC, it will be converted to CSR, have its polynomial features generated, then converted back to CSC. If the degree is 2 or 3, the method described in "Leveraging Sparsity to Speed Up Polynomial Feature Expansions of CSR Matrices Using K-Simplex Numbers" by Andrew Nystrom and John Hughes is used, which is much faster than the method used on CSC input. For this reason, a CSC input will be converted to CSR, and the output will be converted back to CSC prior to being returned, hence the preference of CSR. Returns ------- XP : {ndarray, sparse matrix} of shape (n_samples, NP) The matrix of features, where `NP` is the number of polynomial features generated from the combination of inputs. If a sparse matrix is provided, it will be converted into a sparse `csr_matrix`. rJF)csrcsc)rNr%resetrrrr#rc30K|]}|jdVdS)rN)r$rWmats r@rYz/PolynomialFeatures.transform..s(!C!C3#)A,!C!C!C!C!C!CrBr )r1r2r3r4r5Nr}c3JK|]}|jjtjkVdSrQ)r/r%r'r)rs r@rYz/PolynomialFeatures.transform..s.RR# 1RX =RRRRRRrB1.9.2aIn scipy versions `<1.9.2`, the function `scipy.sparse.hstack` produces negative columns when: 1. The output shape contains `n_cols` too large to be represented by a 32bit signed integer. 2. All sub-matrices to be stacked have indices of dtype `np.int32`. To avoid this error, either use a version of scipy `>=1.9.2` or alter the `PolynomialFeatures` transformer to produce fewer than 2^31 output features)r%formatrrk)r$r%rNno)outcasting)(rrrr$r'r(r)r*rissparserrr transformtocsctocsrrMrr0onesr%rqrfrVrAr2rallrrrr,hstackr`multiply csc_matrixr-rrNlistcopy)rRr1 n_samplesr4r:to_stackr5r3expandedXP all_int32rcolumnscombiout_colcol_idxbias current_colindexr new_indexend feature_idxr^next_coln_XPn_XoutXouts r@rzPolynomialFeatures.transforms:    (    !" :HRX&&* ?1  I !(e"3"3!##~~aggii0066888H  %bgYN!'&R&R&RSS1$$)9A)=)="""!!C!C(!C!C!CCCOSD$455t7G!7KLL 9 9,%)%:)$3 'OOH---#x~a'88O8}}!!& 1~QWEEE RRRRRRR w!7!777/);;!<%R]8175III _Q  \ AH$5$5$:JQ:N:N>>!'')),,2244 4 _Q  Z --%++!%!6!. .LG% ) ))G#(DD"#AAAyL/":":7"C"CNN7++++!,RWagaj!_-E-EFFDNN4((((wag666<<>>BB $"2317$*B$  111a4  1$$ =>Bqqq+ j 888 9{K*,DEEFFE : %K LL % % %1d.233 " " Bi#(#4#4++K!+.E$$[111,M{Q!7% :L!LL*S058H;..K111eCi<(!!![;?::;qqq+h"667 $  #+KK  ---!!###/1Hf$98(&1D"#DAJ"$QQQv (9(;(;%;"`. .. versionadded:: 1.0 Parameters ---------- n_knots : int, default=5 Number of knots of the splines if `knots` equals one of {'uniform', 'quantile'}. Must be larger or equal 2. Ignored if `knots` is array-like. degree : int, default=3 The polynomial degree of the spline basis. Must be a non-negative integer. knots : {'uniform', 'quantile'} or array-like of shape (n_knots, n_features), default='uniform' Set knot positions such that first knot <= features <= last knot. - If 'uniform', `n_knots` number of knots are distributed uniformly from min to max values of the features. - If 'quantile', they are distributed uniformly along the quantiles of the features. - If an array-like is given, it directly specifies the sorted knot positions including the boundary knots. Note that, internally, `degree` number of knots are added before the first knot, the same after the last knot. extrapolation : {'error', 'constant', 'linear', 'continue', 'periodic'}, default='constant' If 'error', values outside the min and max values of the training features raises a `ValueError`. If 'constant', the value of the splines at minimum and maximum value of the features is used as constant extrapolation. If 'linear', a linear extrapolation is used. If 'continue', the splines are extrapolated as is, i.e. option `extrapolate=True` in :class:`scipy.interpolate.BSpline`. If 'periodic', periodic splines with a periodicity equal to the distance between the first and last knot are used. Periodic splines enforce equal function values and derivatives at the first and last knot. For example, this makes it possible to avoid introducing an arbitrary jump between Dec 31st and Jan 1st in spline features derived from a naturally periodic "day-of-year" input feature. In this case it is recommended to manually set the knot values to control the period. include_bias : bool, default=True If False, then the last spline element inside the data range of a feature is dropped. As B-splines sum to one over the spline basis functions for each data point, they implicitly include a bias term, i.e. a column of ones. It acts as an intercept term in a linear models. order : {'C', 'F'}, default='C' Order of output array in the dense case. `'F'` order is faster to compute, but may slow down subsequent estimators. sparse_output : bool, default=False Will return sparse CSR matrix if set True else will return an array. This option is only available with `scipy>=1.8`. .. versionadded:: 1.2 Attributes ---------- bsplines_ : list of shape (n_features,) List of BSplines objects, one for each feature. n_features_in_ : int The total number of input features. feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 n_features_out_ : int The total number of output features, which is computed as `n_features * n_splines`, where `n_splines` is the number of bases elements of the B-splines, `n_knots + degree - 1` for non-periodic splines and `n_knots - 1` for periodic ones. If `include_bias=False`, then it is only `n_features * (n_splines - 1)`. See Also -------- KBinsDiscretizer : Transformer that bins continuous data into intervals. PolynomialFeatures : Transformer that generates polynomial and interaction features. Notes ----- High degrees and a high number of knots can cause overfitting. See :ref:`examples/linear_model/plot_polynomial_interpolation.py `. Examples -------- >>> import numpy as np >>> from sklearn.preprocessing import SplineTransformer >>> X = np.arange(6).reshape(6, 1) >>> spline = SplineTransformer(degree=2, n_knots=3) >>> spline.fit_transform(X) array([[0.5 , 0.5 , 0. , 0. ], [0.18, 0.74, 0.08, 0. ], [0.02, 0.66, 0.32, 0. ], [0. , 0.32, 0.66, 0.02], [0. , 0.08, 0.74, 0.18], [0. , 0. , 0.5 , 0.5 ]]) r NrDrEruniformquantilerG>errorlinearconstantcontinueperiodicrHrIrJn_knotsrLknots extrapolationrMrN sparse_outputrOrrTF)rrrMrNrch||_||_||_||_||_||_||_dSrQr)rRrrLrrrMrNrs r@rSzSplineTransformer.__init__s>   *( *rB c|dkradtjdd|tjz}tj|d}ntjfd|D}ntt dddndk}tj|d}tj|d}tj|||d tj }|S) aCalculate base knot positions. Base knots such that first knot <= feature <= last knot. For the B-spline construction with scipy.interpolate.BSpline, 2*degree knots beyond the base interval are added. Returns ------- knots : ndarray of shape (n_knots, n_features), dtype=np.float64 Knot positions (points) of base interval. rdrr)r^stopnumr%Naxisc2g|]}t|Srxr)rW percentiler1 sample_weights r@rez>SplineTransformer._get_base_knot_positions..s5&-Q zJJrBT)r^rrendpointr%)r'linspacefloat64rarraysliceaminamax)r1rrr percentilesmaskx_minx_maxs` ` r@_get_base_knot_positionsz*SplineTransformer._get_base_knot_positionss J   aWBJ!!!K$ a1===*5,9+@5tQ'''mVWFWDGAdG!,,,EGAdG!,,,EKj E rBc^t|d|jdjjd}t ||}g}t |jD]?}t |dz |jzD]"}|||d|#@tj |tS)aGet output feature names for transformation. Parameters ---------- input_features : array-like of str or None, default=None Input features. - If `input_features` is `None`, then `feature_names_in_` is used as feature names in. If `feature_names_in_` is not defined, then the following input feature names are generated: `["x0", "x1", ..., "x(n_features_in_ - 1)"]`. - If `input_features` is an array-like, then `input_features` must match `feature_names_in_` if `feature_names_in_` is defined. Returns ------- feature_names_out : ndarray of str objects Transformed feature names. rorr_sp_r}) r bsplines_rpr$rrVrorMrr'rr)rRr{ n_splinesrrXjs r@rz'SplineTransformer.get_feature_names_outs( .///N1%'-a0 0~FF t*++ D DA9q=4+<<== D D$$q(9%B%Bq%B%BCCCC Dz-v6666rBrc Bt|dddd}|t|||j}|j\}}t jt r$|jj|}ntjtj }|jddkrtd |jd |krtd tj tj|d dkstd jr0t t#dkrtdt d|jd}jdkr&|jkrtd|djdjdkr|jzd z }n|d z }j} ||z} jdkrD|d|dz } tj|| d z d| z ||d | d z| zfn|d |dz } |d|dz } tjtj|d| | zz |d| z | |tj|d| z|d| | zz| ftj|tj jdkr"tjd| ddffjdvfdt1|D}|_| |d jz zz _S)aECompute knot positions of splines. Parameters ---------- X : array-like of shape (n_samples, n_features) The data. y : None Ignored. sample_weight : array-like of shape (n_samples,), default = None Individual weights for each sample. Used to calculate quantiles if `knots="quantile"`. For `knots="uniform"`, zero weighted observations are ignored for finding the min and max of `X`. Returns ------- self : object Fitted transformer. TFr )rrensure_min_samples ensure_2dNr})rrrrz.Number of knots, knots.shape[0], must be >= 2.rz)knots.shape[1] == n_features is violated.rz(knots must be sorted without duplicates.r"zOOption sparse_output=True is only available with scipy>=1.8.0, but here scipy==z is used.rz7Periodic splines require degree < n_knots. Got n_knots=z and degree=rr)r)rrc^g|])}tjdd|fj*S)N) extrapolate)rconstruct_fastrL)rWrXcoefrrrRs r@rez)SplineTransformer.fit..sT     "aaad T4;K      rB)rrr%r$rrstrrrrr'rr,rdiffrrrrrLr_reye concatenaterVrrMn_features_out_)rRr1rrrr4 base_knotsrrrLn_outperioddist_mindist_maxbsplinesr rrs` @@@r@rzSplineTransformer.fit9s,          $0QQQM : dj# & & M6644gvgqqqj)9":;;D(,DD        :&&     "$zQ9J5J'KK rBc  t|t||ddd}|j\}}|jdjjd |j}t tdk}|r|j}d|jdj i}n(|jo|jdj }t}|j |d|j z zz}|j tvr|j } n tj} |rg} ntj||f| |j} t'|D]} |j| } |jd vr|jd krk| jj| jz dz }| j| j|d d | f| j| jz | j|| j| jz zz}n |d d | f}|rqt1j|| j| jfi|}|jd krF|}|d d d |fxx|d d | d fz cc<|d d d | f}n!| || d d | z| dz zf<n| j|| j| dz }}| || |}}||d d | fk|d d | f|kz}|r|}|d d | f}| j|j||<t1j|| j| j}tj|r|}d||d d f<n#| ||| f| || z| dz zf<|jd kr{|r+tjtj|js=|sJtjtj| d d | z| dz zfrt?d n|jdkr|d d | f|k}tj|rB|r&|}|d |||d |f<n|d || || z| z|zf<|d d | f|k}tj|rL|r)|}|| d ||| d f<nY|| d | || dz z|z | dz zf<n6|jdkr*| |d| |d}}|dkr|dz }t'|D]}|d d | f|k}tj|rJ||||| f|z ||zz}|r|}||||f<n || || z|zf<|d d | f|k}tj|ra dz |z }||||| f|z ||zz}|r+|}|d d d f||||dzf<|| || z|zf<|r)| }| !||rtj"tj#j$}d}| D]}||j%j tj#kz} t tdkr|j |kr|rt?dtMj'| d} n|jrtMj(| } |j r| S fdt'| jdD}| d d |fS)aTransform each feature data to B-splines. Parameters ---------- X : array-like of shape (n_samples, n_features) The data to transform. Returns ------- XBS : {ndarray, sparse matrix} of shape (n_samples, n_features * n_splines) The matrix of features, where n_splines is the number of bases elements of the B-splines, n_knots + degree - 1. FT)rrrrrz1.10.0r)r%rN)rrrrNrz1X contains values beyond the limits of the knots.rr)nuraIn scipy versions `<1.9.2`, the function `scipy.sparse.hstack` produces negative columns when: 1. The output shape contains `n_cols` too large to be represented by a 32bit signed integer. . All sub-matrices to be stacked have indices of dtype `np.int32`. To avoid this error, either use a version of scipy `>=1.9.2` or alter the `SplineTransformer` transformer to produce fewer than 2^31 output featuresr)rc,g|]}|dzzdk|S)rrrx)rWrrs r@rez/SplineTransformer.transform..s-RRRQ!a%99LPQ9Q9Qq9Q9Q9QrB))rrr$rrprLrrrrrrrMr%rr'rzerosrNrVrtsizekr design_matrixtolilranyisnanr.r,rrr(r)r*r/rrr0)!rRr1rr4rL scipy_1_10 use_sparsekwargs_extrapolaterr% output_listXBSrXsplnx XBS_sparsexminxmaxf_minf_maxrmask_invfp_minfp_maxr linear_extrrr:rrr/rs! @r@rzSplineTransformer.transforms{  $et T T T ! :N1%'-a0   =#:#::   (+J"/1B1N!O  +QDN14E4Q0QJ!% $zQ9J5J'KK 7l " "GEEJE  NKK(Iu-U$*MMMCz""G /G /A.#C!%FFF%33  SU*Q.Ace !!!Q$#%,(>a35</(AA!!!Q$A M!(!635#%""+=""J)Z77 &0%5%5%7%7 "111gvg:...*QQQ[2II...%/8VG8 %< FIc!ffCA Mq1u .ABBCC U6]CE6'A+,>d"s4yy##d))u!!!Q$AaaadGtO<Y $uH!!!Q$ A#&% "4AhK!(!6q#%!G!GJ vh''4%/%5%5%7%7 23 8QQQ;/ILQtUVwZCq9}!a%91DEEF!W,,26"(:?*C*C#D#D"QQQYAEY;N(O%O!PQQ %K#z11 Aw~6$<< !%/%5%5%7%7 49'6'N 4&=11QV#VGQD1y=Q]V5K"LLMAw~6$<< ,!,%/%5%5%7%7 5:F788_ 4&>22 "6'((O !ey069q1u >QRT #x//"%Ta##dq///Q;;aKFvGGAQQQT7T>Dvd||G&+Ah!D!G*t2Cvay1P&P %G)3)9)9););J2=JtQw//;FCa)ma&7 78QQQT7T>Dvd||G%MA-&+Ah!D!G*t2Cvay1P&P %G)3)9)9););J:Eaaag:NJtQQY77;FCa)ma&7 78 /'--// "":...  ) **.II" ; ;S[."(:: ]73333(9445!N- E:::CC   )#C((C   #JSRRR% ! "5"5RRRGqqq'z? "rB)rr)rrNrQ)NN)rrrrrrrrOrrrSrrrrrrrxrBr@r r RsxxxvHXq$v>>>?8Haf===>*i455|D JNNN O O # *c3Z(()# $ $D   +  +++++&,,,\,\7777<\555DDD65DLZ#Z#Z#Z#Z#rB)r),rr itertoolsrrrrZnumbersrnumpyr'scipyrscipy.interpolater scipy.specialr baser r rutilsrutils._param_validationrr utils.fixesrr utils.statsrutils.validationrrrrrrrr__all__rArr rxrBr@r?s ))))))))GGGGGG%%%%%%@@@@@@@@@@::::::::33333333......  ::::zhhhhh)=hhhVH #H #H #H #H #(-H #H #H #H #H #rB