-i", SrSSKrSSKrSSKJr SSKJrJr SSKrSSK J r SSK J r SSKJr SSKJr SS KJrJr SS KJr SS KJrJrJr SS KJr S r\"0S\"\SSSS9/_S\"\SSSS9/_S\"\SSSS9/_S\"\SSSS9/_S\"\SSSS9/_S\"\SSSS9/_S\"\SSSS9/_SSS/_S\"\SSSS9/_S\"\SSSS9/_SS/_S \"\SSSS9SS/_S!\"\SSSS9SS/_S"S/_S#S#/_S$S/_S%S&9SjSSSSSSS(S)S%S*S)S%SS%S+.S,jj5r\"\"\SSSS9/\"\SSSS9/\"\SSSS9/\"\SSSS9/\"\SSSS9/S/S/\"S-S.15S/S/S#/S/. S%S&9SjS0SS1S%S2S-S2SS3.S4jj5r\"\"\SSSS9/S#/S5.S%S&9SkSS6.S7jj5r \"\"\SSSS9/\"\SSSS9/\"\SSSS9/\"\SSSS9/\"\SSSS9/\"\SSSS9S/\"\SSSS9/\"\SSSS9/S/S/S#/S8. S%S&9SlS9SS*SS:S*S%S2SS;. S<jj5r!\"\"\SSSS9\"/S/\"\SSSS9S/S#/\"\SSSS9/S=.S%S&9SmS%SSS>S?.S@jj5r#\"\"\SSSS9\"/S/\"\SSSS9S/S#/SA.S%S&9SmS%SSSB.SCjj5r$\"\"\SSSS9S/\"\SSSS9/\"\SSSS9SS/\"\SSSS9S/\"/S/S#/S/SD.S%S&9SnSS)SES%SS2SF.SGjj5r%\"\"\SSSS9/\"\S0SSS9/\"\S*SSS9/S#/SH.S%S&9SoS*SSI.SJjj5r&\"\"\SSSS9/\"\SSSS9/S#/SK.S%S&9SmS*SSI.SLjj5r'\"\"\SSSS9/\"\SSSS9/S#/SK.S%S&9SmS*SSI.SMjj5r(\"\"\SSSS9/\"\SSSS9/\"\SSSS9/\"\SSSS9/S#/SN.S%S&9SlS9S:SSO.SPjj5r)\"\"\SSSS9/\"\SSSS9/\"\SSSS9/\"\SSSS9/S#/SQ.S%S&9SS6.SRj5r*\"\"\SSSS9/\"\SSSS9/S#/SS.S%S&9SoSS6.STjj5r+\"\"\SSSS9/S#/SU.S%S&9SS6.SVj5r,\"\"\SSSS9/\"\SSSS9/S/\"\SSSS9/\"\SSSS9/\"1SWk5S/S#/SX.S%S&9SpSYS2SZS[SSS\.S]jj5r-\"\"\SSSS9/\"\SSSS9/S#/S/S^.S%S&9SmS*SS2S_.S`jj5r.\"\"\SSSS9/\"\SSSS9/S#/SK.S%S&9SmS*SSI.Sajj5r/\"SS/\"\SSSS9/\"\SSSS9/\"\SSSS9/\"\SSSS9/S/S#/Sb.S%S&9SS)S'SScS%SSb.Sdj5r0SqSejr1\"\"/\"\SSSS9/\"\SSSS9/\"\SSSS9/\"\SSSS9/S/S#/Sf.S%S&9S*S9S'S%SSg.Shj5r2\"\"/\"\SSSS9S/\"\SSSS9/\"\SSSS9/\"\SSSS9/S/S#/Sf.S%S&9S*S9S'S%SSg.Sij5r3g)rz* Generate samples of synthetic data sets. N)Iterable)IntegralReal)linalg)Bunch)MultiLabelBinarizer) check_arraycheck_random_state)shuffle)Interval StrOptionsvalidate_params)sample_without_replacementc.US:a5[R"URSXS- 4S9[USU5/5$[ SU-XS9R SSS9n[R "URS55RS 5S S 2U*S 24nU$) z5Returns distinct binary samples of length dimensions.rsize random_statez>u4F)dtypecopyz>u1) N) nphstackrandint_generate_hypercuberastype unpackbitsviewreshape)samples dimensionsrngouts V/var/www/html/venv/lib/python3.13/site-packages/sklearn/datasets/_samples_generator.pyrrsByy AW2o$> ?#GR5   %Q ]G N U U% V C -- ( 0 0 :1zkl? KC J n_samplesleft)closed n_features n_informative n_redundant n_repeated n_classesn_clusters_per_classweightsz array-likeflip_yboth class_sepneither hypercubebooleanshiftscaler r return_X_yT)prefer_skip_nested_validationdg{Gz??)r.r/r0r1r2r3r4r6r8r:r;r rr<c p [U5nX#-U-U:a [S5eU[R"XV-5:a&SnUS- n[UR XVUSU-55eUb[ U5XUS- 4;a [S5e[ U5US- :XaS[ U[5(aUS[U5- /-nOE[R"Xu5nS[USS 5- US 'OUR5nO SU- /U-nX- U- U- nXV-n[U5Vs/sHn[UUUU--U- 5PM nn[U[U5- 5HnUUU-==S- ss'M [R"X45n[R"U[S 9n[UUU5R[ S S 9nUSU --nUU -nU (d(UUR#US4S 9-nUUR#SU4S 9-nUR%X4S 9USS2SU24'Sn['U5HXunnUUUU-nnUU-UUU&UUU2SU24nSUR#X"4S 9-S- n[R("UU5US'UU- nMZ US:aASUR#X#4S 9-S- n [R("USS2SU24U 5USS2X"U-24'X#-n!US:aJU!S- UR#US 9-S-R[R*5n"USS2U"4USS2U!U!U-24'US:aUR%UU4S 9USS2U*S24'US:a3UR#US 9U:n#UR-UU#R5S 9UU#'U cSUR#US 9-S- U -n UU - nU cSSUR#US 9--n UU -n[R."U5n"U (a1[1UUUS9unnUR3U"5 USS2U"4USS2SS24'U(aUU4$S/U-n$['U"5HGunn%U%U:aSU$U'MUU%s=::aX#-:a O OSU$U'M,U!U%s=::a U!U-:dM>O MBSU$U'MI 0SU_SU_SU_SU_SU_SU_SU_SU_S U_S!U _S"U _S#U _S$U _S%U _S&U_S'U_n&[5[6R8U&U$UUS(9n'U'$s snf))aGenerate a random n-class classification problem. This initially creates clusters of points normally distributed (std=1) about vertices of an ``n_informative``-dimensional hypercube with sides of length ``2*class_sep`` and assigns an equal number of clusters to each class. It introduces interdependence between these features and adds various types of further noise to the data. Without shuffling, ``X`` horizontally stacks features in the following order: the primary ``n_informative`` features, followed by ``n_redundant`` linear combinations of the informative features, followed by ``n_repeated`` duplicates, drawn randomly with replacement from the informative and redundant features. The remaining features are filled with random noise. Thus, without shuffling, all useful features are contained in the columns ``X[:, :n_informative + n_redundant + n_repeated]``. Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int, default=100 The number of samples. n_features : int, default=20 The total number of features. These comprise ``n_informative`` informative features, ``n_redundant`` redundant features, ``n_repeated`` duplicated features and ``n_features-n_informative-n_redundant-n_repeated`` useless features drawn at random. n_informative : int, default=2 The number of informative features. Each class is composed of a number of gaussian clusters each located around the vertices of a hypercube in a subspace of dimension ``n_informative``. For each cluster, informative features are drawn independently from N(0, 1) and then randomly linearly combined within each cluster in order to add covariance. The clusters are then placed on the vertices of the hypercube. n_redundant : int, default=2 The number of redundant features. These features are generated as random linear combinations of the informative features. n_repeated : int, default=0 The number of duplicated features, drawn randomly from the informative and the redundant features. n_classes : int, default=2 The number of classes (or labels) of the classification problem. n_clusters_per_class : int, default=2 The number of clusters per class. weights : array-like of shape (n_classes,) or (n_classes - 1,), default=None The proportions of samples assigned to each class. If None, then classes are balanced. Note that if ``len(weights) == n_classes - 1``, then the last class weight is automatically inferred. More than ``n_samples`` samples may be returned if the sum of ``weights`` exceeds 1. Note that the actual class proportions will not exactly match ``weights`` when ``flip_y`` isn't 0. flip_y : float, default=0.01 The fraction of samples whose class is assigned randomly. Larger values introduce noise in the labels and make the classification task harder. Note that the default setting flip_y > 0 might lead to less than ``n_classes`` in y in some cases. class_sep : float, default=1.0 The factor multiplying the hypercube size. Larger values spread out the clusters/classes and make the classification task easier. hypercube : bool, default=True If True, the clusters are put on the vertices of a hypercube. If False, the clusters are put on the vertices of a random polytope. shift : float, ndarray of shape (n_features,) or None, default=0.0 Shift features by the specified value. If None, then features are shifted by a random value drawn in [-class_sep, class_sep]. scale : float, ndarray of shape (n_features,) or None, default=1.0 Multiply features by the specified value. If None, then features are scaled by a random value drawn in [1, 100]. Note that scaling happens after shifting. shuffle : bool, default=True Shuffle the samples and the features. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. return_X_y : bool, default=True If True, a tuple ``(X, y)`` instead of a Bunch object is returned. .. versionadded:: 1.7 Returns ------- data : :class:`~sklearn.utils.Bunch` if `return_X_y` is `False`. Dictionary-like object, with the following attributes. DESCR : str A description of the function that generated the dataset. parameter : dict A dictionary that stores the values of the arguments passed to the generator function. feature_info : list of len(n_features) A description for each generated feature. X : ndarray of shape (n_samples, n_features) The generated samples. y : ndarray of shape (n_samples,) An integer label for class membership of each sample. .. versionadded:: 1.7 (X, y) : tuple if ``return_X_y`` is True A tuple of generated samples and labels. See Also -------- make_blobs : Simplified variant. make_multilabel_classification : Unrelated generator for multilabel tasks. Notes ----- The algorithm is adapted from Guyon [1] and was designed to generate the "Madelon" dataset. References ---------- .. [1] I. Guyon, "Design of experiments for the NIPS 2003 variable selection benchmark", 2003. Examples -------- >>> from sklearn.datasets import make_classification >>> X, y = make_classification(random_state=42) >>> X.shape (100, 20) >>> y.shape (100,) >>> list(y[:5]) [np.int64(0), np.int64(0), np.int64(1), np.int64(1), np.int64(0)] ziNumber of informative, redundant and repeated features must sum to less than the number of total featuresz0n_classes({}) * n_clusters_per_class({}) must bez) smaller or equal 2**n_informative({})={}rNr*z:Weights specified but incompatible with number of classes.r?rrFrrr.?r@r>rrandom informative redundantrepeatedr)r-r.r/r0r1r2r3r4r6r8r:r;r rr<)DESCR parameters feature_infoXy)r ValueErrorrlog2formatlen isinstancelistsumresizerrangeintzerosrrfloatuniformstandard_normal enumeratedotintprarange util_shuffler rmake_classification__doc__)(r)r-r.r/r0r1r2r3r4r6r8r:r;r rr< generatormsgweights_n_random n_clusterskn_samples_per_clusterirLrM centroidsstopcentroidstartX_kABnindices flip_mask feat_descindexrJbunchs( r'rara*s3t#<0I"Z/*<   rwwy?@@@ :: JJy q-GW X   w< q=9 9L  w<9q= ('4(("cCL&8%9999W8"S#2%77 ||~H)O$y0)K7*DH1J z""A IY/ /2F FG" 9s#899 :a*n-2-; )()A #&A$J yIPP EQIYI I Y&&ZO&<< Y&&Q ,>&?? %449:T4UAa- D + 8D#8#;;tI % d N]N*+ !! 'E!F F J66#q>C x,Q !! 'C!D Dq H<>FF a- != !][8 8 89 #AA~EY..J.??#EMMbggV#$QZ=!QZ   !|$449h:O4P!hYZ-}%%9%5>  (((I)  }Y&&J&77!;yHJA }C)+++<<<JAii #GAqy91 '"AwJ-!Q$!t  Z'Ig&5 = (IaL e Am&A A&IaL % (!j. ( (%IaL 'Yj  {  j  Y   4 7 & Y Y   7   j!J& !))  E Lks!R3densesparse) r)r-r1n_labelslengthallow_unlabeledryreturn_indicatorreturn_distributionsr2F)r1rzr{r|ryr}r~rc~^^^^^^^[U 5mTRUS9n XR5-n [R"U 5mTRTU4S9mT[R"TSS9-mUUUUUUU4Sjn [ R "S5n [ R "SS/5n /n[ U5HInU "5unnU RU5 U R[U 55 URU5 MK [R"[U 5[RS9n[R"UX4UT4S9nUR5 U(dUR5nUS;a6[!US :HS 9nUR#[ U5/5R%U5nU(aUXT4$UU4$) aL Generate a random multilabel classification problem. For each sample, the generative process is: - pick the number of labels: n ~ Poisson(n_labels) - n times, choose a class c: c ~ Multinomial(theta) - pick the document length: k ~ Poisson(length) - k times, choose a word: w ~ Multinomial(theta_c) In the above process, rejection sampling is used to make sure that n is never zero or more than `n_classes`, and that the document length is never zero. Likewise, we reject classes which have already been chosen. For an example of usage, see :ref:`sphx_glr_auto_examples_datasets_plot_random_multilabel_dataset.py`. Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int, default=100 The number of samples. n_features : int, default=20 The total number of features. n_classes : int, default=5 The number of classes of the classification problem. n_labels : int, default=2 The average number of labels per instance. More precisely, the number of labels per sample is drawn from a Poisson distribution with ``n_labels`` as its expected value, but samples are bounded (using rejection sampling) by ``n_classes``, and must be nonzero if ``allow_unlabeled`` is False. length : int, default=50 The sum of the features (number of words if documents) is drawn from a Poisson distribution with this expected value. allow_unlabeled : bool, default=True If ``True``, some instances might not belong to any class. sparse : bool, default=False If ``True``, return a sparse feature matrix. .. versionadded:: 0.17 parameter to allow *sparse* output. return_indicator : {'dense', 'sparse'} or False, default='dense' If ``'dense'`` return ``Y`` in the dense binary indicator format. If ``'sparse'`` return ``Y`` in the sparse binary indicator format. ``False`` returns a list of lists of labels. return_distributions : bool, default=False If ``True``, return the prior class probability and conditional probabilities of features given classes, from which the data was drawn. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape (n_samples, n_features) The generated samples. Y : {ndarray, sparse matrix} of shape (n_samples, n_classes) The label sets. Sparse matrix should be of CSR format. p_c : ndarray of shape (n_classes,) The probability of each class being drawn. Only returned if ``return_distributions=True``. p_w_c : ndarray of shape (n_features, n_classes) The probability of each feature being drawn given each class. Only returned if ``return_distributions=True``. Examples -------- >>> from sklearn.datasets import make_multilabel_classification >>> X, y = make_multilabel_classification(n_labels=3, random_state=42) >>> X.shape (100, 20) >>> y.shape (100, 5) >>> list(y[:3]) [array([1, 1, 0, 1, 0]), array([0, 1, 1, 1, 0]), array([0, 1, 0, 0, 0])] rraxisc >TRupUS-nT(dUS:XdX!:a'T RT 5nT(dUS:XaM X!:aM'[5n[U5U:waR[R "T T R U[U5- S95nURU5 [U5U:waMR[U5nSnUS:XaT RT 5nUS:XaM[U5S:XaT RT US9nXc4$TRUSS9RSS9R5nXwS-n[R "UT R US95nXc4$)Nr*rrrr) shapepoissonsetrQr searchsortedrZupdaterSrtakerTcumsum)_r1y_sizerMcn_wordswordscumulative_p_w_sampler|cumulative_p_crcr{r-rzp_w_cs r'sample_example6make_multilabel_classification..sample_examplesY{{ Q"v{v7I&&x0F#v{v7I E!f 0A0AvPSTUPV0A0WXA HHQK!f Gl''/Gl q6Q;%%jw%?E8O!& 11 5 9 9q 9 A H H Jr!:: 5y7H7Hg7H7VWxr(rjrB)r)Tryrxry) sparse_output)r rZrTrrarrayrVextendappendrQonesfloat64sp csr_matrixsum_duplicatestoarrayr fit transform)r)r-r1rzr{r|ryr}r~rp_cr X_indicesX_indptrYrjrrMX_datarLlbrrcrs ` ``` @@@r'make_multilabel_classificationrsn#<0I     +C779CYYs^N   J #:  ;E RVVE ""EB C I{{3$H A 9 !#qI'   WWS^2:: 6F vy3Iz;RSA  IIK44 0@H0L N FFE)$% & 0 0 3!% a4Kr()r)rrc[U5nUS4nURUS9RU5nUS-RSS9S:R [ R SS9nS XUS :H'XE4$) aGenerate data for binary classification used in Hastie et al. 2009, Example 10.2. The ten features are standard independent Gaussian and the target ``y`` is defined by:: y[i] = 1 if np.sum(X[i] ** 2) > 9.34 else -1 Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int, default=12000 The number of samples. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape (n_samples, 10) The input samples. y : ndarray of shape (n_samples,) The output values. See Also -------- make_gaussian_quantiles : A generalization of this dataset approach. References ---------- .. [1] T. Hastie, R. Tibshirani and J. Friedman, "Elements of Statistical Learning Ed. 2", Springer, 2009. Examples -------- >>> from sklearn.datasets import make_hastie_10_2 >>> X, y = make_hastie_10_2(n_samples=24000, random_state=42) >>> X.shape (24000, 10) >>> y.shape (24000,) >>> list(y[:5]) [np.float64(-1.0), np.float64(1.0), np.float64(-1.0), np.float64(1.0), np.float64(-1.0)] r@r*rgGz"@FrCr@)r normalr"rTrrr)r)rrsrrLrMs r'make_hastie_10_2r8srp L )B OE u %%e,A S&1  $,,RZZe,DAA3hK 4Kr() r)r-r. n_targetsbiaseffective_rank tail_strengthnoiser coefrrrD) r.rrrrrr rrc Z[X5n[U 5n UcU RX4S9n O [UUUUU S9n [R "X45n SU R X#4S9-U SU2SS24'[R"X5U-nUS:aXRX~RS9- nU(aI[XU S9up[R"U5nU RU5 U SS2U4U SS2SS24'Xn [R"U5nU (aX[R"U 54$X4$)a Generate a random regression problem. The input set can either be well conditioned (by default) or have a low rank-fat tail singular profile. See :func:`make_low_rank_matrix` for more details. The output is generated by applying a (potentially biased) random linear regression model with `n_informative` nonzero regressors to the previously generated input and some gaussian centered noise with some adjustable scale. Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int, default=100 The number of samples. n_features : int, default=100 The number of features. n_informative : int, default=10 The number of informative features, i.e., the number of features used to build the linear model used to generate the output. n_targets : int, default=1 The number of regression targets, i.e., the dimension of the y output vector associated with a sample. By default, the output is a scalar. bias : float, default=0.0 The bias term in the underlying linear model. effective_rank : int, default=None If not None: The approximate number of singular vectors required to explain most of the input data by linear combinations. Using this kind of singular spectrum in the input allows the generator to reproduce the correlations often observed in practice. If None: The input set is well conditioned, centered and gaussian with unit variance. tail_strength : float, default=0.5 The relative importance of the fat noisy tail of the singular values profile if `effective_rank` is not None. When a float, it should be between 0 and 1. noise : float, default=0.0 The standard deviation of the gaussian noise applied to the output. shuffle : bool, default=True Shuffle the samples and the features. coef : bool, default=False If True, the coefficients of the underlying linear model are returned. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape (n_samples, n_features) The input samples. y : ndarray of shape (n_samples,) or (n_samples, n_targets) The output values. coef : ndarray of shape (n_features,) or (n_features, n_targets) The coefficient of the underlying linear model. It is returned only if coef is True. Examples -------- >>> from sklearn.datasets import make_regression >>> X, y = make_regression(n_samples=5, n_features=2, noise=1, random_state=42) >>> X array([[ 0.4967, -0.1382 ], [ 0.6476, 1.523], [-0.2341, -0.2341], [-0.4694, 0.5425], [ 1.579, 0.7674]]) >>> y array([ 6.737, 37.79, -10.27, 0.4017, 42.22]) Nrr)r-rrrr>r@r;rr)minr r[make_low_rank_matrixrrXrZr]rrr`r_r squeeze)r)r-r.rrrrrr rrrcrL ground_truthrMrss r'make_regressionrzsDh 2M"<0I  % %I+B % C !!)'"  88Z34L&)I,=,= '->-'L-"# q$&A s{  E  88Ay9))J''"AwJ-!Q$#,  1 A RZZ ---t r()r)r rrfactorg?)r rrrc[U[R5(a US-nX- nO[U5S:wa [ S5eUupV[ U5n[ R"SS[ R-USS9n[ R"SS[ R-USS9n [ R"U5n [ R"U5n [ R"U 5U-n [ R"U 5U-n [ R"[ R"X5[ R"X5/5Rn[ R"[ R"U[ R S9[ R""U[ R S9/5nU(a [%XUS9upUbXR'X.R(S9- nX4$) aMake a large circle containing a smaller circle in 2d. A simple toy dataset to visualize clustering and classification algorithms. Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int or tuple of shape (2,), dtype=int, default=100 If int, it is the total number of points generated. For odd numbers, the inner circle will have one point more than the outer circle. If two-element tuple, number of points in outer circle and inner circle. .. versionchanged:: 0.23 Added two-element tuple. shuffle : bool, default=True Whether to shuffle the samples. noise : float, default=None Standard deviation of Gaussian noise added to the data. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset shuffling and noise. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. factor : float, default=.8 Scale factor between inner and outer circle in the range `[0, 1)`. Returns ------- X : ndarray of shape (n_samples, 2) The generated samples. y : ndarray of shape (n_samples,) The integer labels (0 or 1) for class membership of each sample. Examples -------- >>> from sklearn.datasets import make_circles >>> X, y = make_circles(random_state=42) >>> X.shape (100, 2) >>> y.shape (100,) >>> list(y[:5]) [np.int64(1), np.int64(1), np.int64(1), np.int64(0), np.int64(0)] rz7When a tuple, n_samples must have exactly two elements.rF)endpointrBrr)rRnumbersrrQrNr rlinspacepicossinvstackrTrrXr^rr`rr)r)r rrr n_samples_out n_samples_inrc linspace_out linspace_in outer_circ_x outer_circ_y inner_circ_x inner_circ_yrLrMs r' make_circlesrsmB)W--..!Q  0 y>Q VW W&/# "<0I;;q!bee)]UKL++aRUUL5IK66,'L66,'L66+&/L66+&/L < . ,0UV a -rww /RWW1UV AAy9   E  88 4Kr()r)r rr)r rrcB[U[R5(a US-nX- nOUupE[ U5n[ R "[ R"S[ RU55n[ R"[ R"S[ RU55n S[ R "[ R"S[ RU55- n S[ R"[ R"S[ RU55- S- n [ R"[ R"X5[ R"X5/5Rn [ R"[ R"U[ RS9[ R "U[ RS9/5n U(a [#XUS9upUbXR%X,R&S 9- n X4$![an[S5UeSnAff=f) aMake two interleaving half circles. A simple toy dataset to visualize clustering and classification algorithms. Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int or tuple of shape (2,), dtype=int, default=100 If int, the total number of points generated. If two-element tuple, number of points in each of two moons. .. versionchanged:: 0.23 Added two-element tuple. shuffle : bool, default=True Whether to shuffle the samples. noise : float, default=None Standard deviation of Gaussian noise added to the data. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset shuffling and noise. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape (n_samples, 2) The generated samples. y : ndarray of shape (n_samples,) The integer labels (0 or 1) for class membership of each sample. Examples -------- >>> from sklearn.datasets import make_moons >>> X, y = make_moons(n_samples=200, noise=0.2, random_state=42) >>> X.shape (200, 2) >>> y.shape (200,) rz8`n_samples` can be either an int or a two-element tuple.Nrr*rDrBrr)rRrrrNr rrrrrrrrrrXr^rr`rr)r)r rrrrercrrrrrLrMs r' make_moonsrsj)W--..!Q  0  *3 'M #<0I66"++a >?L66"++a >?Lrvvbkk!RUULABBLrvvbkk!RUULABBSHL < . ,0UV a -rww /RWW1UV AAy9   E  88 4K3 J  sH H HH)r)r-centers cluster_std center_boxr rreturn_centers)g$g$@)rrrr rrcx[U5n[U[R5(aiUcSn[U[R5(aUn UR USUSX4S9nO[ U5nUR SnUR Sn O[U5n UcUR USUSX4S9n[U[5(d[SRU55e[U5U :wa[SUSU35e[ U5nUR Sn[US5(a)[U5U :wa[S RX#55e[U[R5(a [R"[U5U5n[U[5(aUn O1[X -5/U -n [!X -5Hn X==S- ss'M [R""U 5n [R$"['U 5U4[R(S 9n [R$"['U 54[S 9n[+[-X55H7un unnU S:aXS- OSnXnUR/X+UX4S 9U UU&XUU&M9 U(a [1XUS 9upU(aXU4$X4$) a Generate isotropic Gaussian blobs for clustering. Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int or array-like, default=100 If int, it is the total number of points equally divided among clusters. If array-like, each element of the sequence indicates the number of samples per cluster. .. versionchanged:: v0.20 one can now pass an array-like to the ``n_samples`` parameter n_features : int, default=2 The number of features for each sample. centers : int or array-like of shape (n_centers, n_features), default=None The number of centers to generate, or the fixed center locations. If n_samples is an int and centers is None, 3 centers are generated. If n_samples is array-like, centers must be either None or an array of length equal to the length of n_samples. cluster_std : float or array-like of float, default=1.0 The standard deviation of the clusters. center_box : tuple of float (min, max), default=(-10.0, 10.0) The bounding box for each cluster center when centers are generated at random. shuffle : bool, default=True Shuffle the samples. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. return_centers : bool, default=False If True, then return the centers of each cluster. .. versionadded:: 0.23 Returns ------- X : ndarray of shape (n_samples, n_features) The generated samples. y : ndarray of shape (n_samples,) The integer labels for cluster membership of each sample. centers : ndarray of shape (n_centers, n_features) The centers of each cluster. Only returned if ``return_centers=True``. See Also -------- make_classification : A more intricate variant. Examples -------- >>> from sklearn.datasets import make_blobs >>> X, y = make_blobs(n_samples=10, centers=3, n_features=2, ... random_state=0) >>> print(X.shape) (10, 2) >>> y array([0, 0, 1, 0, 2, 2, 2, 1, 1, 0]) >>> X, y = make_blobs(n_samples=[3, 3, 4], centers=None, n_features=2, ... random_state=0) >>> print(X.shape) (10, 2) >>> y array([0, 1, 2, 0, 2, 2, 2, 1, 1, 0]) rr*rz8Parameter `centers` must be array-like. Got {!r} insteadzMLength of `n_samples` not consistent with number of centers. Got n_samples = z and centers = __len__zeLength of `clusters_std` not consistent with number of centers. Got centers = {} and cluster_std = {}rrlocr;rr)r rRrrrZr rrQrrNrPhasattrrrfullrWrVremptyrTrr\ziprr`)r)r-rrrr rrrc n_centersn_samples_per_centerrjcum_sum_n_samplesrLrMrrstd start_idxend_idxs r' make_blobsrsH#<0I)W--.. ?G gw// 0 0I''1 z!}I3J(G "'*G q)J a(I N ?''1 z!}I3J(G'8,,JQQ  w<9 $,,5;ogYP g&]]1% {I&&3{+;y+H ##)6'#?  +w||,,ggc'lK8 )X&&( #I$: ;bjjQA 0133?A %9!GH 8As01A%!e,1 #&(// #QO 0 )G !)G IAy9W}t r()r)r-rr)rrc2[U5nURX4S9nS[R"[RUSS2S4-USS2S4-5-SUSS2S4S- S---SUSS2S 4--S USS2S 4--X$R US9--nXV4$) aGenerate the "Friedman #1" regression problem. This dataset is described in Friedman [1] and Breiman [2]. Inputs `X` are independent features uniformly distributed on the interval [0, 1]. The output `y` is created according to the formula:: y(X) = 10 * sin(pi * X[:, 0] * X[:, 1]) + 20 * (X[:, 2] - 0.5) ** 2 + 10 * X[:, 3] + 5 * X[:, 4] + noise * N(0, 1). Out of the `n_features` features, only 5 are actually used to compute `y`. The remaining features are independent of `y`. The number of features has to be >= 5. Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int, default=100 The number of samples. n_features : int, default=10 The number of features. Should be at least 5. noise : float, default=0.0 The standard deviation of the gaussian noise applied to the output. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset noise. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape (n_samples, n_features) The input samples. y : ndarray of shape (n_samples,) The output values. References ---------- .. [1] J. Friedman, "Multivariate adaptive regression splines", The Annals of Statistics 19 (1), pages 1-67, 1991. .. [2] L. Breiman, "Bagging predictors", Machine Learning 24, pages 123-140, 1996. Examples -------- >>> from sklearn.datasets import make_friedman1 >>> X, y = make_friedman1(random_state=42) >>> X.shape (100, 10) >>> y.shape (100,) >>> list(y[:3]) [np.float64(16.8), np.float64(5.87), np.float64(9.46)] rrNrr*rrDrr)r rZrrrr[)r)r-rrrcrLrMs r'make_friedman1rsL#<0I 67A RVVBEEAadGOa1g- .. !Q$# !# # $ qAw,  a1g+  ++)+= =  > 4Kr()r)rrc[U5nURUS4S9nUSS2S4==S-ss'USS2S4==S[R--ss'USS2S4==S[R-- ss'USS2S 4==S -ss'USS2S 4==S- ss'USS2S4S -USS2S4USS2S 4-SUSS2S4USS2S 4-- - S --S -XR US9--nXE4$) aGenerate the "Friedman #2" regression problem. This dataset is described in Friedman [1] and Breiman [2]. Inputs `X` are 4 independent features uniformly distributed on the intervals:: 0 <= X[:, 0] <= 100, 40 * pi <= X[:, 1] <= 560 * pi, 0 <= X[:, 2] <= 1, 1 <= X[:, 3] <= 11. The output `y` is created according to the formula:: y(X) = (X[:, 0] ** 2 + (X[:, 1] * X[:, 2] - 1 / (X[:, 1] * X[:, 3])) ** 2) ** 0.5 + noise * N(0, 1). Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int, default=100 The number of samples. noise : float, default=0.0 The standard deviation of the gaussian noise applied to the output. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset noise. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape (n_samples, 4) The input samples. y : ndarray of shape (n_samples,) The output values. References ---------- .. [1] J. Friedman, "Multivariate adaptive regression splines", The Annals of Statistics 19 (1), pages 1-67, 1991. .. [2] L. Breiman, "Bagging predictors", Machine Learning 24, pages 123-140, 1996. Examples -------- >>> from sklearn.datasets import make_friedman2 >>> X, y = make_friedman2(random_state=42) >>> X.shape (100, 4) >>> y.shape (100,) >>> list(y[:3]) [np.float64(1229.4), np.float64(27.0), np.float64(65.6)] rrNrr>r*(rrrrD)r rZrrr[r)rrrcrLrMs r'make_friedman2rs H#<0I 1~.AadGsNGadGsRUU{GadGrBEEzGadGrMGadGqLG !Q$1 !Q$!AqD')A1a41QT71B,CCII  00y0BB CA 4Kr(c[U5nURUS4S9nUSS2S4==S-ss'USS2S4==S[R--ss'USS2S4==S[R-- ss'USS2S 4==S -ss'USS2S 4==S- ss'[R"USS2S4USS2S 4-SUSS2S4USS2S 4-- - USS2S4- 5XR US9--nXE4$) aGenerate the "Friedman #3" regression problem. This dataset is described in Friedman [1] and Breiman [2]. Inputs `X` are 4 independent features uniformly distributed on the intervals:: 0 <= X[:, 0] <= 100, 40 * pi <= X[:, 1] <= 560 * pi, 0 <= X[:, 2] <= 1, 1 <= X[:, 3] <= 11. The output `y` is created according to the formula:: y(X) = arctan((X[:, 1] * X[:, 2] - 1 / (X[:, 1] * X[:, 3])) / X[:, 0]) + noise * N(0, 1). Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int, default=100 The number of samples. noise : float, default=0.0 The standard deviation of the gaussian noise applied to the output. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset noise. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape (n_samples, 4) The input samples. y : ndarray of shape (n_samples,) The output values. References ---------- .. [1] J. Friedman, "Multivariate adaptive regression splines", The Annals of Statistics 19 (1), pages 1-67, 1991. .. [2] L. Breiman, "Bagging predictors", Machine Learning 24, pages 123-140, 1996. Examples -------- >>> from sklearn.datasets import make_friedman3 >>> X, y = make_friedman3(random_state=42) >>> X.shape (100, 4) >>> y.shape (100,) >>> list(y[:3]) [np.float64(1.54), np.float64(0.956), np.float64(0.414)] rrNrr>r*rrrrr)r rZrrarctanr[rs r'make_friedman3r3sH#<0I 1~.AadGsNGadGsRUU{GadGrBEEzGadGrMGadGqLG 1a41QT7 Q!AqD'AadG"34 4!Q$?  )) );; `. Parameters ---------- n_samples : int, default=100 The number of samples. n_features : int, default=100 The number of features. effective_rank : int, default=10 The approximate number of singular vectors required to explain most of the data by linear combinations. tail_strength : float, default=0.5 The relative importance of the fat noisy tail of the singular values profile. The value should be between 0 and 1. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape (n_samples, n_features) The matrix. Examples -------- >>> from numpy.linalg import svd >>> from sklearn.datasets import make_low_rank_matrix >>> X = make_low_rank_matrix( ... n_samples=50, ... n_features=25, ... effective_rank=5, ... tail_strength=0.01, ... random_state=0, ... ) >>> X.shape (50, 25) reconomicF)mode check_finiterBr*rrg) r rrqrr[rr_rexpidentityr]r)r)r-rrrrcrrurv singular_indlow_ranktailss r'rrs`#<0I I"A 99!! ~!6  DA 99!! !7  DA99Qbjj1LM!RVVDL4QVW3W,W%XXH 266$"5"FG GD A(/*A 66"&&, $$r()r) n_componentsr-n_nonzero_coefsrc[U5nURX!4S9nU[R"[R"US-SS95-n[R "X45n[ U5HBn[R"U5n URU 5 U SUn URUS9XyU4'MD [R"Xg5n U RURURpvn [[RXU45$)a&Generate a signal as a sparse combination of dictionary elements. Returns matrices `Y`, `D` and `X` such that `Y = XD` where `X` is of shape `(n_samples, n_components)`, `D` is of shape `(n_components, n_features)`, and each row of `X` has exactly `n_nonzero_coefs` non-zero elements. Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int Number of samples to generate. n_components : int Number of components in the dictionary. n_features : int Number of features of the dataset to generate. n_nonzero_coefs : int Number of active (non-zero) coefficients in each sample. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- data : ndarray of shape (n_samples, n_features) The encoded signal (Y). dictionary : ndarray of shape (n_components, n_features) The dictionary with normalized components (D). code : ndarray of shape (n_samples, n_components) The sparse code such that each column of this matrix has exactly n_nonzero_coefs non-zero items (X). Examples -------- >>> from sklearn.datasets import make_sparse_coded_signal >>> data, dictionary, code = make_sparse_coded_signal( ... n_samples=50, ... n_components=100, ... n_features=10, ... n_nonzero_coefs=4, ... random_state=0 ... ) >>> data.shape (50, 10) >>> dictionary.shape (100, 10) >>> code.shape (50, 100) rrrrN) r r[rsqrtrTrXrVr_r r]rmapr) r)rr-rrrcDrLrjidxrs r'make_sparse_coded_signalr sT#<0I !! 'A!BAAQ' ((A ,*+A 9 ii %#"?#--?-Cq&  q Acc133!A rzzA!9 %%r()r)r-rc[U5nURSSX4S9nURUSS2S4SUSS2S4--SUSS2S4-- SUSS2S4-- [R"U5S9nXE4$) aGenerate a random regression problem with sparse uncorrelated design. This dataset is described in Celeux et al [1]. as:: X ~ N(0, 1) y(X) = X[:, 0] + 2 * X[:, 1] - 2 * X[:, 2] - 1.5 * X[:, 3] Only the first 4 features are informative. The remaining features are useless. Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int, default=100 The number of samples. n_features : int, default=10 The number of features. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape (n_samples, n_features) The input samples. y : ndarray of shape (n_samples,) The output values. References ---------- .. [1] G. Celeux, M. El Anbari, J.-M. Marin, C. P. Robert, "Regularization in regression: comparing Bayesian and frequentist methods in a poorly informative situation", 2009. Examples -------- >>> from sklearn.datasets import make_sparse_uncorrelated >>> X, y = make_sparse_uncorrelated(random_state=0) >>> X.shape (100, 10) >>> y.shape (100,) rr*rNr?r)rr;)r rrr)r)r-rrcrLrMs r'make_sparse_uncorrelatedr Rsr#<0IQay.EFA q!tWq1QT7{ "Q1a4[ 031a4= @ggi   A 4Kr()n_dimrc J[U5nURX4S9n[R"[R "UR U5SS9upEn[R "[R "US[R"URUS95-5U5nU$)aGenerate a random symmetric, positive-definite matrix. Read more in the :ref:`User Guide `. Parameters ---------- n_dim : int The matrix dimension. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape (n_dim, n_dim) The random symmetric, positive-definite matrix. See Also -------- make_sparse_spd_matrix: Generate a sparse symmetric definite positive matrix. Examples -------- >>> from sklearn.datasets import make_spd_matrix >>> make_spd_matrix(n_dim=2, random_state=42) array([[2.093, 0.346], [0.346, 0.218]]) rF)rr?)r rZrsvdrr]rdiag)r rrcrpUrVtrLs r'make_spd_matrixrsL#<0I~.Azz"&&a.u=HA" rvvarwwy'8'8e'8'DEEFKA Hr(>bsrcoocsccsrdiadoklil)r alpha norm_diag smallest_coef largest_coef sparse_formatrgffffff?g?g?)rrrrrrc^^^[T5m[R"U5*n[R"UUSU- UUU4SjTS9n[R"USSS9nTR U5n XR U nXx- nUR U-n U(aB[R"S[R"U R55- 5n X-U -n UcU R5$U RU5$)axGenerate a sparse symmetric definite positive matrix. Read more in the :ref:`User Guide `. Parameters ---------- n_dim : int, default=1 The size of the random matrix to generate. .. versionchanged:: 1.4 Renamed from ``dim`` to ``n_dim``. alpha : float, default=0.95 The probability that a coefficient is zero (see notes). Larger values enforce more sparsity. The value should be in the range 0 and 1. norm_diag : bool, default=False Whether to normalize the output matrix to make the leading diagonal elements all 1. smallest_coef : float, default=0.1 The value of the smallest coefficient between 0 and 1. largest_coef : float, default=0.9 The value of the largest coefficient between 0 and 1. sparse_format : str, default=None String representing the output sparse format, such as 'csc', 'csr', etc. If ``None``, return a dense numpy ndarray. .. versionadded:: 1.4 random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- prec : ndarray or sparse matrix of shape (dim, dim) The generated matrix. If ``sparse_format=None``, this would be an ndarray. Otherwise, this will be a sparse matrix of the specified format. See Also -------- make_spd_matrix : Generate a random symmetric, positive-definite matrix. Notes ----- The sparsity is actually imposed on the cholesky factor of the matrix. Thus alpha does not translate directly into the filling fraction of the matrix itself. Examples -------- >>> from sklearn.datasets import make_sparse_spd_matrix >>> make_sparse_spd_matrix(n_dim=4, norm_diag=False, random_state=42) array([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [0., 0., 0., 1.]]) r*c&>TRTTUS9$)N)lowhighr)rZ)xrrrs r'(make_sparse_spd_matrix..#s<//Lq0 r()mrrdensitydata_rvsrrr)rhrPr?) r reyerEtril permutationrdiagsrrdiagonalrasformat) r rrrrrrcholauxr,precds `` ` r'make_sparse_spd_matrixr4sn&l3L FF5M>D ))  E  " C ''#E *C**51K   [ )CKD 66D=D HHS2774==?33 4x!|||~}}]++r()r)rrhole)rrr5c Z[U5nU(d<S[R-SSURUS9---nSURUS9-nO[R"[ S5VVs/sH1n[ S5Hn[RSU--US-/PM M3 snn5n [R "U SS S 9n URS U5n URSU4S9[R"[R/S//5-n XRU -upVU[R"U5-n U[R"U5-n [R"XU 45nXURSU4S9-- nURn[R"U5nX4$s snnf) aGenerate a swiss roll dataset. Read more in the :ref:`User Guide `. Adapted with permission from Stephen Marsland's code [1]. Parameters ---------- n_samples : int, default=100 The number of sample points on the Swiss Roll. noise : float, default=0.0 The standard deviation of the gaussian noise. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. hole : bool, default=False If True generates the swiss roll with hole dataset. Returns ------- X : ndarray of shape (n_samples, 3) The points. t : ndarray of shape (n_samples,) The univariate position of the sample according to the main dimension of the points in the manifold. Notes ----- The algorithm is from Marsland [1]. References ---------- .. [1] S. Marsland, "Machine Learning: An Algorithmic Perspective", 2nd edition, Chapter 6, 2014. https://homepages.ecs.vuw.ac.nz/~marslast/Code/Ch6/lle.py Examples -------- >>> from sklearn.datasets import make_swiss_roll >>> X, t = make_swiss_roll(noise=0.05, random_state=0) >>> X.shape (100, 3) >>> t.shape (100,) r r*rrrrrr)r rrrZrrVdeletechoicerrrrr[r)r)rrr5rctrMrjjcorners corner_indexrJr$zrLs r'make_swiss_rollrA=sx#<0I  "%%K1q9#4#4)#4#DDD E "" "2 2((16q LA58abeesQwQ '8 ' L ))GQQ/ ''95 &&Q N&;bhhRSQT~>VV $&&3 BFF1I A BFF1I A 1)A**I*? ??A A 1 A 4K Ms-8F' c[U5nS[R-URSU4S9S- -n[R"US4[R S9n[R "U5USS2S4'SURUS9-USS2S4'[R"U5[R"U5S- -USS2S 4'XQURSU4S9R-- n[R"U5nXT4$) aiGenerate an S curve dataset. Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int, default=100 The number of sample points on the S curve. noise : float, default=0.0 The standard deviation of the gaussian noise. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape (n_samples, 3) The points. t : ndarray of shape (n_samples,) The univariate position of the sample according to the main dimension of the points in the manifold. Examples -------- >>> from sklearn.datasets import make_s_curve >>> X, t = make_s_curve(noise=0.05, random_state=0) >>> X.shape (100, 3) >>> t.shape (100,) rr*rrDrNrrr) r rrrZrrrsignrr[rr)r)rrrcr<rLs r' make_s_curverDsX#<0I BEE Y&&Q N&;cABA  1~RZZ8AffQiAadGI%%9%55AadGggajBFF1IM*AadG**I*?AA AAA 1 A 4Kr()meancovr)r-r1r rrc rX$:a [S5e[U5nUc[R"U5nO[R"U5nUR X[R "U5-U45n[R"[R"X[RSS24- S-SS95n XSS24nX$-n [R"[R"[R"U5U 5[R"US- X*U-- 5/5n U(a [XUS9upX4$)a2Generate isotropic Gaussian and label samples by quantile. This classification dataset is constructed by taking a multi-dimensional standard normal distribution and defining classes separated by nested concentric multi-dimensional spheres such that roughly equal numbers of samples are in each class (quantiles of the :math:`\chi^2` distribution). Read more in the :ref:`User Guide `. Parameters ---------- mean : array-like of shape (n_features,), default=None The mean of the multi-dimensional normal distribution. If None then use the origin (0, 0, ...). cov : float, default=1.0 The covariance matrix will be this value times the unit matrix. This dataset only produces symmetric normal distributions. n_samples : int, default=100 The total number of points equally divided among classes. n_features : int, default=2 The number of features for each sample. n_classes : int, default=3 The number of classes. shuffle : bool, default=True Shuffle the samples. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape (n_samples, n_features) The generated samples. y : ndarray of shape (n_samples,) The integer labels for quantile membership of each sample. Notes ----- The dataset is from Zhu et al [1]. References ---------- .. [1] J. Zhu, H. Zou, S. Rosset, T. Hastie, "Multi-class AdaBoost", 2009. Examples -------- >>> from sklearn.datasets import make_gaussian_quantiles >>> X, y = make_gaussian_quantiles(random_state=42) >>> X.shape (100, 2) >>> y.shape (100,) >>> list(y[:5]) [np.int64(2), np.int64(0), np.int64(1), np.int64(0), np.int64(2)] z$n_samples must be at least n_classesNrr*rr)rNr rrXrmultivariate_normalrargsortrTnewaxisrrepeatr_r`) rErFr)r-r1r rrcrLrsteprMs r'make_gaussian_quantilesrMsj?@@"<0I |xx #xx~ %%d"++j2I,II<XA **RVVQbjj!m!44:C DC q& A  !D IIbii *D 1 IIi!mY 1A%A B  AAy9 4Kr(c[U5nURup4URU5nURU5nXSS2U4nXuU4$N)r rr,)datarrcn_rowsn_colsrow_idxcol_idxresults r'_shufflerVAsR"<0IZZNF##F+G##F+G ]1g: &F G ##r()rrgrminvalmaxvalr r)rrWrXr rc [U5nUupURX4U5n URU[R"SU- U55n URU [R"SU- U55n [R "[ [U5U 5V Vs/sHup[R"X5PM snn 5n[R "[ [U5U 5V Vs/sHup[R"X5PM snn 5n[R"U[RS9n[U5H0n[R"UU:HUU:H5nUU==U U- ss'M2 US:aUURUURS9- nU(a[UU5unnnUUnUUn[R"[U5Vs/sHnUU:HPM sn5n[R"[U5Vs/sHnUU:HPM sn5nUUU4$s snn fs snn fs snfs snf)aGenerate a constant block diagonal structure array for biclustering. Read more in the :ref:`User Guide `. Parameters ---------- shape : tuple of shape (n_rows, n_cols) The shape of the result. n_clusters : int The number of biclusters. noise : float, default=0.0 The standard deviation of the gaussian noise. minval : float, default=10 Minimum value of a bicluster. maxval : float, default=100 Maximum value of a bicluster. shuffle : bool, default=True Shuffle the samples. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape `shape` The generated array. rows : ndarray of shape (n_clusters, X.shape[0]) The indicators for cluster membership of each row. cols : ndarray of shape (n_clusters, X.shape[1]) The indicators for cluster membership of each column. See Also -------- make_checkerboard: Generate an array with block checkerboard structure for biclustering. References ---------- .. [1] Dhillon, I. S. (2001, August). Co-clustering documents and words using bipartite spectral graph partitioning. In Proceedings of the seventh ACM SIGKDD international conference on Knowledge discovery and data mining (pp. 269-274). ACM. Examples -------- >>> from sklearn.datasets import make_biclusters >>> data, rows, cols = make_biclusters( ... shape=(10, 20), n_clusters=2, random_state=42 ... ) >>> data.shape (10, 20) >>> rows.shape (2, 10) >>> cols.shape (2, 20) r?rBrr)r rZ multinomialrrKrrrVrXrouterrrrVr)rrgrrWrXr rrcrQrRconsts row_sizes col_sizesvalrep row_labels col_labelsrUrjselectorrSrTrrowscolss r'make_biclustersrfJsp#<0INF   vz :F%%fbiij8H*.UVI%%fbiij8H*.UVI-0z1BI-NO-N3 -NOJ-0z1BI-NO-N3 -NOJXXe2:: .F : 88J!OZ1_=xF1I% qy)""V\\"BB#+FL#A ( ( 99uZ/@A/@!jAo/@A BD 99uZ/@A/@!jAo/@A BD 4 - P P BAs"H+ 0"H1 H7H<c $[U5n[US5(aUupOU=pUupURU [R"SU- U55n URU [R"SU - U 55n [R "[ [U5U 5VVs/sHup[R"X5PM snn5n[R "[ [U 5U 5VVs/sHup[R"X5PM snn5n[R"U[RS9n[U5HNn[U 5H<n[R"UU:HUU:H5nUU==URX45- ss'M> MP US:aUURUURS9- nU(a[UU5unnnUUnUUn[R"[U5VVs/sHn[U 5HnUU:HPM M snn5n[R"[U5VVs/sHn[U 5HnUU:HPM M snn5nUUU4$s snnfs snnfs snnfs snnf)a,Generate an array with block checkerboard structure for biclustering. Read more in the :ref:`User Guide `. Parameters ---------- shape : tuple of shape (n_rows, n_cols) The shape of the result. n_clusters : int or array-like or shape (n_row_clusters, n_column_clusters) The number of row and column clusters. noise : float, default=0.0 The standard deviation of the gaussian noise. minval : float, default=10 Minimum value of a bicluster. maxval : float, default=100 Maximum value of a bicluster. shuffle : bool, default=True Shuffle the samples. random_state : int, RandomState instance or None, default=None Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : ndarray of shape `shape` The generated array. rows : ndarray of shape (n_clusters, X.shape[0]) The indicators for cluster membership of each row. cols : ndarray of shape (n_clusters, X.shape[1]) The indicators for cluster membership of each column. See Also -------- make_biclusters : Generate an array with constant block diagonal structure for biclustering. References ---------- .. [1] Kluger, Y., Basri, R., Chang, J. T., & Gerstein, M. (2003). Spectral biclustering of microarray data: coclustering genes and conditions. Genome research, 13(4), 703-716. Examples -------- >>> from sklearn.datasets import make_checkerboard >>> data, rows, columns = make_checkerboard(shape=(300, 300), n_clusters=10, ... random_state=42) >>> data.shape (300, 300) >>> rows.shape (100, 300) >>> columns.shape (100, 300) >>> print(rows[0][:5], columns[0][:5]) [False False False True False] [False False False False False] rr?rBrr)r rrZrrKrrrVrXrr[rZrrrVr)rrgrrWrXr rrcn_row_clustersn_col_clustersrQrRr]r^r_r`rarbrUrjr=rcrSrTlabelrrdres r'make_checkerboardrksgn#<0Iz9%%)3&*44NF%% #.?I%% #.?I-0~1F -RS-R3 -RSJ-0~1F -RS-R3 -RSJXXe2:: .F > "~&Axx aqAH 8  1 1& A A '#  qy)""V\\"BB#+FL#A ( ( 99~. .>* % * .  D 99>* *~. % . *  D 4 G T T$  s%"I: 7"J "J "J )r>r)i.)r>r>)r>)r>r)r>r)r*rO)4rbrrcollections.abcrrrnumpyr scipy.sparseryrscipyr sklearn.utilsr preprocessingr utilsr r r r`utils._param_validationr rr utils.randomrrrarrrtuplerrrrrrrr r rr4rArDrMrVrfrkr(r'rws;  $"/3+KK5  hxD@Ax!T&AB (8QVDE 1d6BC  x!T&AB  hxD@A  (AtF!K L L$' 8D!Qv67 htQY?@ i[ (4tI> dS (4D;\4P I; ( yk!$#'',@   #@+*@F xD@A!T&ABxD@Ah4?@Haf=>%;+'((;#HafEtL"4Af=>4D89; '( #'"R   R! RjxD@%H;4D8$?'(D!Qv67 #' T"$T#T TnxD@%H;4D8$?'(  #'KTKK\xD@,O!T&ABXq$v> dS q$v> Mg;'($+ #' d  d dNxD@A!T&AB4d6:;'(  #'H#DHHVxD@A4D89'( #' I3TIIXxD@A4D89'( #' I3TIIXxD@A!T&AB#HafEF"4Af=>'( #' ]% ]% ]%@xD@A!(AtFCD!T&AB$Xq$vFG'( #'   T& T&nxD@A!T&AB'( #' 9499x8QV<='(#' ,0% % P8QV<=4Af56["4Af=>!$1V<= H I  (( #' f, f,f,RxD@A4D89'(  #'ICdIIXxD@A4D89'( #' .4..bt$q$v67xD@A!T&ABxD@A;'(#'    g gT$!T&AB4D89D$Y?@D$Y?@;'(#'    k k\!T&A<P4D89D$Y?@D$Y?@;'(#'     r(