ó cÂY]c@sÉdZddlZddlZddlZddlmZddljZ ddl m Z ddl m Z mZddl mZddlmZdd lmZdd lmZejjZejjZd „Zd d ddddddddeddedd„Zd d dddeededd„ Z ddd„Z!d d ddddddeedd„ Z"d edddd„Z#d eddd„Z$d dddd5edd"„Z%d dddd#„Z&d ddd$„Z'd ddd%„Z(d d dddd&„Z)dd'„Z*d ddd(„Z+dd)„Z,dd*ed+d,dd-„Z-d ddd.„Z.d ddd/„Z/ddd dd0edd1„Z0dd2„Z1ddd edd3„Z2ddd edd4„Z3dS(6s* Generate samples of synthetic data sets. iÿÿÿÿN(tlinalgi(tMultiLabelBinarizer(t check_arraytcheck_random_state(tshuffle(t _Iterable(tsample_without_replacement(tsixcCs«|dkrDtj|jdd||dfƒt|d|ƒgƒStd||d|ƒjdddtƒ}tj|jdƒƒj d ƒd d …| d …f}|S( s9Returns distinct binary samples of length dimensions iitsizet random_statetdtypes>u4tcopys>u1iÿÿÿÿi N(iÿÿÿÿi ( tnpthstacktrandintt_generate_hypercubeRtastypetFalset unpackbitstviewtreshape(tsamplest dimensionstrngtout((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pyRs " 8idiig{®Gáz„?gð?gc!Cst|ƒ}||||kr/tdƒ‚n|tj||ƒkrWtdƒ‚n|rˆt|ƒ||dgkrˆtdƒ‚n||||}||}|rÚt|ƒ|dkrÚ|dt|ƒg}n|d krd|g|}dt|d ƒ|d`. Parameters ---------- n_samples : int, optional (default=100) The number of samples. n_features : int, optional (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, optional (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, optional (default=2) The number of redundant features. These features are generated as random linear combinations of the informative features. n_repeated : int, optional (default=0) The number of duplicated features, drawn randomly from the informative and the redundant features. n_classes : int, optional (default=2) The number of classes (or labels) of the classification problem. n_clusters_per_class : int, optional (default=2) The number of clusters per class. weights : list of floats or None (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. flip_y : float, optional (default=0.01) The fraction of samples whose class are randomly exchanged. Larger values introduce noise in the labels and make the classification task harder. class_sep : float, optional (default=1.0) The factor multiplying the hypercube size. Larger values spread out the clusters/classes and make the classification task easier. hypercube : boolean, optional (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, array of shape [n_features] or None, optional (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, array of shape [n_features] or None, optional (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 : boolean, optional (default=True) Shuffle the samples and the features. random_state : int, RandomState instance or None (default) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, n_features] The generated samples. y : array of shape [n_samples] The integer labels for class membership of each sample. 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. See also -------- make_blobs: simplified variant make_multilabel_classification: unrelated generator for multilabel tasks siNumber of informative, redundant and repeated features must sum to less than the number of total featuressLn_classes * n_clusters_per_class must be smaller or equal 2 ** n_informativeis:Weights specified but incompatible with number of classes.gð?iÿÿÿÿR iNi.gà?gRidR (Rt ValueErrorR tlog2tlentsumtNonetrangetappendtinttzerosRRtfloattrandtrandnt enumeratetdottintpRt util_shuffletarangeR(!t n_samplest n_featurest n_informativet n_redundantt n_repeatedt n_classestn_clusters_per_classtweightstflip_yt class_sept hypercubetshifttscaleRR t generatort n_uselesst n_clusterstn_samples_per_clustertktitXtyt centroidststoptcentroidtstarttX_ktAtBtntindicest flip_mask((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_classification&s|v "     ( E  '3 , "     /ii2tdensec sít| ƒ‰ˆj|ƒ} | | jƒ:} tj| ƒ‰ˆjˆ|ƒ‰ˆtjˆddƒ:‰‡‡‡‡‡‡‡fd†} tjdƒ} tjddgƒ} g}xPt|ƒD]B}| ƒ\}}| j|ƒ| jt | ƒƒ|j|ƒq½Wtj t | ƒdtj ƒ}t j || | fd|ˆfƒ}|jƒ|sd|jƒ}n|tddfkr²td |dkƒ}|jt|ƒgƒj|ƒ}n|tk rÍtd ƒ‚n|rã||| ˆfS||fS( sà 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. Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int, optional (default=100) The number of samples. n_features : int, optional (default=20) The total number of features. n_classes : int, optional (default=5) The number of classes of the classification problem. n_labels : int, optional (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, optional (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, optional (default=True) If ``True``, some instances might not belong to any class. sparse : bool, optional (default=False) If ``True``, return a sparse feature matrix .. versionadded:: 0.17 parameter to allow *sparse* output. return_indicator : 'dense' (default) | 'sparse' | False 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, optional (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) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, n_features] The generated samples. Y : array or sparse CSR matrix of shape [n_samples, n_classes] The label sets. p_c : array, shape [n_classes] The probability of each class being drawn. Only returned if ``return_distributions=True``. p_w_c : array, shape [n_features, n_classes] The probability of each feature being drawn given each class. Only returned if ``return_distributions=True``. taxisicsaˆj\}}|d}x2ˆ r/|dks;||krMˆjˆƒ}qWtƒ}xHt|ƒ|kr¡tjˆˆj|t|ƒƒƒ}|j|ƒqZWt|ƒ}d}x|dkrÕˆjˆƒ}q·Wt|ƒdkrˆj ˆd|ƒ}||fSˆj |ddƒj ddƒj ƒ}||d:}tj|ˆj|ƒƒ}||fS(NiiRRKiÿÿÿÿ( tshapetpoissontsetRR t searchsortedR#tupdatetlistRttakeRtcumsum(t_R/ty_sizeR>tctn_wordstwordstcumulative_p_w_sample(tallow_unlabeledtcumulative_p_cR7tlengthR+tn_labelstp_w_c(sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytsample_example\s( "    'R<R RLtsparseRJt sparse_outputs;return_indicator must be either 'sparse', 'dense' or False.(RR#RR RStarrayRtextendRRtonestfloat64tspt csr_matrixtsum_duplicatesttoarraytTrueRtfitt transformRR(R*R+R/R]R\RZR`treturn_indicatortreturn_distributionsR tp_cR_t X_indicestX_indptrtYR<RXR>tX_dataR=tlb((RZR[R7R\R+R]R^sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_multilabel_classifications:R !"  $ ià.cCsut|ƒ}|df}|jd|ƒj|ƒ}|djddƒdkjtjƒ}d||dk<||fS( s)Generates 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, optional (default=12000) The number of samples. random_state : int, RandomState instance or None (default) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, 10] The input samples. y : array of shape [n_samples] The output values. References ---------- .. [1] T. Hastie, R. Tibshirani and J. Friedman, "Elements of Statistical Learning Ed. 2", Springer, 2009. See also -------- make_gaussian_quantiles: a generalization of this dataset approach i Rg@RKig®Gáz®"@gð¿g(RtnormalRRRR Re(R*R trsRLR=R>((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_hastie_10_2™s &  (i igà?c  Cs—t||ƒ}t| ƒ} |dkr<| j||ƒ} n'td|d|d|d|d| ƒ} tj||fƒ} d| j||ƒ| d|…dd…f`. Parameters ---------- n_samples : int, optional (default=100) The number of samples. n_features : int, optional (default=100) The number of features. n_informative : int, optional (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, optional (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, optional (default=0.0) The bias term in the underlying linear model. effective_rank : int or None, optional (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 between 0.0 and 1.0, optional (default=0.5) The relative importance of the fat noisy tail of the singular values profile if `effective_rank` is not None. noise : float, optional (default=0.0) The standard deviation of the gaussian noise applied to the output. shuffle : boolean, optional (default=True) Shuffle the samples and the features. coef : boolean, optional (default=False) If True, the coefficients of the underlying linear model are returned. random_state : int, RandomState instance or None (default) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, n_features] The input samples. y : array of shape [n_samples] or [n_samples, n_targets] The output values. coef : array of shape [n_features] or [n_features, n_targets], optional The coefficient of the underlying linear model. It is returned only if coef is True. R*R+teffective_rankt tail_strengthR idNgR6R(tminRRR$tmake_low_rank_matrixR R!R#R&RvRLR(R)Rtsqueeze(R*R+R,t n_targetstbiasRyRztnoiseRtcoefR R7R=t ground_truthR>RG((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_regressionÉs2L       " , gš™™™™™é?cCs”|dks|dkr'tdƒ‚n|d}||}t|ƒ}tjddtj|dtƒ}tjddtj|dtƒ} tj|ƒ} tj|ƒ} tj| ƒ|} tj| ƒ|} tjtj | | ƒtj | | ƒgƒj }tj tj |dtj ƒtj|dtj ƒgƒ}|r\t||d|ƒ\}}n|d k rŠ||jd|d |jƒ7}n||fS( s‡Make 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, optional (default=100) The total number of points generated. If odd, the inner circle will have one point more than the outer circle. shuffle : bool, optional (default=True) Whether to shuffle the samples. noise : double or None (default=None) Standard deviation of Gaussian noise added to the data. random_state : int, RandomState instance or None (default) Determines random number generation for dataset shuffling and noise. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. factor : 0 < double < 1 (default=.8) Scale factor between inner and outer circle. Returns ------- X : array of shape [n_samples, 2] The generated samples. y : array of shape [n_samples] The integer labels (0 or 1) for class membership of each sample. iis#'factor' has to be between 0 and 1.itendpointR R R6RN(RRR tlinspacetpiRtcostsintvstackRtTR R!R'RdR(RRvRL(R*RR€R tfactort n_samples_outt n_samples_inR7t linspace_outt linspace_int outer_circ_xt outer_circ_yt inner_circ_xt inner_circ_yR=R>((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pyt make_circlesCs(&   "" "c Csu|d}||}t|ƒ}tjtjdtj|ƒƒ}tjtjdtj|ƒƒ}dtjtjdtj|ƒƒ} dtjtjdtj|ƒƒd} tjtj|| ƒtj|| ƒgƒj} tj tj |dtj ƒtj |dtj ƒgƒ} |r=t | | d|ƒ\} } n|d k rk| |jd|d| jƒ7} n| | fS( s¾Make 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, optional (default=100) The total number of points generated. shuffle : bool, optional (default=True) Whether to shuffle the samples. noise : double or None (default=None) Standard deviation of Gaussian noise added to the data. random_state : int, RandomState instance or None (default) Determines random number generation for dataset shuffling and noise. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, 2] The generated samples. y : array of shape [n_samples] The integer labels (0 or 1) for class membership of each sample. iiigà?R R R6RN(RR R‡R…R†RˆR‰RRŠR R!R'RdR(RRvRL( R*RR€R RŒRR7RR‘R’R“R=R>((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pyt make_moons…s    !!%) "g$Àg$@c Cst|ƒ}t|tjƒr|d kr3d}nt|tjƒrt|}|j|d|dd||fƒ}qdt|ƒ}|jd}|jd}nÇt|ƒ}|d krÞ|j|d|dd||fƒ}nyt|ƒ|ksùt ‚WnNt k r"t dj |ƒƒ‚nBt k rJt dj ||ƒƒ‚nXt|ƒ}|jd}t |dƒr t|ƒ|kr t dj ||ƒƒ‚nt|tjƒrÍtjt|ƒ|ƒ}ng} g} t|tƒrñ|} nBt||ƒg|} x(t||ƒD]} | | cd7`. Parameters ---------- n_samples : int or array-like, optional (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. n_features : int, optional (default=2) The number of features for each sample. centers : int or array of shape [n_centers, n_features], optional (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 sequence of floats, optional (default=1.0) The standard deviation of the clusters. center_box : pair of floats (min, max), optional (default=(-10.0, 10.0)) The bounding box for each cluster center when centers are generated at random. shuffle : boolean, optional (default=True) Shuffle the samples. random_state : int, RandomState instance or None (default) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, n_features] The generated samples. y : array of shape [n_samples] The integer labels for cluster membership of each sample. Examples -------- >>> from sklearn.datasets.samples_generator 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]) See also -------- make_classification: a more intricate variant iiiRs8Parameter `centers` must be array-like. Got {!r} insteads`Length of `n_samples` not consistent with number of centers. Got n_samples = {} and centers = {}t__len__seLength of `clusters_std` not consistent with number of centers. Got centers = {} and cluster_std = {}tlocR6N(Rt isinstancetnumberstIntegralRtuniformRRLRtAssertionErrort TypeErrorRtformatthasattrtRealR tfulltIterableR RR%tzipRRvt concatenateRbRR)R(R*R+tcenterst cluster_stdt center_boxRR R7t n_centersR=R>tn_samples_per_centerR<RFtstdttotal_n_samplesRG((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pyt make_blobs¼sdC             !  (   cCsâ|dkrtdƒ‚nt|ƒ}|j||ƒ}dtjtj|dd…df|dd…dfƒd|dd…dfd dd|dd…d fd|dd…d f||j|ƒ}||fS( sMGenerate 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, optional (default=100) The number of samples. n_features : int, optional (default=10) The number of features. Should be at least 5. noise : float, optional (default=0.0) The standard deviation of the gaussian noise applied to the output. random_state : int, RandomState instance or None (default) Determines random number generation for dataset noise. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, n_features] The input samples. y : array 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. is!n_features must be at least five.i Niiiigà?ii(RRR#R RˆR†R$(R*R+R€R R7R=R>((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_friedman1Js 2  ŸcCsIt|ƒ}|j|dƒ}|dd…dfcd9<|dd…dfcdtj9<|dd…dfcdtj7<|dd…dfcd 9<|dd…dfcd7<|dd…dfd |dd…df|dd…d fd|dd…df|dd…dfd d ||j|ƒ}||fS( s£Generate 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, optional (default=100) The number of samples. noise : float, optional (default=0.0) The standard deviation of the gaussian noise applied to the output. random_state : int, RandomState instance or None (default) Determines random number generation for dataset noise. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, 4] The input samples. y : array 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. iNiidiii(ii igà?(RR#R R†R$(R*R€R R7R=R>((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_friedman2ˆs1 ##\cCsFt|ƒ}|j|dƒ}|dd…dfcd9<|dd…dfcdtj9<|dd…dfcdtj7<|dd…dfcd 9<|dd…dfcd7`. Parameters ---------- n_samples : int, optional (default=100) The number of samples. noise : float, optional (default=0.0) The standard deviation of the gaussian noise applied to the output. random_state : int, RandomState instance or None (default) Determines random number generation for dataset noise. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, 4] The input samples. y : array 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. iNiidiii(ii i(RR#R R†tarctanR$(R*R€R R7R=R>((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_friedman3És1 ##pcCsõt|ƒ}t||ƒ}tj|j||ƒddƒ\}}tj|j||ƒddƒ\} }tj|dtjƒ} d|tjd| |dƒ} |tjd| |ƒ} tj |ƒ| | } tj tj || ƒ| j ƒS(sÝGenerate a mostly low rank matrix with bell-shaped singular values Most of the variance can be explained by a bell-shaped curve of width effective_rank: the low rank part of the singular values profile is:: (1 - tail_strength) * exp(-1.0 * (i / effective_rank) ** 2) The remaining singular values' tail is fat, decreasing as:: tail_strength * exp(-0.1 * i / effective_rank). The low rank part of the profile can be considered the structured signal part of the data while the tail can be considered the noisy part of the data that cannot be summarized by a low number of linear components (singular vectors). This kind of singular profiles is often seen in practice, for instance: - gray level pictures of faces - TF-IDF vectors of text documents crawled from the web Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int, optional (default=100) The number of samples. n_features : int, optional (default=100) The number of features. effective_rank : int, optional (default=10) The approximate number of singular vectors required to explain most of the data by linear combinations. tail_strength : float between 0.0 and 1.0, optional (default=0.5) The relative importance of the fat noisy tail of the singular values profile. random_state : int, RandomState instance or None (default) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, n_features] The matrix. tmodeteconomicR igð¿igš™™™™™¹¿( RR{RtqrR$R R)RetexptidentityR&RŠ(R*R+RyRzR R7RFtuRTtvt singular_indtlow_rankttailts((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pyR| s2 ''c CsÚt|ƒ}|j||ƒ}|tjtj|dddƒƒ:}tj||fƒ}xSt|ƒD]E}tj|ƒ} |j| ƒ| | } |j|ƒ|| |f`. 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) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- data : array of shape [n_features, n_samples] The encoded signal (Y). dictionary : array of shape [n_features, n_components] The dictionary with normalized components (D). code : array of shape [n_components, n_samples] The sparse code such that each column of this matrix has exactly n_nonzero_coefs non-zero items (X). iRKi( RR$R tsqrtRR!RR)RR&tmapR}( R*t n_componentsR+tn_nonzero_coefsR R7tDR=R<tidxRr((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_sparse_coded_signalNs* &  cCs³t|ƒ}|jddddd||fƒ}|jd|dd…dfd|dd…dfd|dd…dfd|dd…d fdtj|ƒƒ}||fS( s«Generate 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, optional (default=100) The number of samples. n_features : int, optional (default=10) The number of features. random_state : int, RandomState instance or None (default) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, n_features] The input samples. y : array 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. R—iR6iRNigø?i(RRvR Rd(R*R+R R7R=R>((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_sparse_uncorrelatedŒs ( $ C-cCs}t|ƒ}|j||ƒ}tjtj|j|ƒƒ\}}}tjtj|dtj|j|ƒƒƒ|ƒ}|S(smGenerate 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) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_dim, n_dim] The random symmetric, positive-definite matrix. See also -------- make_sparse_spd_matrix gð?(RR#RtsvdR R&RŠtdiag(tn_dimR R7RDtUR»tVR=((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_spd_matrix¿s  '4gffffffî?gš™™™™™¹?gÍÌÌÌÌÌì?c Cst|ƒ}tj|ƒ }|j||ƒ}d|||k<||||jtj||kƒƒ|||k`. Parameters ---------- dim : integer, optional (default=1) The size of the random matrix to generate. alpha : float between 0 and 1, optional (default=0.95) The probability that a coefficient is zero (see notes). Larger values enforce more sparsity. norm_diag : boolean, optional (default=False) Whether to normalize the output matrix to make the leading diagonal elements all 1 smallest_coef : float between 0 and 1, optional (default=0.1) The value of the smallest coefficient. largest_coef : float between 0 and 1, optional (default=0.9) The value of the largest coefficient. random_state : int, RandomState instance or None (default) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- prec : sparse matrix of shape (dim, dim) The generated 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. See also -------- make_spd_matrix iR;iÿÿÿÿigð?( RR teyeR#Rttrilt permutationRŠR&RÅRRLR¼( tdimtalphat norm_diagt smallest_coeft largest_coefR tcholtauxRÌtprectd((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_sparse_spd_matrixàs$. * " c CsÁt|ƒ}dtjdd|jd|ƒ}|tj|ƒ}d|jd|ƒ}|tj|ƒ}tj|||fƒ}|||jd|ƒ7}|j}tj |ƒ}||fS(s1Generate a swiss roll dataset. Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int, optional (default=100) The number of sample points on the S curve. noise : float, optional (default=0.0) The standard deviation of the gaussian noise. random_state : int, RandomState instance or None (default) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, 3] The points. t : array 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", Chapter 10, 2009. http://seat.massey.ac.nz/personal/s.r.marsland/Code/10/lle.py gø?iiii( RR R†R#R‡RˆR¤R$RŠR}( R*R€R R7tttxR>tzR=((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_swiss_roll*s% % c CsÆt|ƒ}dtj|jd|ƒd}tj|ƒ}d|jd|ƒ}tj|ƒtj|ƒd}tj|||fƒ}|||jd|ƒ7}|j }tj |ƒ}||fS(s%Generate an S curve dataset. Read more in the :ref:`User Guide `. Parameters ---------- n_samples : int, optional (default=100) The number of sample points on the S curve. noise : float, optional (default=0.0) The standard deviation of the gaussian noise. random_state : int, RandomState instance or None (default) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, 3] The points. t : array of shape [n_samples] The univariate position of the sample according to the main dimension of the points in the manifold. iigà?g@( RR R†R#RˆtsignR‡R¤R$RŠR}( R*R€R R7R×RØR>RÙR=((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pyt make_s_curve^s !  ic CsB||krtdƒ‚nt|ƒ}|dkrEtj|ƒ}ntj|ƒ}|j||tj|ƒ|fƒ}tjtj ||tj dd…fdddƒƒ} || dd…f}||} tj tj tj |ƒ| ƒtj |d|| |ƒgƒ} |r8t|| d|ƒ\}} n|| fS(sGenerate 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 of shape [n_features], optional (default=None) The mean of the multi-dimensional normal distribution. If None then use the origin (0, 0, ...). cov : float, optional (default=1.) The covariance matrix will be this value times the unit matrix. This dataset only produces symmetric normal distributions. n_samples : int, optional (default=100) The total number of points equally divided among classes. n_features : int, optional (default=2) The number of features for each sample. n_classes : int, optional (default=3) The number of classes shuffle : boolean, optional (default=True) Shuffle the samples. random_state : int, RandomState instance or None (default) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape [n_samples, n_features] The generated samples. y : array 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. s$n_samples must be at least n_classesNiRKiR (RRRR R!Rbtmultivariate_normalRµtargsortRtnewaxisR trepeatR)R(( tmeantcovR*R+R/RR R7R=RÁtstepR>((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_gaussian_quantilesˆs 8    9 $cCs`t|ƒ}|j\}}|j|ƒ}|j|ƒ}||dd…|f}|||fS(N(RRLRÌ(tdataR R7tn_rowstn_colstrow_idxtcol_idxtresult((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pyt_shuffleÞs  cCsút|ƒ}|\}} |j|||ƒ} |j|tjd||ƒƒ} |j| tjd||ƒƒ} tjtd„tt|ƒ| ƒDƒƒƒ} tjtd„tt|ƒ| ƒDƒƒƒ}tj |dtj ƒ}xFt|ƒD]8}tj | |k||kƒ}||c| |7`. Parameters ---------- shape : iterable (n_rows, n_cols) The shape of the result. n_clusters : integer The number of biclusters. noise : float, optional (default=0.0) The standard deviation of the gaussian noise. minval : int, optional (default=10) Minimum value of a bicluster. maxval : int, optional (default=100) Maximum value of a bicluster. shuffle : boolean, optional (default=True) Shuffle the samples. random_state : int, RandomState instance or None (default) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape `shape` The generated array. rows : array of shape (n_clusters, X.shape[0],) The indicators for cluster membership of each row. cols : array of shape (n_clusters, X.shape[1],) The indicators for cluster membership of each column. 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. See also -------- make_checkerboard gð?css'|]\}}tj||ƒVqdS(N(R Rà(t.0tvaltrep((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pys *scss'|]\}}tj||ƒVqdS(N(R Rà(RìRíRî((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pys ,sR iR6R(RR›t multinomialR RàR RQR£RR!RetouterRvRLRëR‰(RLR9R€tminvaltmaxvalRR R7RæRçtconstst row_sizest col_sizest row_labelst col_labelsRêR<tselectorRèRéRVtrowstcols((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_biclustersçs47         "  ..cCsRt|ƒ}t|dƒr*|\}} n |}} |\} } |j| tjd||ƒƒ} |j| tjd| | ƒƒ} tjtd„tt|ƒ| ƒDƒƒƒ}tjtd„tt| ƒ| ƒDƒƒƒ}tj |dtj ƒ}xet|ƒD]W}xNt| ƒD]@}tj ||k||kƒ}||c|j ||ƒ7`. Parameters ---------- shape : iterable (n_rows, n_cols) The shape of the result. n_clusters : integer or iterable (n_row_clusters, n_column_clusters) The number of row and column clusters. noise : float, optional (default=0.0) The standard deviation of the gaussian noise. minval : int, optional (default=10) Minimum value of a bicluster. maxval : int, optional (default=100) Maximum value of a bicluster. shuffle : boolean, optional (default=True) Shuffle the samples. random_state : int, RandomState instance or None (default) Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Returns ------- X : array of shape `shape` The generated array. rows : array of shape (n_clusters, X.shape[0],) The indicators for cluster membership of each row. cols : array of shape (n_clusters, X.shape[1],) The indicators for cluster membership of each column. 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. See also -------- make_biclusters R–gð?css'|]\}}tj||ƒVqdS(N(R Rà(RìRíRî((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pys ‰scss'|]\}}tj||ƒVqdS(N(R Rà(RìRíRî((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pys ‹sR iR6R(RRŸRïR RàR RQR£RR!ReRðR›RvRLRëR‰(RLR9R€RñRòRR R7tn_row_clusterstn_col_clustersRæRçRôRõRöR÷RêR<tjRøRèRétlabelRTRùRú((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytmake_checkerboardBsB7         $ "   ( ((g$Àg$@(4t__doc__R™RbtnumpyR tscipyRt scipy.sparseR`Rft preprocessingRtutilsRRRR(t utils.fixesRR¢t utils.randomRt externalsRtmovesR½R£RRRjRIRRuRxRƒR”R•R¬R­R®R°R|RÂRÃRÉRÖRÚRÜRäRëRûR(((sAlib/python2.7/site-packages/sklearn/datasets/samples_generator.pytsn         Ù   ’0    w  A7 >A@ E =3 !  H4* T Z