ó ʽ÷Xc@`sŸdZddlmZmZmZddlZddlZddlmZddl Z ddl m Z ddl jjZddlmZddlmZidd 6dd 6d d 6d d6dd6dd6dd6ZdddfZdd dd ddddddddddd d!d"d#d$d%d&d'dd(d)d d*d+ddd,gZd-efd.„ƒYZd/„Zd0„Zd1„Zd2„Zd3„Zd4„Zd5„Zd6„Zd7„Z d8„Z!d9„Z"d d:d;„Z#dfd<„ƒYZ$e$dƒZ%e&e$ƒZ'd=„Z(e)e)d>„Z*e+d?„Z,d@„Z-dA„Z.e)dB„Z/d dC„Z0dD„Z1dE„Z2dF„Z3e+e+e)dG„Z4e+e+e)dH„Z5dI„Z6dJ„Z7dK„Z8dL„Z9dM„Z:dd e)e)dN„Z;dd:d d e)dO„Z<dP„Z=idQdR6dSdT6dUdV6ddW6de j>6Z?iddR6dXdY6dZe j>6Z@eAe?jBƒƒZCeCjDƒeAe@jBƒƒZEeEjDƒd[„ZFd\„ZGd]„ZHe)e)e)e)d^d_„ZId`dadbdcdddegZJdf„ZKdTe)e)eLdge)e+e+eLe+e+e)e)e)e+e)e)d^dh„ZMdi„ZNdj„ZOdk„ZPdl„ZQe j>eLdge)e+e+e+dmdngdgge)e+ggge)de)e)d^do„ZRdp„ZSdq„ZTdr„ZUds„ZVdt„ZWdS(usÍ ======================================================== Hierarchical clustering (:mod:`scipy.cluster.hierarchy`) ======================================================== .. currentmodule:: scipy.cluster.hierarchy These functions cut hierarchical clusterings into flat clusterings or find the roots of the forest formed by a cut by providing the flat cluster ids of each observation. .. autosummary:: :toctree: generated/ fcluster fclusterdata leaders These are routines for agglomerative clustering. .. autosummary:: :toctree: generated/ linkage single complete average weighted centroid median ward These routines compute statistics on hierarchies. .. autosummary:: :toctree: generated/ cophenet from_mlab_linkage inconsistent maxinconsts maxdists maxRstat to_mlab_linkage Routines for visualizing flat clusters. .. autosummary:: :toctree: generated/ dendrogram These are data structures and routines for representing hierarchies as tree objects. .. autosummary:: :toctree: generated/ ClusterNode leaves_list to_tree cut_tree These are predicates for checking the validity of linkage and inconsistency matrices as well as for checking isomorphism of two flat cluster assignments. .. autosummary:: :toctree: generated/ is_valid_im is_valid_linkage is_isomorphic is_monotonic correspond num_obs_linkage Utility routines for plotting: .. autosummary:: :toctree: generated/ set_link_color_palette References ---------- .. [1] "Statistics toolbox." API Reference Documentation. The MathWorks. http://www.mathworks.com/access/helpdesk/help/toolbox/stats/. Accessed October 1, 2007. .. [2] "Hierarchical clustering." API Reference Documentation. The Wolfram Research, Inc. http://reference.wolfram.com/mathematica/HierarchicalClustering/tutorial/ HierarchicalClustering.html. Accessed October 1, 2007. .. [3] Gower, JC and Ross, GJS. "Minimum Spanning Trees and Single Linkage Cluster Analysis." Applied Statistics. 18(1): pp. 54--64. 1969. .. [4] Ward Jr, JH. "Hierarchical grouping to optimize an objective function." Journal of the American Statistical Association. 58(301): pp. 236--44. 1963. .. [5] Johnson, SC. "Hierarchical clustering schemes." Psychometrika. 32(2): pp. 241--54. 1966. .. [6] Sneath, PH and Sokal, RR. "Numerical taxonomy." Nature. 193: pp. 855--60. 1962. .. [7] Batagelj, V. "Comparing resemblance measures." Journal of Classification. 12: pp. 73--90. 1995. .. [8] Sokal, RR and Michener, CD. "A statistical method for evaluating systematic relationships." Scientific Bulletins. 38(22): pp. 1409--38. 1958. .. [9] Edelbrock, C. "Mixture model tests of hierarchical clustering algorithms: the problem of classifying everybody." Multivariate Behavioral Research. 14: pp. 367--84. 1979. .. [10] Jain, A., and Dubes, R., "Algorithms for Clustering Data." Prentice-Hall. Englewood Cliffs, NJ. 1988. .. [11] Fisher, RA "The use of multiple measurements in taxonomic problems." Annals of Eugenics, 7(2): 179-188. 1936 * MATLAB and MathWorks are registered trademarks of The MathWorks, Inc. * Mathematica is a registered trademark of The Wolfram Research, Inc. i(tdivisiontprint_functiontabsolute_importN(tdequei(t _hierarchy(t string_types(txrangetsingletcompleteitaverageitcentroiditmedianitwarditweightedt ClusterNodetcophenett correspondtcut_treet dendrogramtfclustert fclusterdatatfrom_mlab_linkaget inconsistentt is_isomorphict is_monotonict is_valid_imtis_valid_linkagetleaderst leaves_listtlinkagetmaxRstattmaxdistst maxinconststnum_obs_linkagetset_link_color_palettetto_mlab_linkagetto_treetdistancetClusterWarningcB`seZRS((t__name__t __module__(((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR&ÅscC`stjd|tddƒdS(Nsscipy.cluster: %st stackleveli(twarningstwarnR&(ts((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt_warningÉscC`sL|jdk r|jƒStj|tjƒrDtj|dtjƒS|SdS(s@ Copies the array if its base points to a parent array. tdtypeN(tbasetNonetcopytnpt issubsctypetfloat32tarraytdouble(ta((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt_copy_array_if_base_presentÍs  cC`s#g|D]}t|ƒ^q}|S(sþ Accepts a tuple of arrays T. Copies the array T[i] if its base array points to an actual array. Otherwise, the reference is just copied. This is useful if the arrays are being passed to a C function that does not do proper striding. (R8(tTR7tl((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt_copy_arrays_if_base_presentÙscC`s=|dkr-tjj||ddƒ}n tdƒ‚|S(s| Generates a random distance matrix stored in condensed form. A pnts * (pnts - 1) / 2 sized vector is returned. iis?The number of points in the distance matrix must be at least 2.(R2trandomtrandt ValueError(tpntstD((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt_randdmäs ! cC`st|ddddƒS(sÐ Performs single/min/nearest linkage on the condensed distance matrix ``y`` Parameters ---------- y : ndarray The upper triangular of the distance matrix. The result of ``pdist`` is returned in this form. Returns ------- Z : ndarray The linkage matrix. See Also -------- linkage: for advanced creation of hierarchical clusterings. scipy.spatial.distance.pdist : pairwise distance metrics tmethodRtmetrict euclidean(R(ty((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRðscC`st|ddddƒS(sV Performs complete/max/farthest point linkage on a condensed distance matrix Parameters ---------- y : ndarray The upper triangular of the distance matrix. The result of ``pdist`` is returned in this form. Returns ------- Z : ndarray A linkage matrix containing the hierarchical clustering. See the `linkage` function documentation for more information on its structure. See Also -------- linkage: for advanced creation of hierarchical clusterings. scipy.spatial.distance.pdist : pairwise distance metrics RBRRCRD(R(RE((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRscC`st|ddddƒS(s% Performs average/UPGMA linkage on a condensed distance matrix Parameters ---------- y : ndarray The upper triangular of the distance matrix. The result of ``pdist`` is returned in this form. Returns ------- Z : ndarray A linkage matrix containing the hierarchical clustering. See `linkage` for more information on its structure. See Also -------- linkage: for advanced creation of hierarchical clusterings. scipy.spatial.distance.pdist : pairwise distance metrics RBR RCRD(R(RE((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR "scC`st|ddddƒS(s} Performs weighted/WPGMA linkage on the condensed distance matrix. See `linkage` for more information on the return structure and algorithm. Parameters ---------- y : ndarray The upper triangular of the distance matrix. The result of ``pdist`` is returned in this form. Returns ------- Z : ndarray A linkage matrix containing the hierarchical clustering. See `linkage` for more information on its structure. See Also -------- linkage : for advanced creation of hierarchical clusterings. scipy.spatial.distance.pdist : pairwise distance metrics RBR RCRD(R(RE((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR ;scC`st|ddddƒS(sc Performs centroid/UPGMC linkage. See `linkage` for more information on the input matrix, return structure, and algorithm. The following are common calling conventions: 1. ``Z = centroid(y)`` Performs centroid/UPGMC linkage on the condensed distance matrix ``y``. 2. ``Z = centroid(X)`` Performs centroid/UPGMC linkage on the observation matrix ``X`` using Euclidean distance as the distance metric. Parameters ---------- y : ndarray A condensed distance matrix. A condensed distance matrix is a flat array containing the upper triangular of the distance matrix. This is the form that ``pdist`` returns. Alternatively, a collection of m observation vectors in n dimensions may be passed as a m by n array. Returns ------- Z : ndarray A linkage matrix containing the hierarchical clustering. See the `linkage` function documentation for more information on its structure. See Also -------- linkage: for advanced creation of hierarchical clusterings. RBR RCRD(R(RE((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR Ws)cC`st|ddddƒS(sÖ Performs median/WPGMC linkage. See `linkage` for more information on the return structure and algorithm. The following are common calling conventions: 1. ``Z = median(y)`` Performs median/WPGMC linkage on the condensed distance matrix ``y``. See ``linkage`` for more information on the return structure and algorithm. 2. ``Z = median(X)`` Performs median/WPGMC linkage on the observation matrix ``X`` using Euclidean distance as the distance metric. See `linkage` for more information on the return structure and algorithm. Parameters ---------- y : ndarray A condensed distance matrix. A condensed distance matrix is a flat array containing the upper triangular of the distance matrix. This is the form that ``pdist`` returns. Alternatively, a collection of m observation vectors in n dimensions may be passed as a m by n array. Returns ------- Z : ndarray The hierarchical clustering encoded as a linkage matrix. See Also -------- linkage: for advanced creation of hierarchical clusterings. scipy.spatial.distance.pdist : pairwise distance metrics RBR RCRD(R(RE((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR ƒs*cC`st|ddddƒS(s‚ Performs Ward's linkage on a condensed distance matrix. See `linkage` for more information on the return structure and algorithm. The following are common calling conventions: 1. ``Z = ward(y)`` Performs Ward's linkage on the condensed distance matrix ``y``. 2. ``Z = ward(X)`` Performs Ward's linkage on the observation matrix ``X`` using Euclidean distance as the distance metric. Parameters ---------- y : ndarray A condensed distance matrix. A condensed distance matrix is a flat array containing the upper triangular of the distance matrix. This is the form that ``pdist`` returns. Alternatively, a collection of m observation vectors in n dimensions may be passed as a m by n array. Returns ------- Z : ndarray The hierarchical clustering encoded as a linkage matrix. See `linkage` for more information on the return structure and algorithm. See Also -------- linkage: for advanced creation of hierarchical clusterings. scipy.spatial.distance.pdist : pairwise distance metrics RBR RCRD(R(RE((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR °s'RDcC`sã|tkr$tdj|ƒƒ‚nttj|ddƒƒ}|jdkr|tj|dt ddƒt |gƒ\}nÏ|jdkr?|t kr»|d kr»td j|ƒƒ‚n|j d |j dkr*tj tj|ƒd ƒr*tj|d kƒr*tj ||jƒr*td ƒq*ntj||ƒ}n td ƒ‚tjtj|ƒƒsrtdƒ‚nttj|ƒƒ}t|}|dkr­tj||ƒS|dkrÌtj|||ƒStj|||ƒSdS(s Performs hierarchical/agglomerative clustering. The input y may be either a 1d compressed distance matrix or a 2d array of observation vectors. If y is a 1d compressed distance matrix, then y must be a :math:`{n \choose 2}` sized vector where n is the number of original observations paired in the distance matrix. The behavior of this function is very similar to the MATLAB linkage function. A :math:`(n-1)` by 4 matrix ``Z`` is returned. At the :math:`i`-th iteration, clusters with indices ``Z[i, 0]`` and ``Z[i, 1]`` are combined to form cluster :math:`n + i`. A cluster with an index less than :math:`n` corresponds to one of the :math:`n` original observations. The distance between clusters ``Z[i, 0]`` and ``Z[i, 1]`` is given by ``Z[i, 2]``. The fourth value ``Z[i, 3]`` represents the number of original observations in the newly formed cluster. The following linkage methods are used to compute the distance :math:`d(s, t)` between two clusters :math:`s` and :math:`t`. The algorithm begins with a forest of clusters that have yet to be used in the hierarchy being formed. When two clusters :math:`s` and :math:`t` from this forest are combined into a single cluster :math:`u`, :math:`s` and :math:`t` are removed from the forest, and :math:`u` is added to the forest. When only one cluster remains in the forest, the algorithm stops, and this cluster becomes the root. A distance matrix is maintained at each iteration. The ``d[i,j]`` entry corresponds to the distance between cluster :math:`i` and :math:`j` in the original forest. At each iteration, the algorithm must update the distance matrix to reflect the distance of the newly formed cluster u with the remaining clusters in the forest. Suppose there are :math:`|u|` original observations :math:`u[0], \ldots, u[|u|-1]` in cluster :math:`u` and :math:`|v|` original objects :math:`v[0], \ldots, v[|v|-1]` in cluster :math:`v`. Recall :math:`s` and :math:`t` are combined to form cluster :math:`u`. Let :math:`v` be any remaining cluster in the forest that is not :math:`u`. The following are methods for calculating the distance between the newly formed cluster :math:`u` and each :math:`v`. * method='single' assigns .. math:: d(u,v) = \min(dist(u[i],v[j])) for all points :math:`i` in cluster :math:`u` and :math:`j` in cluster :math:`v`. This is also known as the Nearest Point Algorithm. * method='complete' assigns .. math:: d(u, v) = \max(dist(u[i],v[j])) for all points :math:`i` in cluster u and :math:`j` in cluster :math:`v`. This is also known by the Farthest Point Algorithm or Voor Hees Algorithm. * method='average' assigns .. math:: d(u,v) = \sum_{ij} \frac{d(u[i], v[j])} {(|u|*|v|)} for all points :math:`i` and :math:`j` where :math:`|u|` and :math:`|v|` are the cardinalities of clusters :math:`u` and :math:`v`, respectively. This is also called the UPGMA algorithm. * method='weighted' assigns .. math:: d(u,v) = (dist(s,v) + dist(t,v))/2 where cluster u was formed with cluster s and t and v is a remaining cluster in the forest. (also called WPGMA) * method='centroid' assigns .. math:: dist(s,t) = ||c_s-c_t||_2 where :math:`c_s` and :math:`c_t` are the centroids of clusters :math:`s` and :math:`t`, respectively. When two clusters :math:`s` and :math:`t` are combined into a new cluster :math:`u`, the new centroid is computed over all the original objects in clusters :math:`s` and :math:`t`. The distance then becomes the Euclidean distance between the centroid of :math:`u` and the centroid of a remaining cluster :math:`v` in the forest. This is also known as the UPGMC algorithm. * method='median' assigns :math:`d(s,t)` like the ``centroid`` method. When two clusters :math:`s` and :math:`t` are combined into a new cluster :math:`u`, the average of centroids s and t give the new centroid :math:`u`. This is also known as the WPGMC algorithm. * method='ward' uses the Ward variance minimization algorithm. The new entry :math:`d(u,v)` is computed as follows, .. math:: d(u,v) = \sqrt{\frac{|v|+|s|} {T}d(v,s)^2 + \frac{|v|+|t|} {T}d(v,t)^2 - \frac{|v|} {T}d(s,t)^2} where :math:`u` is the newly joined cluster consisting of clusters :math:`s` and :math:`t`, :math:`v` is an unused cluster in the forest, :math:`T=|v|+|s|+|t|`, and :math:`|*|` is the cardinality of its argument. This is also known as the incremental algorithm. Warning: When the minimum distance pair in the forest is chosen, there may be two or more pairs with the same minimum distance. This implementation may chose a different minimum than the MATLAB version. Parameters ---------- y : ndarray A condensed distance matrix. A condensed distance matrix is a flat array containing the upper triangular of the distance matrix. This is the form that ``pdist`` returns. Alternatively, a collection of :math:`m` observation vectors in :math:`n` dimensions may be passed as an :math:`m` by :math:`n` array. All elements of the condensed distance matrix must be finite, i.e. no NaNs or infs. method : str, optional The linkage algorithm to use. See the ``Linkage Methods`` section below for full descriptions. metric : str or function, optional The distance metric to use in the case that y is a collection of observation vectors; ignored otherwise. See the ``pdist`` function for a list of valid distance metrics. A custom distance function can also be used. Returns ------- Z : ndarray The hierarchical clustering encoded as a linkage matrix. Notes ----- 1. For method 'single' an optimized algorithm based on minimum spanning tree is implemented. It has time complexity :math:`O(n^2)`. For methods 'complete', 'average', 'weighted' and 'ward' an algorithm called nearest-neighbors chain is implemented. It also has time complexity :math:`O(n^2)`. For other methods a naive algorithm is implemented with :math:`O(n^3)` time complexity. All algorithms use :math:`O(n^2)` memory. Refer to [1]_ for details about the algorithms. 2. Methods 'centroid', 'median' and 'ward' are correctly defined only if Euclidean pairwise metric is used. If `y` is passed as precomputed pairwise distances, then it is a user responsibility to assure that these distances are in fact Euclidean, otherwise the produced result will be incorrect. See Also -------- scipy.spatial.distance.pdist : pairwise distance metrics References ---------- .. [1] Daniel Mullner, "Modern hierarchical, agglomerative clustering algorithms", :arXiv:`1109.2378v1`. sInvalid method: {0}tordertcitthrowtnameREiRDs9Method '{0}' requires the distance metric to be EuclideaniskThe symmetric non-negative hollow observation matrix looks suspiciously like an uncondensed distance matrixs`y` must be 1 or 2 dimensional.s>The condensed distance matrix must contain only finite values.RRR R R N(scompletesaveragesweightedsward(t_LINKAGE_METHODSR>tformatt_convert_to_doubleR2tasarraytndimR%t is_valid_ytTrueR;t_EUCLIDEAN_METHODStshapetallclosetdiagtallR9R-tpdisttisfinitetintt num_obs_yRtmst_single_linkagetnn_chaint fast_linkage(RERBRCtnt method_code((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRÚs0´  5*    cB`szeZdZddddd„Zd„Zd„Zd„Zd„Zd„Z d „Z d „Z d „Z d „d „Z RS(s1 A tree node class for representing a cluster. Leaf nodes correspond to original observations, while non-leaf nodes correspond to non-singleton clusters. The `to_tree` function converts a matrix returned by the linkage function into an easy-to-use tree representation. All parameter names are also attributes. Parameters ---------- id : int The node id. left : ClusterNode instance, optional The left child tree node. right : ClusterNode instance, optional The right child tree node. dist : float, optional Distance for this cluster in the linkage matrix. count : int, optional The number of samples in this cluster. See Also -------- to_tree : for converting a linkage matrix ``Z`` into a tree object. iicC`sæ|dkrtdƒ‚n|dkr6tdƒ‚n|dkrN|dk sf|dk ru|dkrutdƒ‚n|dkrtdƒ‚n||_||_||_||_|jdkrÏ||_n|j|j|_dS(NisThe id must be non-negative.s"The distance must be non-negative.sIOnly full or proper binary trees are permitted. This node has one child.is9A cluster must contain at least one original observation.(R>R0tidtlefttrighttdisttcount(tselfR_R`RaRbRc((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt__init__Ïs         cC`s=t|tƒs-tdjt|ƒƒƒ‚n|j|jkS(Ns$Can't compare ClusterNode to type {}(t isinstanceRR>RKttypeRb(Rdtnode((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt__lt__äs cC`s=t|tƒs-tdjt|ƒƒƒ‚n|j|jkS(Ns$Can't compare ClusterNode to type {}(RfRR>RKRgRb(RdRh((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt__gt__ês cC`s=t|tƒs-tdjt|ƒƒƒ‚n|j|jkS(Ns$Can't compare ClusterNode to type {}(RfRR>RKRgRb(RdRh((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt__eq__ðs cC`s|jS(sK The identifier of the target node. For ``0 <= i < n``, `i` corresponds to original observation i. For ``n <= i < 2n-1``, `i` corresponds to non-singleton cluster formed at iteration ``i-n``. Returns ------- id : int The identifier of the target node. (R_(Rd((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pytget_idöscC`s|jS(s The number of leaf nodes (original observations) belonging to the cluster node nd. If the target node is a leaf, 1 is returned. Returns ------- get_count : int The number of leaf nodes below the target node. (Rc(Rd((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt get_counts cC`s|jS(så Return a reference to the left child tree object. Returns ------- left : ClusterNode The left child of the target node. If the node is a leaf, None is returned. (R`(Rd((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pytget_lefts cC`s|jS(sè Returns a reference to the right child tree object. Returns ------- right : ClusterNode The left child of the target node. If the node is a leaf, None is returned. (Ra(Rd((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt get_right!s cC`s |jdkS(sª Returns True if the target node is a leaf. Returns ------- leafness : bool True if the target node is a leaf node. N(R`R0(Rd((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pytis_leaf.s cC`s|jS(N(R_(tx((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt:sc C`s|j}dgd|}tƒ}tƒ}||d>> from scipy import cluster >>> np.random.seed(23) >>> X = np.random.randn(50, 4) >>> Z = cluster.hierarchy.ward(X) >>> cutree = cluster.hierarchy.cut_tree(Z, n_clusters=[5, 10]) >>> cutree[:10] array([[0, 0], [1, 1], [2, 2], [3, 3], [3, 4], [2, 2], [0, 0], [1, 5], [3, 6], [4, 7]]) s8At least one of either height or n_clusters must be NoneiR.iN(R!R‡R0R>R2tarangeR5Rbt searchsortedtlent TypeErrortzerosRXt enumerateR~R1tmintmaxtwhereR9(Rƒt n_clusterstheighttnobsR†tcols_idxRqtheightstn_colstgroupst last_grouptiRhtidxt this_group((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR™s8,   %      $ cC`sŽtj|ddƒ}t|dtddƒ|jdd}d g|dd}x'td|ƒD]}t|ƒ||>> from scipy.cluster import hierarchy >>> x = np.random.rand(10).reshape(5, 2) >>> Z = hierarchy.linkage(x) >>> hierarchy.to_tree(Z) >> rootnode, nodelist = hierarchy.to_tree(Z, rd=True) >>> rootnode >> len(nodelist) 9 RFRGRHRIRƒiiis_Corrupt matrix Z. Index to derivative cluster is used before it is formed. See row %d, column 0s_Corrupt matrix Z. Index to derivative cluster is used before it is formed. See row %d, column 1is1Corrupt matrix Z. The count Z[%d,3] is incorrect.N( R2RMRRPRRR0RRRXR>Rc(RƒtrdR]tdR™R|tfitfj((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR$ês0:  +  cC`s@|jtkr!|jtƒ}n|jjs<|jƒ}n|S(N(R.tbooltastypetflagst contiguousR1(tX((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt_convert_to_boolKs  cC`sF|jtjkr'|jtjƒ}n|jjsB|jƒ}n|S(N(R.R2R6R¡R¢R£R1(R¤((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRLSs  c C`sFtj|ddƒ}t|dtddƒ|j}|dd}tj||ddd tjƒ}t|ƒ}tj ||t |ƒƒ|d kr›|Stj|ddƒ}t j |dtdd ƒ|jƒ}|jƒ}||}||}||} |d} |d} | jƒtj| jƒ| jƒƒ} | |fS( s­ Calculates the cophenetic distances between each observation in the hierarchical clustering defined by the linkage ``Z``. Suppose ``p`` and ``q`` are original observations in disjoint clusters ``s`` and ``t``, respectively and ``s`` and ``t`` are joined by a direct parent cluster ``u``. The cophenetic distance between observations ``i`` and ``j`` is simply the distance between clusters ``s`` and ``t``. Parameters ---------- Z : ndarray The hierarchical clustering encoded as an array (see `linkage` function). Y : ndarray (optional) Calculates the cophenetic correlation coefficient ``c`` of a hierarchical clustering defined by the linkage matrix `Z` of a set of :math:`n` observations in :math:`m` dimensions. `Y` is the condensed distance matrix from which `Z` was generated. Returns ------- c : ndarray The cophentic correlation distance (if ``Y`` is passed). d : ndarray The cophenetic distance matrix in condensed form. The :math:`ij` th entry is the cophenetic distance between original observations :math:`i` and :math:`j`. RFRGRHRIRƒiiiR.tYN(R2RMRRPRRRŒR6RLRtcophenetic_distancesRXR0R%ROtmeantsumtsqrt( RƒR¦tZsR]tzztzREtYytZzt numeratortdenomAtdenomBRG((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR[s(" $         )cC`sÍtj|ddƒ}|j}t|dtddƒ|tj|ƒk sV|dkretdƒ‚nt|gƒ\}|dd}tj|dd fd tj ƒ}t j ||t |ƒt |ƒƒ|S( s= Calculates inconsistency statistics on a linkage matrix. Parameters ---------- Z : ndarray The :math:`(n-1)` by 4 matrix encoding the linkage (hierarchical clustering). See `linkage` documentation for more information on its form. d : int, optional The number of links up to `d` levels below each non-singleton cluster. Returns ------- R : ndarray A :math:`(n-1)` by 5 matrix where the ``i``'th row contains the link statistics for the non-singleton cluster ``i``. The link statistics are computed over the link heights for links :math:`d` levels below the cluster ``i``. ``R[i,0]`` and ``R[i,1]`` are the mean and standard deviation of the link heights, respectively; ``R[i,2]`` is the number of links included in the calculation; and ``R[i,3]`` is the inconsistency coefficient, .. math:: \frac{\mathtt{Z[i,2]} - \mathtt{R[i,0]}} {R[i,1]} Notes ----- This function behaves similarly to the MATLAB(TM) ``inconsistent`` function. RFRGRHRIRƒis:The second argument d must be a nonnegative integer value.iiR.( R2RMRRRRPtfloorR>R;RŒR6RRRX(RƒRR«R]tR((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR™s  """c C`s˜tj|dtjddƒ}|j}t|ƒdks[t|ƒdkre|ddkre|jƒSt|ƒdkr†tdƒ‚n|ddkr |jƒS|jƒ}|dd…dd…fjƒd kr|dd…dd…fjƒd|dkrtd ƒ‚n|dd…dd…fcd 8RŽRRŒRtcalculate_cluster_sizesRXthstacktreshape(RƒR«tZparttCS((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRÌs 4   X"!cC`sÃtj|dddtjƒ}|j}t|ƒdks[t|ƒdkre|ddkre|jƒSt|dtddƒ|d d …dd …fjƒ}|d d …dd …fcd 7<|S( sÅ Converts a linkage matrix to a MATLAB(TM) compatible one. Converts a linkage matrix ``Z`` generated by the linkage function of this module to a MATLAB(TM) compatible one. The return linkage matrix has the last column removed and the cluster indices are converted to ``1..N`` indexing. Parameters ---------- Z : ndarray A linkage matrix generated by ``scipy.cluster.hierarchy``. Returns ------- to_mlab_linkage : ndarray A linkage matrix compatible with MATLAB(TM)'s hierarchical clustering functions. The return linkage matrix has the last column removed and the cluster indices are converted to ``1..N`` indexing. RFRGR.iiRHRIRƒNiigð?(R2RMR6RRRŠR1RRP(RƒR«tZP((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR#s 4 ""cC`s[tj|ddƒ}t|dtddƒ|dd…df|dd …dfkjƒS( s¿ Returns True if the linkage passed is monotonic. The linkage is monotonic if for every cluster :math:`s` and :math:`t` joined, the distance between them is no less than the distance between any previously joined clusters. Parameters ---------- Z : ndarray The linkage matrix to check for monotonicity. Returns ------- b : bool A boolean indicating whether the linkage is monotonic. RFRGRHRIRƒiNiiÿÿÿÿ(R2RMRRPRU(Rƒ((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR$scC`sÚtj|ddƒ}t}|r+d|nd}ydt|ƒtjkr\td|ƒ‚n|jtjkrtd|ƒ‚nt|j ƒdkr©t d|ƒ‚n|j d d krÏt d |ƒ‚n|j d d krõt d |ƒ‚n|dd…d fd kj ƒr*t d|ƒ‚n|dd…d fd kj ƒr_t d|ƒ‚n|dd…dfd kj ƒr”t d|ƒ‚nWn>t k rÕ}|r³‚n|rÌt t|ƒƒnt}nX|S(s'Returns True if the inconsistency matrix passed is valid. It must be a :math:`n` by 4 array of doubles. The standard deviations ``R[:,1]`` must be nonnegative. The link counts ``R[:,2]`` must be positive and no greater than :math:`n-1`. Parameters ---------- R : ndarray The inconsistency matrix to check for validity. warning : bool, optional When True, issues a Python warning if the linkage matrix passed is invalid. throw : bool, optional When True, throws a Python exception if the linkage matrix passed is invalid. name : str, optional This string refers to the variable name of the invalid linkage matrix. Returns ------- b : bool True if the inconsistency matrix is valid. RFRGs%r ts?Variable %spassed as inconsistency matrix is not a numpy array.s5Inconsistency matrix %smust contain doubles (double).isCInconsistency matrix %smust have shape=2 (i.e. be two-dimensional).iis+Inconsistency matrix %smust have 4 columns.is2Inconsistency matrix %smust have at least one row.Ns;Inconsistency matrix %scontains negative link height means.sIInconsistency matrix %scontains negative link height standard deviations.s5Inconsistency matrix %scontains negative link counts.(R2RMRPRgtndarrayR‹R.R6RŠRRR>tanyt ExceptionR-tstrtFalse(R´twarningRHRItvalidtname_strte((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR>sF     " " " cC`sRtj|ddƒ}t}|r+d|nd}yÜt|ƒtjkr\td|ƒ‚n|jtjkrtd|ƒ‚nt|j ƒdkr©t d|ƒ‚n|j d d krÏt d |ƒ‚n|j d d krñt d ƒ‚n|j d }|d krÎ|dd…d fd kj ƒsN|dd…d fd kj ƒrat d|ƒ‚n|dd…dfd kj ƒr–t d|ƒ‚n|dd…dfd kj ƒrÎt d|ƒ‚qÎnt |ƒrít d|ƒ‚nt |ƒr t d|ƒ‚nWn>tk rM}|r+‚n|rDtt|ƒƒnt}nX|S(s Checks the validity of a linkage matrix. A linkage matrix is valid if it is a two dimensional array (type double) with :math:`n` rows and 4 columns. The first two columns must contain indices between 0 and :math:`2n-1`. For a given row ``i``, the following two expressions have to hold: .. math:: 0 \leq \mathtt{Z[i,0]} \leq i+n-1 0 \leq Z[i,1] \leq i+n-1 I.e. a cluster cannot join another cluster unless the cluster being joined has been generated. Parameters ---------- Z : array_like Linkage matrix. warning : bool, optional When True, issues a Python warning if the linkage matrix passed is invalid. throw : bool, optional When True, throws a Python exception if the linkage matrix passed is invalid. name : str, optional This string refers to the variable name of the invalid linkage matrix. Returns ------- b : bool True if the inconsistency matrix is valid. RFRGs%r R»s/Passed linkage argument %sis not a valid array.s&Linkage matrix %smust contain doubles.is=Linkage matrix %smust have shape=2 (i.e. be two-dimensional).iis%Linkage matrix %smust have 4 columns.is6Linkage must be computed on at least two observations.Ns$Linkage %scontains negative indices.s&Linkage %scontains negative distances.is#Linkage %scontains negative counts.s9Linkage %suses non-singleton cluster before it is formed.s/Linkage %suses the same cluster more than once.(R2RMRPRgR¼R‹R.R6RŠRRR>R½t+_check_hierarchy_uses_cluster_before_formedt,_check_hierarchy_uses_cluster_more_than_onceR¾R-R¿RÀ(RƒRÁRHRIRÂRÃR]RÄ((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRsP%    D " "    cC`sk|jdd}xStd|dƒD]>}||df||ks_||df||kr%tSq%WtS(Nii(RRRRPRÀ(RƒR]R™((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRÅÐs 4cC`s½|jdd}tgƒ}x™td|dƒD]„}||df|ksƒ||df|ksƒ||df||dfkr‡tS|j||dfƒ|j||dfƒq1WtS(Nii(RRRsRRPRuRÀ(RƒR]tchosenR™((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRÆØs LcC`s«|jdd}tgƒ}xUtd|dƒD]@}|jt||dfƒƒ|jt||dfƒƒq1Wttdd|dƒƒ}t|j|ƒƒdkS(Niii(RRRsRRuRXtrangeRŠt difference(RƒR]RÇR™t must_chosen((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt&_check_hierarchy_not_all_clusters_usedãs !cC`s:tj|ddƒ}t|dtddƒ|jddS(s& Returns the number of original observations of the linkage matrix passed. Parameters ---------- Z : ndarray The linkage matrix on which to perform the operation. Returns ------- n : int The number of original observations in the linkage. RFRGRHRIRƒii(R2RMRRPRR(Rƒ((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR!íscC`sft|dtƒtj|dtƒtj|ddƒ}tj|ddƒ}tj|ƒt|ƒkS(sÐ Checks for correspondence between linkage and condensed distance matrices They must have the same number of original observations for the check to succeed. This function is useful as a sanity check in algorithms that make extensive use of linkage and distance matrices that must correspond to the same set of original observations. Parameters ---------- Z : array_like The linkage matrix to check for correspondence. Y : array_like The condensed distance matrix to check for correspondence. Returns ------- b : bool A boolean indicating whether the linkage matrix and distance matrix could possibly correspond to one another. RHRFRG(RRPR%ROR2RMRYR!(RƒR¦((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRs cC`sýtj|ddƒ}t|dtddƒ|jdd}tj|fdd ƒ}t|gƒ\}|d krõ|dkrt||ƒ}n=tj|ddƒ}t |dtdd ƒt|gƒ\}t j |||t |ƒt |ƒƒn|d kr&t j||t |ƒt |ƒƒnÓ|d krWt j||t |ƒt |ƒƒn¢|dkrt|gƒ\}t j|||t |ƒt |ƒƒn\|dkrãt|gƒ\}t j|||t |ƒt |ƒƒntdt|ƒƒ‚|S(s$ Forms flat clusters from the hierarchical clustering defined by the given linkage matrix. Parameters ---------- Z : ndarray The hierarchical clustering encoded with the matrix returned by the `linkage` function. t : float The threshold to apply when forming flat clusters. criterion : str, optional The criterion to use in forming flat clusters. This can be any of the following values: ``inconsistent`` : If a cluster node and all its descendants have an inconsistent value less than or equal to `t` then all its leaf descendants belong to the same flat cluster. When no non-singleton cluster meets this criterion, every node is assigned to its own cluster. (Default) ``distance`` : Forms flat clusters so that the original observations in each flat cluster have no greater a cophenetic distance than `t`. ``maxclust`` : Finds a minimum threshold ``r`` so that the cophenetic distance between any two original observations in the same flat cluster is no more than ``r`` and no more than `t` flat clusters are formed. ``monocrit`` : Forms a flat cluster from a cluster node c with index i when ``monocrit[j] <= t``. For example, to threshold on the maximum mean distance as computed in the inconsistency matrix R with a threshold of 0.8 do:: MR = maxRstat(Z, R, 3) cluster(Z, t=0.8, criterion='monocrit', monocrit=MR) ``maxclust_monocrit`` : Forms a flat cluster from a non-singleton cluster node ``c`` when ``monocrit[i] <= r`` for all cluster indices ``i`` below and including ``c``. ``r`` is minimized such that no more than ``t`` flat clusters are formed. monocrit must be monotonic. For example, to minimize the threshold t on maximum inconsistency values so that no more than 3 flat clusters are formed, do:: MI = maxinconsts(Z, R) cluster(Z, t=3, criterion='maxclust_monocrit', monocrit=MI) depth : int, optional The maximum depth to perform the inconsistency calculation. It has no meaning for the other criteria. Default is 2. R : ndarray, optional The inconsistency matrix to use for the 'inconsistent' criterion. This matrix is computed if not provided. monocrit : ndarray, optional An array of length n-1. `monocrit[i]` is the statistics upon which non-singleton i is thresholded. The monocrit vector must be monotonic, i.e. given a node c with index i, for all node indices j corresponding to nodes below c, ``monocrit[i] >= monocrit[j]``. Returns ------- fcluster : ndarray An array of length ``n``. ``T[i]`` is the flat cluster number to which original observation ``i`` belongs. RFRGRHRIRƒiiR.R™RR´R%tmaxclusttmonocrittmaxclust_monocrits'Invalid cluster formation criterion: %sN(R2RMRRPRRRŒR;R0RRRt cluster_intfloatRXt cluster_disttcluster_maxclust_disttcluster_monocrittcluster_maxclust_monocritR>R¿(Rƒttt criteriontdepthR´RÍR]R9((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR"s2J  ( % % ( (c C`sÜtj|dddtjƒ}t|ƒtjksHt|jƒdkrWtdƒ‚ntj |d|ƒ}t |d|ƒ}|d krŸt |d|ƒ}ntj|ddƒ}t |d |d |d |d |ƒ} | S(sç Cluster observation data using a given metric. Clusters the original observations in the n-by-m data matrix X (n observations in m dimensions), using the euclidean distance metric to calculate distances between original observations, performs hierarchical clustering using the single linkage algorithm, and forms flat clusters using the inconsistency method with `t` as the cut-off threshold. A one-dimensional array ``T`` of length ``n`` is returned. ``T[i]`` is the index of the flat cluster to which the original observation ``i`` belongs. Parameters ---------- X : (N, M) ndarray N by M data matrix with N observations in M dimensions. t : float The threshold to apply when forming flat clusters. criterion : str, optional Specifies the criterion for forming flat clusters. Valid values are 'inconsistent' (default), 'distance', or 'maxclust' cluster formation algorithms. See `fcluster` for descriptions. metric : str, optional The distance metric for calculating pairwise distances. See ``distance.pdist`` for descriptions and linkage to verify compatibility with the linkage method. depth : int, optional The maximum depth for the inconsistency calculation. See `inconsistent` for more information. method : str, optional The linkage method to use (single, complete, average, weighted, median centroid, ward). See `linkage` for more information. Default is "single". R : ndarray, optional The inconsistency matrix. It will be computed if necessary if it is not passed. Returns ------- fclusterdata : ndarray A vector of length n. T[i] is the flat cluster number to which original observation i belongs. See Also -------- scipy.spatial.distance.pdist : pairwise distance metrics Notes ----- This function is similar to the MATLAB function ``clusterdata``. RFRGR.is7The observation matrix X must be an n by m numpy array.RCRBRRÖR×R´RÕN(R2RMR6RgR¼RŠRRR‹R%RVRR0RR( R¤RÕRÖRCR×RBR´R¦RƒR9((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRs8* $cC`sƒtj|ddƒ}t|dtddƒ|jdd}tj|fdd ƒ}t|gƒ\}tj||t |ƒƒ|S( s´ Returns a list of leaf node ids The return corresponds to the observation vector index as it appears in the tree from left to right. Z is a linkage matrix. Parameters ---------- Z : ndarray The hierarchical clustering encoded as a matrix. `Z` is a linkage matrix. See `linkage` for more information. Returns ------- leaves_list : ndarray The list of leaf node ids. RFRGRHRIRƒiiR.R™( R2RMRRPRRRŒR;RtprelistRX(RƒR]tML((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRØsi ii iii2iUi-i(iZcC`sPtgƒ}g}x7|D]/}||kr|j|ƒ|j|ƒqqW|S(s~ Removes duplicates AND preserves the original order of the elements. The set class is not guaranteed to do this. (RsRuRt(tLt seen_beforetL2R™((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt _remove_dupss    cC`s)x"tD]}||krt|SqWdS(N(t_dtextsortedkeyst _dtextsizes(tpRz((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt_get_tick_text_sizes  cC`s)x"tD]}||krt|SqWdS(N(t_drotationsortedkeyst _drotation(RàRz((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt_get_tick_rotations  tbc#C`s`y7| dkrddl}nddl}ddl}Wntk rVtdƒ‚nX| dkr{|jjƒ} t}nt}t |ƒd}||d}t j dt |ƒdddƒ}|dkr(|dkr| j d|gƒ| j d|gƒn&| j |dgƒ| j d|gƒ|}|}|rX| jgƒ| jgƒq†| j|ƒ|dkr„| jjdƒn| jjdƒx!| jƒD]}|jtƒq¡W| dkrÜttt |ƒƒƒn| }| dkrttt |ƒƒƒn| }| j|d|d |ƒn^|dkr†|d kri| j |dgƒ| j d|gƒn&| j d|gƒ| j d|gƒ|}|}|r¾| jgƒ| jgƒq†| j|ƒ|d krê| jjd ƒn| jjd ƒx!| jƒD]}|jtƒqW| dkrBttt |ƒƒƒn| }| dk rp| j|d| d |ƒq†| j|d |ƒnt|ƒ}i}x|D]}g||>> from scipy.cluster import hierarchy >>> ytdist = np.array([662., 877., 255., 412., 996., 295., 468., 268., 400., ... 754., 564., 138., 219., 869., 669.]) >>> Z = hierarchy.linkage(ytdist, 'single') >>> dn = hierarchy.dendrogram(Z, no_plot=True) >>> dn['color_list'] ['g', 'b', 'b', 'b', 'b'] >>> hierarchy.set_link_color_palette(['c', 'm', 'y', 'k']) >>> dn = hierarchy.dendrogram(Z, no_plot=True) >>> dn['color_list'] ['c', 'b', 'b', 'b', 'b'] >>> dn = hierarchy.dendrogram(Z, no_plot=True, color_threshold=267, ... above_threshold_color='k') >>> dn['color_list'] ['c', 'm', 'm', 'k', 'k'] Now reset the color palette to its default: >>> hierarchy.set_link_color_palette(None) R)R*RGR+RERzspalette must be a list or tuples/all palette list elements must be color stringsN( R0RgRÿttupleR‹RfRRÀt_link_line_colorstremovetextend(tpaletteRàt_ptypesR™((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR"¦s8 " Ræc5C`stj|ddƒ}|ddddgkr<tdƒ‚nt|dtd d ƒ|j}|d d }t|ƒttfkrt|ƒ}n t d ƒ‚|dddddt fkrÉtdƒ‚n|dkpÞ|dkr||kpö|d kr|}nn|dkrd}n|dkrA|d kr>tj }nn|rPg}nt }g}g}g}d g}t g}g}|t kp¤t |tƒo¤|dkrÊt|dd…dfƒd}ni|d6|d6|d6|d6|d6}|rÿgnt }td |d|d|d|d |d!|d"|d#|d$|d%| d&d|dd'd(d|d)|d*|d+|d,|d-|d|d.|d/|d0|d1|d2|ƒ| r t|dd…dfƒ}t|||||||| |d3| d4| d0|d5|d2|ƒ n|S(6s¥( Plots the hierarchical clustering as a dendrogram. The dendrogram illustrates how each cluster is composed by drawing a U-shaped link between a non-singleton cluster and its children. The top of the U-link indicates a cluster merge. The two legs of the U-link indicate which clusters were merged. The length of the two legs of the U-link represents the distance between the child clusters. It is also the cophenetic distance between original observations in the two children clusters. Parameters ---------- Z : ndarray The linkage matrix encoding the hierarchical clustering to render as a dendrogram. See the ``linkage`` function for more information on the format of ``Z``. p : int, optional The ``p`` parameter for ``truncate_mode``. truncate_mode : str, optional The dendrogram can be hard to read when the original observation matrix from which the linkage is derived is large. Truncation is used to condense the dendrogram. There are several modes: ``None`` No truncation is performed (default). Note: ``'none'`` is an alias for ``None`` that's kept for backward compatibility. ``'lastp'`` The last ``p`` non-singleton clusters formed in the linkage are the only non-leaf nodes in the linkage; they correspond to rows ``Z[n-p-2:end]`` in ``Z``. All other non-singleton clusters are contracted into leaf nodes. ``'level'`` No more than ``p`` levels of the dendrogram tree are displayed. A "level" includes all nodes with ``p`` merges from the last merge. Note: ``'mtica'`` is an alias for ``'level'`` that's kept for backward compatibility. color_threshold : double, optional For brevity, let :math:`t` be the ``color_threshold``. Colors all the descendent links below a cluster node :math:`k` the same color if :math:`k` is the first node below the cut threshold :math:`t`. All links connecting nodes with distances greater than or equal to the threshold are colored blue. If :math:`t` is less than or equal to zero, all nodes are colored blue. If ``color_threshold`` is None or 'default', corresponding with MATLAB(TM) behavior, the threshold is set to ``0.7*max(Z[:,2])``. get_leaves : bool, optional Includes a list ``R['leaves']=H`` in the result dictionary. For each :math:`i`, ``H[i] == j``, cluster node ``j`` appears in position ``i`` in the left-to-right traversal of the leaves, where :math:`j < 2n-1` and :math:`i < n`. orientation : str, optional The direction to plot the dendrogram, which can be any of the following strings: ``'top'`` Plots the root at the top, and plot descendent links going downwards. (default). ``'bottom'`` Plots the root at the bottom, and plot descendent links going upwards. ``'left'`` Plots the root at the left, and plot descendent links going right. ``'right'`` Plots the root at the right, and plot descendent links going left. labels : ndarray, optional By default ``labels`` is None so the index of the original observation is used to label the leaf nodes. Otherwise, this is an :math:`n` -sized list (or tuple). The ``labels[i]`` value is the text to put under the :math:`i` th leaf node only if it corresponds to an original observation and not a non-singleton cluster. count_sort : str or bool, optional For each node n, the order (visually, from left-to-right) n's two descendent links are plotted is determined by this parameter, which can be any of the following values: ``False`` Nothing is done. ``'ascending'`` or ``True`` The child with the minimum number of original objects in its cluster is plotted first. ``'descendent'`` The child with the maximum number of original objects in its cluster is plotted first. Note ``distance_sort`` and ``count_sort`` cannot both be True. distance_sort : str or bool, optional For each node n, the order (visually, from left-to-right) n's two descendent links are plotted is determined by this parameter, which can be any of the following values: ``False`` Nothing is done. ``'ascending'`` or ``True`` The child with the minimum distance between its direct descendents is plotted first. ``'descending'`` The child with the maximum distance between its direct descendents is plotted first. Note ``distance_sort`` and ``count_sort`` cannot both be True. show_leaf_counts : bool, optional When True, leaf nodes representing :math:`k>1` original observation are labeled with the number of observations they contain in parentheses. no_plot : bool, optional When True, the final rendering is not performed. This is useful if only the data structures computed for the rendering are needed or if matplotlib is not available. no_labels : bool, optional When True, no labels appear next to the leaf nodes in the rendering of the dendrogram. leaf_rotation : double, optional Specifies the angle (in degrees) to rotate the leaf labels. When unspecified, the rotation is based on the number of nodes in the dendrogram (default is 0). leaf_font_size : int, optional Specifies the font size (in points) of the leaf labels. When unspecified, the size based on the number of nodes in the dendrogram. leaf_label_func : lambda or function, optional When leaf_label_func is a callable function, for each leaf with cluster index :math:`k < 2n-1`. The function is expected to return a string with the label for the leaf. Indices :math:`k < n` correspond to original observations while indices :math:`k \geq n` correspond to non-singleton clusters. For example, to label singletons with their node id and non-singletons with their id, count, and inconsistency coefficient, simply do:: # First define the leaf label function. def llf(id): if id < n: return str(id) else: return '[%d %d %1.2f]' % (id, count, R[n-id,3]) # The text for the leaf nodes is going to be big so force # a rotation of 90 degrees. dendrogram(Z, leaf_label_func=llf, leaf_rotation=90) show_contracted : bool, optional When True the heights of non-singleton nodes contracted into a leaf node are plotted as crosses along the link connecting that leaf node. This really is only useful when truncation is used (see ``truncate_mode`` parameter). link_color_func : callable, optional If given, `link_color_function` is called with each non-singleton id corresponding to each U-shaped link it will paint. The function is expected to return the color to paint the link, encoded as a matplotlib color string code. For example:: dendrogram(Z, link_color_func=lambda k: colors[k]) colors the direct links below each untruncated non-singleton node ``k`` using ``colors[k]``. ax : matplotlib Axes instance, optional If None and `no_plot` is not True, the dendrogram will be plotted on the current axes. Otherwise if `no_plot` is not True the dendrogram will be plotted on the given ``Axes`` instance. This can be useful if the dendrogram is part of a more complex figure. above_threshold_color : str, optional This matplotlib color string sets the color of the links above the color_threshold. The default is 'b'. Returns ------- R : dict A dictionary of data structures computed to render the dendrogram. Its has the following keys: ``'color_list'`` A list of color names. The k'th element represents the color of the k'th link. ``'icoord'`` and ``'dcoord'`` Each of them is a list of lists. Let ``icoord = [I1, I2, ..., Ip]`` where ``Ik = [xk1, xk2, xk3, xk4]`` and ``dcoord = [D1, D2, ..., Dp]`` where ``Dk = [yk1, yk2, yk3, yk4]``, then the k'th link painted is ``(xk1, yk1)`` - ``(xk2, yk2)`` - ``(xk3, yk3)`` - ``(xk4, yk4)``. ``'ivl'`` A list of labels corresponding to the leaf nodes. ``'leaves'`` For each i, ``H[i] == j``, cluster node ``j`` appears in position ``i`` in the left-to-right traversal of the leaves, where :math:`j < 2n-1` and :math:`i < n`. If ``j`` is less than ``n``, the ``i``-th leaf node corresponds to an original observation. Otherwise, it corresponds to a non-singleton cluster. See Also -------- linkage, set_link_color_palette Notes ----- It is expected that the distances in ``Z[:,2]`` be monotonic, otherwise crossings appear in the dendrogram. Examples -------- >>> from scipy.cluster import hierarchy >>> import matplotlib.pyplot as plt A very basic example: >>> ytdist = np.array([662., 877., 255., 412., 996., 295., 468., 268., ... 400., 754., 564., 138., 219., 869., 669.]) >>> Z = hierarchy.linkage(ytdist, 'single') >>> plt.figure() >>> dn = hierarchy.dendrogram(Z) Now plot in given axes, improve the color scheme and use both vertical and horizontal orientations: >>> hierarchy.set_link_color_palette(['m', 'c', 'y', 'k']) >>> fig, axes = plt.subplots(1, 2, figsize=(8, 3)) >>> dn1 = hierarchy.dendrogram(Z, ax=axes[0], above_threshold_color='y', ... orientation='top') >>> dn2 = hierarchy.dendrogram(Z, ax=axes[1], above_threshold_color='#bcbddc', ... orientation='right') >>> hierarchy.set_link_color_palette(None) # reset to default after use >>> plt.show() RFRGRæR`RçRas>orientation must be one of 'top', 'left', 'bottom', or 'right'RHRIRƒiis$The second argument must be a numbertlastptmlabtmticatleveltnonesInvalid truncation mode.tdefaultNigffffffæ?ticoordtdcoordR tleavesRRàt truncate_modetcolor_thresholdt get_leavesRtlabelst count_sortt distance_sorttshow_leaf_countsR™tivgR]t icoord_listt dcoord_listtlvst current_colortcurrently_below_thresholdtleaf_label_funcRtlink_color_funcRRRR(R2RMR>RRPRRRgRXRÐR‹R0tinfRÀRfRRt_dendrogram_calculate_infoR((RƒRàR;R<R=RR>R?R@RAtno_plotRRRRHtshow_contractedRIRRR«R]RERCRDRRFRGR R´RR((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRísŠÿ           #   c C`sš|dk r"|jt|ƒƒn|dk r–|rP|j|t|ƒƒƒq–|dk rz|j|t||ƒƒq–|jtt|ƒƒƒndS(N(R0RtRXR¿( RƒRàR]R5RER RHR™R>((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt_append_singleton_leaf_nodeL s   c C`sœ|dk r"|jt|ƒƒn|dk r˜|rP|j|t|ƒƒƒq˜| rˆ|jdtt|||dfƒƒdƒq˜|jdƒndS(Nt(it)R»(R0RtRXR¿( RƒRàR]R5RER RHR™R>RA((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt_append_nonsingleton_leaf_nodef s  2cC`sXt||t|||dfƒ||ƒt||t|||dfƒ||ƒdS(Nii(t_append_contraction_marks_subRX(RƒRBR™R]R((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt_append_contraction_marksx s*cC`sˆ||kr„|j||||dffƒt||t|||dfƒ||ƒt||t|||dfƒ||ƒndS(Niii(RtRRRX(RƒRBR™R]R((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRR} s !*iÿÿÿÿgc07C`s¸| dkrtdƒ‚n| dkr6tdƒ‚n|dkr!d| || koa| knrÜ|| | df}t||| ||| || || ƒ |d*k rÈt|| d| | |ƒn| ddd |fS| | kr%t||| ||| || |ƒ | ddd d fSn|d kr| | kr»||kr»|| | df}t||| ||| || || ƒ |d*k r§t|| d| | |ƒn| ddd |fS| | kr%t||| ||| || |ƒ | ddd d fSn%|d+kr%d }tj|tƒn| | krgt||| ||| || |ƒ | ddd d fSt|| | dfƒ}t|| | d fƒ}|| krÒ||| df}||| df}n d }d }|| kr||| df} ||| df}!n d } d }!|dks9|t krc|| krT|}"|}#q|}"|}#nº|dkr™|| krŠ|}"|}#q|}"|}#n„|dks±|t krÛ||!krÌ|}"|}#q|}"|}#nB|dkr||!kr|}"|}#q|}"|}#n |}"|}#t d|d|d|d|d|d|d|d|d|d| d|"d| d| d| d|d |d!|d"|d#|d$|d%|d |d d&|d'|d(|ƒ\}$}%}&}'|| | df}(|(|ksø|dkr4|})|dr'|dd t t ƒ|dR?R@RAR™RBR R]RCRDRERFRRGRHRRIRs6link_color_func must return a matplotlib color string!N(smlab(R>RQR0RSRNR*R+tDeprecationWarningRXRPRKRŠR-RÀRRtRfRR‹(0RƒRàR;R<R=RR>R?R@RAR™RBR R]RCRDREtmhrRFRRGRHR5RRIRRtmsgtaatabtnatdatnbtdbtuatubtuivatuwatuahtuamdthRGtuivbtuwbtubhtubmdtmax_disttv((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRK„ s 2   $                                     cC`s°tj|ddƒ}tj|ddƒ}t|ƒtjkrNtdƒ‚nt|ƒtjkrrtdƒ‚n|j}|j}t|ƒdkr¥tdƒ‚nt|ƒdkrÆtdƒ‚n|d|dkrétd ƒ‚n|d}i}i}xªtd|ƒD]™}|||krp|||kr9t S|||||ksi|||||kr¨t Sq|||kr„t S|||||<|||||RRÀRP(tT1tT2tT1StT2SR]td1td2R™((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRm s8   0cC`sŠtj|dddtjƒ}t|dtddƒ|jdd}tj|dfƒ}t|gƒ\}tj ||t |ƒƒ|S( s^ Returns the maximum distance between any non-singleton cluster. Parameters ---------- Z : ndarray The hierarchical clustering encoded as a matrix. See ``linkage`` for more information. Returns ------- maxdists : ndarray A ``(n-1)`` sized numpy array of doubles; ``MD[i]`` represents the maximum distance between any cluster (including singletons) below and including the node with index i. More specifically, ``MD[i] = Z[Q(i)-n, 2].max()`` where ``Q(i)`` is the set of all node indices below and including node i. RFRGR.RHRIRƒii( R2RMR6RRPRRRŒR;Rtget_max_dist_for_each_clusterRX(RƒR]tMD((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR¡ scC`sátj|ddƒ}tj|ddƒ}t|dtddƒt|dtddƒ|jdd}|jd|jdkrtd ƒ‚ntj|dfƒ}t||gƒ\}}t j |||t |ƒd ƒ|S( sœ Returns the maximum inconsistency coefficient for each non-singleton cluster and its descendents. Parameters ---------- Z : ndarray The hierarchical clustering encoded as a matrix. See `linkage` for more information. R : ndarray The inconsistency matrix. Returns ------- MI : ndarray A monotonic ``(n-1)``-sized numpy array of doubles. RFRGRHRIRƒR´iisQThe inconsistency matrix and linkage matrix each have a different number of rows.i( R2RMRRPRRRR>RŒR;Rtget_max_Rfield_for_each_clusterRX(RƒR´R]tMI((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR ¿ scC`s)tj|ddƒ}tj|ddƒ}t|dtddƒt|dtddƒt|ƒtk rwtdƒ‚n|dks|d kržtd ƒ‚n|j d|j dkrÇtd ƒ‚n|j dd }tj |d fƒ}t ||gƒ\}}t j |||t|ƒ|ƒ|S( s¿ Returns the maximum statistic for each non-singleton cluster and its descendents. Parameters ---------- Z : array_like The hierarchical clustering encoded as a matrix. See `linkage` for more information. R : array_like The inconsistency matrix. i : int The column of `R` to use as the statistic. Returns ------- MR : ndarray Calculates the maximum statistic for the i'th column of the inconsistency matrix `R` for each non-singleton cluster node. ``MR[j]`` is the maximum over ``R[Q(j)-n, i]`` where ``Q(j)`` the set of all node ids corresponding to nodes below and including ``j``. RFRGRHRIRƒR´s&The third argument must be an integer.iis/i must be an integer between 0 and 3 inclusive.sQThe inconsistency matrix and linkage matrix each have a different number of rows.i(R2RMRRPRRgRXR‹R>RRRŒR;RRt(RƒR´R™R]tMR((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyRá sc C`sftj|ddƒ}tj|ddƒ}t|ƒtjksN|jdkr]tdƒ‚nt|dtddƒt|ƒ|j dd krŸt d ƒ‚ntj |ƒ}t|ƒ}tj |fd dƒ}tj |fd dƒ}|j dd }t ||gƒ\}}tj||||t|ƒt|ƒƒ}|dkr\t d |ƒ‚n||fS( só Returns the root nodes in a hierarchical clustering. Returns the root nodes in a hierarchical clustering corresponding to a cut defined by a flat cluster assignment vector ``T``. See the ``fcluster`` function for more information on the format of ``T``. For each flat cluster :math:`j` of the :math:`k` flat clusters represented in the n-sized flat cluster assignment vector ``T``, this function finds the lowest cluster node :math:`i` in the linkage tree Z such that: * leaf descendents belong only to flat cluster j (i.e. ``T[p]==j`` for all :math:`p` in :math:`S(i)` where :math:`S(i)` is the set of leaf ids of leaf nodes descendent with cluster node :math:`i`) * there does not exist a leaf that is not descendent with :math:`i` that also belongs to cluster :math:`j` (i.e. ``T[q]!=j`` for all :math:`q` not in :math:`S(i)`). If this condition is violated, ``T`` is not a valid cluster assignment vector, and an exception will be thrown. Parameters ---------- Z : ndarray The hierarchical clustering encoded as a matrix. See `linkage` for more information. T : ndarray The flat cluster assignment vector. Returns ------- L : ndarray The leader linkage node id's stored as a k-element 1-D array where ``k`` is the number of flat clusters found in ``T``. ``L[j]=i`` is the linkage cluster node id that is the leader of flat cluster with id M[j]. If ``i < n``, ``i`` corresponds to an original observation, otherwise it corresponds to a non-singleton cluster. For example: if ``L[3]=2`` and ``M[3]=8``, the flat cluster with id 8's leader is linkage node 2. M : ndarray The leader linkage node id's stored as a k-element 1-D array where ``k`` is the number of flat clusters found in ``T``. This allows the set of flat cluster ids to be any arbitrary set of ``k`` integers. RFRGR™s4T must be a one-dimensional numpy array of integers.RHRIRƒiis!Mismatch: len(T)!=Z.shape[0] + 1.R.sXT is not a valid assignment vector. Error found when examining linkage node %d (< 2n-1).(R2RMRgR¼R.R‹RRPRŠRRR>tuniqueRŒR;RRRX(RƒR9tCltkkRÚtMR]R,((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyR s$3$ *  (XRt __future__RRRR*RRRtnumpyR2R»Rtscipy.spatial.distancetspatialR%tscipy._lib.sixRRRJRQt__all__t UserWarningR&R-R8R;RARRR R R R R RRt _cnode_bareRgt _cnode_typeR‡R0RRÀR$R¥RLRRRR#RRRRÅRÆRËR!RRRRRJRßRãRÿtkeysRÞtsortRâRÝRáRäR(R-R"RPRRNRQRSRRRKRRR RR(((s6/tmp/pip-build-7oUkmx/scipy/scipy/cluster/hierarchy.pyt…sÆ'            , - *ÖÉ   Q a   > 3 4 $ AQ   nG #,     ƒ G      ÿZ        Ý 4  " -