`L iߴ 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+y)z> This file contains preprocessing tools based on polynomials. N)chain combinations)combinations_with_replacement)Integral)sparse)BSpline)comb) 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|||}|dk(ry|dz }|}tjtj j } t ||| kD} | rtjntj } tj||jj} tj|| } tj|jjd| }t|j|j|j|jd| | ||| tj| | |f|jjddz |f|jS)zDHelper function for creating and appending sparse expansion matricesrNrshapedtype)rindptrrnpiinfoint32maxint64emptydatar"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 g/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/sklearn/preprocessing/_polynomial.py_create_expansionr=*s< *:C@I%j2BCHLq"KJ"&&Ik:.:K)"((rxxKHH9AFFLLAMxxi{ChhQXX^^A%6kJO           (/:xx~~a 1$l3gg ceZdZUdZeeddddgdgdgedd hgd Zee d < dd d dddZ e dZ e dZ edZddZed ddZdZfdZxZS)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-likebooleanCFdegreer. include_biasorder_parameter_constraintsFT)r.rIrJc<||_||_||_||_yNrG)selfrHr.rIrJs r<__init__zPolynomialFeatures.__init__s" 0( r>c|rtnttd|}tjfdt ||dzD}|rtt d|}|S)Nrc3BK|]}t|ywrM)range).0ir r0s r< z3PolynomialFeatures._combinations..s"# +,Dz"A &# sr)rcombinations_w_rr'r from_iterablerR)r0 min_degree max_degreer.rIstartiterr s` @r< _combinationsz PolynomialFeatures._combinationsse 0|5EAz"""# 05eZ!^0L#   eJ/3T:D r>c |rGtttd|t||dzDcgc]}t ||dc}}n5t ||z|ddz }|dkDr|dz }|t ||z|ddz z}|r|dz }|Scc}w)zCalculate number of terms in polynomial expansion This should be equivalent to counting the number of terms returned by _combinations(...) but much faster. rT)exactr)sumrRr'minr )r0rXrYr.rIrTrds r<_num_combinationsz$PolynomialFeatures._num_combinationss #3q*#5s:z7RUV7VWQd3L Z 74PSTTLA~NZ!^Qd Ca GG  A LsBc 6t||j|j|j|j|j |j }tj|Dcgc]#}tj||j%c}Scc}w)z.Exponent for each of the inputs in the output.r0rXrYr.rI) minlength) rr\n_features_in_ _min_degree _max_degreer.rIr$vstackbincount)rNrcs r<powers_zPolynomialFeatures.powers_s ))**''''!22** * yyDP QqR[[d&9&9 : Q  Qs'(Bc 8|j}t|g}|D]`}tj|d}t |r(dj fdt |||D}nd}|j|btj|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 c3LK|]\}}|dk7r d||fzn|yw)rz%s^%dN)rSindexpinput_featuress r<rUz;PolynomialFeatures.get_feature_names_out..sD  !S!8 >##6"<<+C01 s!$1r") rlrr$wherelenjoinzipappendasarrayobject)rNrspowers feature_namesrowindsnames ` r<get_feature_names_outz(PolynomialFeatures.get_feature_names_outs(0~F  'C88C=#D4yxx  %(c$i$8     & 'zz-v66r>prefer_skip_nested_validationc8t||dj\}}t|jtr@|jdk(r|j s t dd|_|j|_nt|jtjjrt|jdk(r|j\|_|_t|jtrBt|jtr(|jdk\r|j|jkst d|jd|jdk(r0|j s$t dt d |jd|j||j|j|j|j |_|jt!j"t j$j&kDrd |jd t!j$j(j*d |d|jd|jd|jd|j d}t j$t j,k(r?|jt!j"t j.j&kr|dz }t ||j|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 rdzGThe 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! isinstancerHrrI ValueErrorrgrh collectionsabcIterablerwrbr.n_output_features_r$r%intpr'r"rr&r( _n_out_full)rNr-y_r0msgs r<fitzPolynomialFeatures.fit#s$&dATBHH : dkk8 ,{{a(9(9 . !D #{{D  t{{KOO$<$< =#dkkBRVWBW15 .D d.4++X6t//:$$)$$(8(88 5{{m1& !!Q&t/@/@ D 1;;-q"  #'"8"8!''''!22** #9#   " "RXXbgg%6%:%: :0012!wwy3345 =!%%&b)9)9(:;1151F1F0GH3373D3D2EQH 288#++rxx/A/E/EED S/ ! 11!''!22** 2  r>c  t|t||dtdd}|j\}}t j tj j}tj|r|jdk(r|jdkDr-|j|jjSg}|jrE|j!tj"t j$|df|j&|j(dkr |jd kDr|j!|t+d |D}t-td |j(|jdzD]B}t/||j0||| }| |j!|||jdz }Dt3|d k(r%tj"|d f|j&} | St5d|D} t6t9dkr|j:|kDr | r t=dtj>||j&d} | Stj|rK|jdk(r<|jdkr-|j|jjStj|r|jA||j(|j|j0|j} g} | D]} | r4d}| D]}|d d |gfjC|}| j!|9tjDt j$|jd df}| j!|tj>| |j&j} | St jF||jHf|j&|jJ} |jr d| d d d f<d}nd }|jd k(r| S|| d d |||zf<tMt-|||z}||z }|j!|t-d |jdzD]}g}|d}t-|D]}}||}|j!||j0r|||dz||z z }||z|z }||krn;t jB| d d ||f|d d ||dzf| d d ||fd|}|j!||}|j(dkDr|jH|j:}}|jrRt jF||f| j&|jJ}d|d d d f<| d d ||z dzd f|d d dd f<n| d d ||z d fjO}|} | 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`. rFF)csrcsc)rJr"resetrrrr rc3:K|]}|jdyw)rN)r!rSmats r<rUz/PolynomialFeatures.transform..s!C3#))A,!Csr )r-r.r/r0r1Nruc3jK|]+}|jjtjk(-ywrM)r+r"r$r&rs r<rUz/PolynomialFeatures.transform..s#R# 1 1RXX =Rs131.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"formatrrd)r!r"rJno)outcasting)(rrrr!r$r%r&r'rissparserrh transformtocsctocsrrIrzr,onesr"rgr_rRr=r.rwallrrrrhstackr\multiply csc_matrixr)rrJlistcopy)rNr- n_samplesr0r6to_stackr1r/expandedXP all_int32rcolumnscombiout_colcol_idxbias current_colindexr new_indexend feature_idxrZnext_coln_XPn_XoutXouts r<rzPolynomialFeatures.transforms:    (  !" :HHRXX&** ??1 !((e"3!#~~aggi06688H  %%bggYN!''&RS1$)9)9A)="!!C(!CCOSD$4$45t7G7G!7KL 9,%)%:%:)$3 'OOH-#x~~a'88O 98}!&& 1~QWWEb [ RRR w!77//);!$R]]81775I| {__Q AHH$5$:J:JQ:N>>!''),224 4 __Q --%++++!%!6!6!.. .LG% )G#(D"#AyL/":":7"CDNN7+!,,RWWaggaj!_-EFDNN4( )wagg6<<>BR K $"2"23177$**B$  1a4  1$ =>Bq+ j 888 9{K*,DEFE : %K LL %1d..23 " Bi#(#4+K!+.E$$[1,,{Q!7% :L!LL*S058H;.KK1eCi<(![;?::;q+h"667 $  #+K!+$  -!- "0!##//1H1Hf$$88(&1D"#DAJ"$Qv (9(;%;"cFt|}d|j_|S)NT)super__sklearn_tags__ input_tagsr)rNtags __class__s r<rz#PolynomialFeatures.__sklearn_tags__:s!w')!% r>)r rM)__name__ __module__ __qualname____doc__rrrrKdict__annotations__rO staticmethodr\rbpropertyrlrr rrr __classcell__)rs@r<rrUs\~Haf=|L&K" c3Z() $D,1C  6    %7N5^6^@tlr>c eZdZUdZeedddgeedddgeddhd gehd gd ged d hgd gdZee d< ddddd dddZ e ddZ ddZ edddZdZy)ranGenerate univariate B-spline bases for features. Generate a new feature matrix consisting of `n_splines=n_knots + degree - 1` (`n_knots - 1` for `extrapolation="periodic"`) spline basis functions (B-splines) of polynomial order=`degree` for each feature. In order to learn more about the SplineTransformer class go to: :ref:`sphx_glr_auto_examples_applications_plot_cyclical_feature_engineering.py` Read more in the :ref:`User Guide `. .. 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. .. 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 Nr@rAruniformquantilerC>errorlinearconstantcontinueperiodicrDrErFn_knotsrHknots extrapolationrIrJ sparse_outputrKrTF)rrrIrJrcf||_||_||_||_||_||_||_yrMr)rNrrHrrrIrJrs r<rOzSplineTransformer.__init__s8   *( *r>c |dk(rvdtjdd|tjz}|tj||d}|Stj|Dcgc]}t |||c}}|S| t dddn|dkD}tj||d}tj||d}tj|||dtj }|Scc}w) 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)rZstopnumr"NaxisT)rZrrendpointr") r$linspacefloat64 percentilearrayrsliceaminamax) r-rr sample_weightpercentile_rankspercentile_rankmaskx_minx_maxs r<_get_base_knot_positionsz*SplineTransformer._get_base_knot_positionss J "R[[aWBJJ&  $ a)9B4 10@+-Q O0 ,9+@5tQ'mVWFWDGGAdG!,EGGAdG!,EKKjj E /sC.c^t|d|jdjjd}t ||}g}t |j D];}t |dz |jzD]}|j||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. rfrr_sp_ru) r bsplines_rkr!rrRrfrIrzr$r{r|)rNrs n_splinesr~rTjs r<rz'SplineTransformer.get_feature_names_outs( ./NN1%''--a0 0~F t**+ DA9q=4+<+<<= D$$q(9':$qc%BC D Dzz-v66r>rc 6t||dddd}|t|||j}|j\}}t |j t r*|j||j|j |}nt|j tj}|jddkr td |jd |k7r td tjtj|d dkDs td |jd}|jdk(r+||j krtd|d|j d|jdk7r||j zd z }n|d z }|j } ||z} |jdk(r5|d|dz } tj"|| d z d| z ||d | d z| zf} nv|d |dz } |d|dz }tj"tj$|d| | zz |d| z | |tj$|d|z|d| |zz| f} tj&|tj}|jdk(r tj(||d| ddff}|jdv}t+|Dcgc],}t-j.| dd|f||j |.}}||_| |d |j2z zz |_|Scc}w)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_2dNru)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.rz7Periodic splines require degree < n_knots. Got n_knots=z and degree=rr)r)rr) extrapolate)rrr"r!rrstrrrrr$rrrdiffrrHr_reye concatenaterRrconstruct_fastrrIn_features_out_)rNr-rrrr0 base_knotsrrrHn_outperiodrdist_mindist_maxcoefrrTbspliness r<rzSplineTransformer.fit&sL,        $0QM : djj# &664<>4gvgqj)9":;D((,DD :&    " "ad T4;;K   "$zQ9J9J5J'KK  s1Lc t|t||ddd}|j\}}|jdjjd}|j }t tdk\}|r(|j}d|jdji}n2|jxr|jdj }t}|j|d|jz zz} |jtvr |j} ntj } |rg} n$tj"|| f| |j$} t'|D]} |j| }|j(d vr:|j(d k(r|j*j,|j.z dz }|j*|j.|d d | f|j*|j.z |j*||j*|j.z zz}n |d d | f}|rwt1j2||j*|j.fi|}|j(d k(rP|j5}|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 | fj7}|j*|j ||<t1j2||j*|j.}tj8|r7|j5}d||d d f<n|||| f || |z| dz|zf<|j(d k(r}|r2tj8tj:j<s>|stj8tj: d d | |z| dz|zfrt?d |j(dk(r|d d | fk}tj8|r4|rj5}d |||d |f<nd | || |z| |z|zf<|d d | fkD}tj8|rN|r j5}| d ||| d f<n,| d  || dz|z|z | dz|zf<n|j(dk(r|d|d}}|dkr|dz }t'|D]}|d d | f|k}tj8|r=|||| f|z ||zz}|rj5}||||f<n | || |z|zf<|d d | f|kD}tj8|s|dz |z }|||| f|z ||zz}|r$j5}|d d d f||||dzf<| || |z|zf<|sjA} jC||rtjDtjFjH}d} D],}||jJjtjFk(z}.t tdkr|j|kDr |r t?dtMjN| d} n!|jrtMjP } |jr St' jdDcgc]}|dz|zdk7s|} }| d d | fScc}w)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"rJ)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)r))rrr!rrkrHrrrrrrrIr"rr$rzerosrJrRrtsizekr design_matrixtolilranyisnanr*rrrzr%r&r'r+rrr,)!rNr-rr0rrH scipy_1_10 use_sparsekwargs_extrapolaterr" output_listXBSrTsplnx XBS_sparsexminxmaxf_minf_maxrmask_invfp_minfp_maxr linear_extrrr6rrr+s! r<rzSplineTransformer.transforms  $et T ! :NN1%''--a0   =#::  ++J"/1B1N1N!O ++QDNN14E4Q4Q0QJ!% $$zQ9J9J5J'KK 77l "GGEJJE K((Iu-U$**MCz"G /A..#C!!%FF%%3  SUU*Q.Acee !Q$#%%,(>a355</(A!Q$A!(!6!6355#%%"+="J))Z7 &0%5%5%7 "1gvg:.*Q[2II.%/8VG8 %< FI!fCA Mq1u .ABBC UU6]CEE6'A+,>d"4y#d)u!Q$AadGtO< $uH!Q$ A#&%% "4AhK!(!6!6q#%%!GJ vvh'%/%5%5%7 23 8Q;/ILQtUVwZCq9}!a%91DEEF!!W,266"((:??*C#D"QYAEY;N(O%O!PQ%K##z1 Aw~66$<!%/%5%5%7 49'6N 4&=1QV#VQD1y=Q]V5K"LLMAw~66$<!%/%5%5%7 5:F78_ 4&>2 "6'(O !ey069q1u >QRT ##x/"%Ta#dq/Q;aKFvGAQT7T>Dvvd|&+Ah!D!G*t2Cvay1P&P %)3)9)9);J2=JtQw/;FCa)ma&7 78QT7T>Dvvd|%MA-&+Ah!D!G*t2Cvay1P&P %)3)9)9);J:Eag:NJtQQY7;FCa)ma&7 78)G,'--/ "":.OG /R  *..II" ;S[[.."((::  ;]733((94 N-- E:C   ##C(C   J#( ! "5RQ!a%99LPQ9QqRGRq'z? "Ss \<-\<)r) rNrM)NN)rrrrrrrrKrrrOrrrr rrrpr>r<rr@swtXq$v>?Haf=>i45|D N O # c3Z()# $D +  +&,,\7<5~6~@Z#r>)r),rr itertoolsrrrrVnumbersrnumpyr$scipyrscipy.interpolater scipy.specialr baser r r utilsrutils._param_validationrr utils.fixesrr utils.statsrutils.validationrrrrrrrr__all__r=rrrpr>r<r6s)G%@@:3.  (Vh)=hVA #(-A #r>