| Server IP : 217.160.0.135 / Your IP : 216.73.217.37 Web Server : Apache System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64 User : sws1074145052 ( 1074145052) PHP Version : 8.3.32 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /lib/python3/dist-packages/scipy/cluster/__pycache__/ |
Upload File : |
�
d�c�C � � � d Z ddlZddlZddlmZ ddlZddlmZm Z ddl
m c m Z ddl
mZ ddddd d
d d �Zd
Zg d�Z G d� de� � Zd� Zd� Zd� Zd� Zd� Zd� Zd� Zd� Zd� Z d� Z d� Z dYd �Z G d � d!� � Z e d� � Z! e"e � � Z#d"� Z$dZd#�Z%d[d$�Z&d\d%�Z'd&� Z(d'� Z)d]d(�Z*d^d)�Z+d*� Z,d+� Z-d,� Z.d_d-�Z/d_d.�Z0d/� Z1d0� Z2d1� Z3d2� Z4d3� Z5d`d5�Z6 dad6�Z7d7� Z8d8d9d:d;d<d=d>d ej9 d
iZ:d8dd?d@ej9 dAiZ; e<e:�= � � � � Z>e>�? � � e<e;�= � � � � Z@e@�? � � dB� ZAdC� ZBdD� ZC dbdF�ZDdGZE e<eE� � aFdH� ZG dcdK�ZHdL� ZIdM� ZJdN� ZKdO� ZLdP� ZMej9 dIdJdd d d dQdRg dg g dd g g g dddddEfdS�ZNdT� ZOdU� ZPdV� ZQdW� ZRdX� ZSdS )da]
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
optimal_leaf_ordering
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
Utility classes:
.. autosummary::
:toctree: generated/
DisjointSet -- data structure for incremental connectivity queries
� N)�deque� )�
_hierarchy�_optimal_leaf_ordering)� DisjointSet� � � � � )�single�complete�average�centroid�median�ward�weighted)r r r ) � ClusterNoder r r r �cophenet�
correspond�cut_tree�
dendrogram�fcluster� fclusterdata�from_mlab_linkage� inconsistent�
is_isomorphic� is_monotonic� is_valid_im�is_valid_linkage�leaders� leaves_list�linkage�maxRstat�maxdists� maxinconstsr �num_obs_linkage�optimal_leaf_ordering�set_link_color_paletter
�to_mlab_linkage�to_treer r c � � e Zd ZdS )�ClusterWarningN)�__name__�
__module__� __qualname__� � �9/usr/lib/python3/dist-packages/scipy/cluster/hierarchy.pyr- r- � s � � � � � ��Dr2 r- c �D � t j d| z t d�� � d S )Nzscipy.cluster: %sr )�
stacklevel)�warnings�warnr- )�ss r3 �_warningr9 � s% � � �M�%��)�>�a�H�H�H�H�H�Hr2 c � � | j �| � � � S t j | t j � � r t j | t j �� � S | S )z>
Copy the array if its base points to a parent array.
N��dtype)�base�copy�np� issubsctype�float32�array�double)�as r3 �_copy_array_if_base_presentrE � sK � � �v���v�v�x�x�� � ��2�:� &� &� ��x����+�+�+�+��r2 c � � d� | D � � }|S )z�
Accept 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.
c �, � g | ]}t |� � ��S r1 )rE )�.0rD s r3 �
<listcomp>z0_copy_arrays_if_base_present.<locals>.<listcomp>� s! � �3�3�3�A� $�Q� '� '�3�3�3r2 r1 )�T�ls r3 � _copy_arrays_if_base_presentrL � s � � 4�3��3�3�3�A� �Hr2 c � � | dk r)t j � | | dz
z dz � � }nt d� � �|S )a%
Generate a random distance matrix stored in condensed form.
Parameters
----------
pnts : int
The number of points in the distance matrix. Has to be at least 2.
Returns
-------
D : ndarray
A ``pnts * (pnts - 1) / 2`` sized vector is returned.
r r z?The number of points in the distance matrix must be at least 2.)r? �random�rand�
ValueError)�pnts�Ds r3 �_randdmrS � sL � � �q�y�y� �I�N�N�4�4�!�8�,�q�0� 1� 1���� /� 0� 0� 0� �Hr2 c �& � t | dd�� � S )aN
Perform 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
Examples
--------
>>> from scipy.cluster.hierarchy import single, fcluster
>>> from scipy.spatial.distance import pdist
First, we need a toy dataset to play with::
x x x x
x x
x x
x x x x
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
Then, we get a condensed distance matrix from this dataset:
>>> y = pdist(X)
Finally, we can perform the clustering:
>>> Z = single(y)
>>> Z
array([[ 0., 1., 1., 2.],
[ 2., 12., 1., 3.],
[ 3., 4., 1., 2.],
[ 5., 14., 1., 3.],
[ 6., 7., 1., 2.],
[ 8., 16., 1., 3.],
[ 9., 10., 1., 2.],
[11., 18., 1., 3.],
[13., 15., 2., 6.],
[17., 20., 2., 9.],
[19., 21., 2., 12.]])
The linkage matrix ``Z`` represents a dendrogram - see
`scipy.cluster.hierarchy.linkage` for a detailed explanation of its
contents.
We can use `scipy.cluster.hierarchy.fcluster` to see to which cluster
each initial point would belong given a distance threshold:
>>> fcluster(Z, 0.9, criterion='distance')
array([ 7, 8, 9, 10, 11, 12, 4, 5, 6, 1, 2, 3], dtype=int32)
>>> fcluster(Z, 1, criterion='distance')
array([3, 3, 3, 4, 4, 4, 2, 2, 2, 1, 1, 1], dtype=int32)
>>> fcluster(Z, 2, criterion='distance')
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32)
Also, `scipy.cluster.hierarchy.dendrogram` can be used to generate a
plot of the dendrogram.
r
� euclidean��method�metric�r# ��ys r3 r
r
� s � �V �1�X�k� :� :� :�:r2 c �& � t | dd�� � S )a�
Perform 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
Examples
--------
>>> from scipy.cluster.hierarchy import complete, fcluster
>>> from scipy.spatial.distance import pdist
First, we need a toy dataset to play with::
x x x x
x x
x x
x x x x
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
Then, we get a condensed distance matrix from this dataset:
>>> y = pdist(X)
Finally, we can perform the clustering:
>>> Z = complete(y)
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 2. , 12. , 1.41421356, 3. ],
[ 5. , 13. , 1.41421356, 3. ],
[ 8. , 14. , 1.41421356, 3. ],
[11. , 15. , 1.41421356, 3. ],
[16. , 17. , 4.12310563, 6. ],
[18. , 19. , 4.12310563, 6. ],
[20. , 21. , 5.65685425, 12. ]])
The linkage matrix ``Z`` represents a dendrogram - see
`scipy.cluster.hierarchy.linkage` for a detailed explanation of its
contents.
We can use `scipy.cluster.hierarchy.fcluster` to see to which cluster
each initial point would belong given a distance threshold:
>>> fcluster(Z, 0.9, criterion='distance')
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=int32)
>>> fcluster(Z, 1.5, criterion='distance')
array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4], dtype=int32)
>>> fcluster(Z, 4.5, criterion='distance')
array([1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2], dtype=int32)
>>> fcluster(Z, 6, criterion='distance')
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32)
Also, `scipy.cluster.hierarchy.dendrogram` can be used to generate a
plot of the dendrogram.
r rU rV rY rZ s r3 r r s � �^ �1�Z� � <� <� <�<r2 c �& � t | dd�� � S )ar
Perform 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
Examples
--------
>>> from scipy.cluster.hierarchy import average, fcluster
>>> from scipy.spatial.distance import pdist
First, we need a toy dataset to play with::
x x x x
x x
x x
x x x x
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
Then, we get a condensed distance matrix from this dataset:
>>> y = pdist(X)
Finally, we can perform the clustering:
>>> Z = average(y)
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 2. , 12. , 1.20710678, 3. ],
[ 5. , 13. , 1.20710678, 3. ],
[ 8. , 14. , 1.20710678, 3. ],
[11. , 15. , 1.20710678, 3. ],
[16. , 17. , 3.39675184, 6. ],
[18. , 19. , 3.39675184, 6. ],
[20. , 21. , 4.09206523, 12. ]])
The linkage matrix ``Z`` represents a dendrogram - see
`scipy.cluster.hierarchy.linkage` for a detailed explanation of its
contents.
We can use `scipy.cluster.hierarchy.fcluster` to see to which cluster
each initial point would belong given a distance threshold:
>>> fcluster(Z, 0.9, criterion='distance')
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=int32)
>>> fcluster(Z, 1.5, criterion='distance')
array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4], dtype=int32)
>>> fcluster(Z, 4, criterion='distance')
array([1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2], dtype=int32)
>>> fcluster(Z, 6, criterion='distance')
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32)
Also, `scipy.cluster.hierarchy.dendrogram` can be used to generate a
plot of the dendrogram.
r rU rV rY rZ s r3 r r o s � �^ �1�Y�{� ;� ;� ;�;r2 c �& � t | dd�� � S )a�
Perform 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
Examples
--------
>>> from scipy.cluster.hierarchy import weighted, fcluster
>>> from scipy.spatial.distance import pdist
First, we need a toy dataset to play with::
x x x x
x x
x x
x x x x
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
Then, we get a condensed distance matrix from this dataset:
>>> y = pdist(X)
Finally, we can perform the clustering:
>>> Z = weighted(y)
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 9. , 11. , 1. , 2. ],
[ 2. , 12. , 1.20710678, 3. ],
[ 8. , 13. , 1.20710678, 3. ],
[ 5. , 14. , 1.20710678, 3. ],
[10. , 15. , 1.20710678, 3. ],
[18. , 19. , 3.05595762, 6. ],
[16. , 17. , 3.32379407, 6. ],
[20. , 21. , 4.06357713, 12. ]])
The linkage matrix ``Z`` represents a dendrogram - see
`scipy.cluster.hierarchy.linkage` for a detailed explanation of its
contents.
We can use `scipy.cluster.hierarchy.fcluster` to see to which cluster
each initial point would belong given a distance threshold:
>>> fcluster(Z, 0.9, criterion='distance')
array([ 7, 8, 9, 1, 2, 3, 10, 11, 12, 4, 6, 5], dtype=int32)
>>> fcluster(Z, 1.5, criterion='distance')
array([3, 3, 3, 1, 1, 1, 4, 4, 4, 2, 2, 2], dtype=int32)
>>> fcluster(Z, 4, criterion='distance')
array([2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1], dtype=int32)
>>> fcluster(Z, 6, criterion='distance')
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32)
Also, `scipy.cluster.hierarchy.dendrogram` can be used to generate a
plot of the dendrogram.
r rU rV rY rZ s r3 r r � s � �d �1�Z� � <� <� <�<r2 c �& � t | dd�� � S )a�
Perform 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
an 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.
scipy.spatial.distance.pdist : pairwise distance metrics
Examples
--------
>>> from scipy.cluster.hierarchy import centroid, fcluster
>>> from scipy.spatial.distance import pdist
First, we need a toy dataset to play with::
x x x x
x x
x x
x x x x
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
Then, we get a condensed distance matrix from this dataset:
>>> y = pdist(X)
Finally, we can perform the clustering:
>>> Z = centroid(y)
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 2. , 12. , 1.11803399, 3. ],
[ 5. , 13. , 1.11803399, 3. ],
[ 8. , 15. , 1.11803399, 3. ],
[11. , 14. , 1.11803399, 3. ],
[18. , 19. , 3.33333333, 6. ],
[16. , 17. , 3.33333333, 6. ],
[20. , 21. , 3.33333333, 12. ]])
The linkage matrix ``Z`` represents a dendrogram - see
`scipy.cluster.hierarchy.linkage` for a detailed explanation of its
contents.
We can use `scipy.cluster.hierarchy.fcluster` to see to which cluster
each initial point would belong given a distance threshold:
>>> fcluster(Z, 0.9, criterion='distance')
array([ 7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6], dtype=int32)
>>> fcluster(Z, 1.1, criterion='distance')
array([5, 5, 6, 7, 7, 8, 1, 1, 2, 3, 3, 4], dtype=int32)
>>> fcluster(Z, 2, criterion='distance')
array([3, 3, 3, 4, 4, 4, 1, 1, 1, 2, 2, 2], dtype=int32)
>>> fcluster(Z, 4, criterion='distance')
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32)
Also, `scipy.cluster.hierarchy.dendrogram` can be used to generate a
plot of the dendrogram.
r rU rV rY rZ s r3 r r s � �F �1�Z� � <� <� <�<r2 c �& � t | dd�� � S )a!
Perform 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
an 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
Examples
--------
>>> from scipy.cluster.hierarchy import median, fcluster
>>> from scipy.spatial.distance import pdist
First, we need a toy dataset to play with::
x x x x
x x
x x
x x x x
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
Then, we get a condensed distance matrix from this dataset:
>>> y = pdist(X)
Finally, we can perform the clustering:
>>> Z = median(y)
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 2. , 12. , 1.11803399, 3. ],
[ 5. , 13. , 1.11803399, 3. ],
[ 8. , 15. , 1.11803399, 3. ],
[11. , 14. , 1.11803399, 3. ],
[18. , 19. , 3. , 6. ],
[16. , 17. , 3.5 , 6. ],
[20. , 21. , 3.25 , 12. ]])
The linkage matrix ``Z`` represents a dendrogram - see
`scipy.cluster.hierarchy.linkage` for a detailed explanation of its
contents.
We can use `scipy.cluster.hierarchy.fcluster` to see to which cluster
each initial point would belong given a distance threshold:
>>> fcluster(Z, 0.9, criterion='distance')
array([ 7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6], dtype=int32)
>>> fcluster(Z, 1.1, criterion='distance')
array([5, 5, 6, 7, 7, 8, 1, 1, 2, 3, 3, 4], dtype=int32)
>>> fcluster(Z, 2, criterion='distance')
array([3, 3, 3, 4, 4, 4, 1, 1, 1, 2, 2, 2], dtype=int32)
>>> fcluster(Z, 4, criterion='distance')
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32)
Also, `scipy.cluster.hierarchy.dendrogram` can be used to generate a
plot of the dendrogram.
r rU rV rY rZ s r3 r r | s � �F �1�X�k� :� :� :�:r2 c �& � t | dd�� � S )a�
Perform 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
an 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
Examples
--------
>>> from scipy.cluster.hierarchy import ward, fcluster
>>> from scipy.spatial.distance import pdist
First, we need a toy dataset to play with::
x x x x
x x
x x
x x x x
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
Then, we get a condensed distance matrix from this dataset:
>>> y = pdist(X)
Finally, we can perform the clustering:
>>> Z = ward(y)
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 2. , 12. , 1.29099445, 3. ],
[ 5. , 13. , 1.29099445, 3. ],
[ 8. , 14. , 1.29099445, 3. ],
[11. , 15. , 1.29099445, 3. ],
[16. , 17. , 5.77350269, 6. ],
[18. , 19. , 5.77350269, 6. ],
[20. , 21. , 8.16496581, 12. ]])
The linkage matrix ``Z`` represents a dendrogram - see
`scipy.cluster.hierarchy.linkage` for a detailed explanation of its
contents.
We can use `scipy.cluster.hierarchy.fcluster` to see to which cluster
each initial point would belong given a distance threshold:
>>> fcluster(Z, 0.9, criterion='distance')
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=int32)
>>> fcluster(Z, 1.1, criterion='distance')
array([1, 1, 2, 3, 3, 4, 5, 5, 6, 7, 7, 8], dtype=int32)
>>> fcluster(Z, 3, criterion='distance')
array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4], dtype=int32)
>>> fcluster(Z, 9, criterion='distance')
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32)
Also, `scipy.cluster.hierarchy.dendrogram` can be used to generate a
plot of the dendrogram.
r rU rV rY rZ s r3 r r � s � �@ �1�V�K� 8� 8� 8�8r2 r
rU Fc �Z � |t vr"t d� |� � � � �t t j | d�� � � � } | j dk r*t j | dd�� � t | g� � \ } n�| j dk r�|t v r(|d k r"t d
� |� � � � �| j d | j d k rht j t j
| � � d � � rAt j | d k � � r)t j | | j � � rt! d � � t j | |� � } nt d
� � �t j t j | � � � � st d� � �t' t j | � � � � }t | }|dk rt+ j | |� � }n1|dv rt+ j | ||� � }nt+ j | ||� � }|rt3 || � � S |S )aH!
Perform hierarchical/agglomerative clustering.
The input y may be either a 1-D condensed distance matrix
or a 2-D array of observation vectors.
If y is a 1-D condensed distance matrix,
then y must be a :math:`\binom{n}{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 choose 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.
optimal_ordering : bool, optional
If True, the linkage matrix will be reordered so that the distance
between successive leaves is minimal. This results in a more intuitive
tree structure when the data are visualized. defaults to False, because
this algorithm can be slow, particularly on large datasets [2]_. See
also the `optimal_leaf_ordering` function.
.. versionadded:: 1.0.0
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 the user's 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`.
.. [2] Ziv Bar-Joseph, David K. Gifford, Tommi S. Jaakkola, "Fast optimal
leaf ordering for hierarchical clustering", 2001. Bioinformatics
:doi:`10.1093/bioinformatics/17.suppl_1.S22`
Examples
--------
>>> from scipy.cluster.hierarchy import dendrogram, linkage
>>> from matplotlib import pyplot as plt
>>> X = [[i] for i in [2, 8, 0, 4, 1, 9, 9, 0]]
>>> Z = linkage(X, 'ward')
>>> fig = plt.figure(figsize=(25, 10))
>>> dn = dendrogram(Z)
>>> Z = linkage(X, 'single')
>>> fig = plt.figure(figsize=(25, 10))
>>> dn = dendrogram(Z)
>>> plt.show()
zInvalid method: {0}�c��orderr Tr[ ��throw�namer rU z9Method '{0}' requires the distance metric to be Euclideanr �kThe symmetric non-negative hollow observation matrix looks suspiciously like an uncondensed distance matrix� `y` must be 1 or 2 dimensional.�>The condensed distance matrix must contain only finite values.r
)r r r r )�_LINKAGE_METHODSrP �format�_convert_to_doubler? �asarray�ndim�distance�
is_valid_yrL �_EUCLIDEAN_METHODS�shape�allclose�diag�allrJ r9 �pdist�isfinite�int� num_obs_yr �mst_single_linkage�nn_chain� fast_linkager( )r[ rW rX �optimal_ordering�n� method_code�results r3 r# r# E s � �\ �%�%�%��.�5�5�f�=�=�>�>�>��2�:�a�s�3�3�3�4�4�A��v��{�{���A�T��4�4�4�4�*�A�3�/�/����
��1��� �'� '� '�F�k�,A�,A� � /�/5�v�f�~�~�?� ?�
?� �7�1�:����� #� #�� �B�G�A�J�J��(B�(B� #��v�a�1�f�~�~�
,�"�+�a���"5�"5�
,�� +� ,� ,� ,�
�N�1�f� %� %����:�;�;�;�
�6�"�+�a�.�.� !� !� +�� *� +� +� +� �H� �q� !� !�"�"�A�"�6�*�K�
�����.�q�!�4�4��� �>� >� >��$�Q��;�7�7����(��A�{�;�;��� �$�V�Q�/�/�/��
r2 c �V � e Zd ZdZdd�Zd� Zd� Zd� Zd � Zd
� Z d � Z
d � Z d
� Z d� fd�Z
dS )r a1
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.
Nr r c �2 � |dk rt d� � �|dk rt d� � �|�|�|�|�t d� � �|dk rt d� � �|| _ || _ || _ || _ | j � || _ d S |j |j z | _ d S )Nr z The id must be non-negative.z"The distance must be non-negative.zIOnly full or proper binary trees are permitted. This node has one child.r z9A cluster must contain at least one original observation.)rP �id�left�right�dist�count)�selfr� r� r� r� r� s r3 �__init__zClusterNode.__init__[ s� � �
��6�6� � ;�<�<� <� �!�8�8� � A�B�B� B� �L�U� .� � �� � � :� ;� ;�
;� �1�9�9� � ,� -� -�
-������ ���
��� � �9� � �D�J�J�J� ��e�k�1�D�J�J�Jr2 c � � t |t � � s/t d� t |� � � � � � �| j |j k S �Nz$Can't compare ClusterNode to type {}��
isinstancer rP rm �typer� �r� �nodes r3 �__lt__zClusterNode.__lt__p �M � ��$� �,�,� >� � *�*0�&��d���*<�*<�>� >�
>��y�4�9�$�$r2 c � � t |t � � s/t d� t |� � � � � � �| j |j k S r� r� r� s r3 �__gt__zClusterNode.__gt__v r� r2 c � � t |t � � s/t d� t |� � � � � � �| j |j k S r� r� r� s r3 �__eq__zClusterNode.__eq__| sM � ��$� �,�,� >� � *�*0�&��d���*<�*<�>� >�
>��y�D�I�%�%r2 c � � | j S )aK
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� �r� s r3 �get_idzClusterNode.get_id� s � � �w�r2 c � � | j S )a
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.
)r� r� s r3 � get_countzClusterNode.get_count� s � � �z�r2 c � � | j S )z�
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� r� s r3 �get_leftzClusterNode.get_left� s � � �y�r2 c � � | j S )z�
Return 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.
)r� r� s r3 � get_rightzClusterNode.get_right� s � � �z�r2 c � � | j du S )z�
Return True if the target node is a leaf.
Returns
-------
leafness : bool
True if the target node is a leaf node.
Nr� r� s r3 �is_leafzClusterNode.is_leaf� s � � �y�D� � r2 c � � | j S �Nr� )�xs r3 �<lambda>zClusterNode.<lambda>� s � ��� r2 c �� � | j }dgd|z z }t � � }t � � }| |d< d}g }|dk r�|| }|j } |� � � r$|� ||� � � � |dz
}n]| |vr(|j ||dz < |� | � � |dz }n1| |vr(|j ||dz < |� | � � |dz }n|dz
}|dk ��|S )a�
Perform pre-order traversal without recursive function calls.
When a leaf node is first encountered, ``func`` is called with
the leaf node as its argument, and its result is appended to
the list.
For example, the statement::
ids = root.pre_order(lambda x: x.id)
returns a list of the node ids corresponding to the leaf nodes
of the tree as they appear from left to right.
Parameters
----------
func : function
Applied to each leaf ClusterNode object in the pre-order traversal.
Given the ``i``-th leaf node in the pre-order traversal ``n[i]``,
the result of ``func(n[i])`` is stored in ``L[i]``. If not
provided, the index of the original observation to which the node
corresponds is used.
Returns
-------
L : list
The pre-order traversal.
Nr r r )r� �setr� r� �appendr� �addr� )
r� �funcr� �curNode�lvisited�rvisited�k�preorder�nd�ndids
r3 � pre_orderzClusterNode.pre_order� s � �@
�J���&�A��E�"���5�5���5�5�����
�
�����1�f�f����B��5�D��z�z�|�|�
������R���)�)�)���E����x�'�'�%'�W�G�A��E�N� �L�L��&�&�&��A��A�A���)�)�%'�X�G�A��E�N� �L�L��&�&�&��A��A�A� �A��A�% �1�f�f�( �r2 )NNr r )r. r/ r0 �__doc__r� r� r� r� r� r� r� r� r� r� r1 r2 r3 r r < s� � � � � � � � �<2� 2� 2� 2�*%� %� %� %� %� %� &� &� &� � � � � � � � � � � � �
!�
!�
!� -�n� <� <� <� <� <� <r2 r c � � t � � }t | � � }|� |� � g }|r�|� � � }|� � � sct j ||� � |� |� � � � � |� |� � � � � |��|S )z�
Return clustering nodes in bottom-up order by distance.
Parameters
----------
Z : scipy.cluster.linkage array
The linkage matrix.
Returns
-------
nodes : list
A list of ClusterNode objects.
) r r+ r� �popleftr� �bisect� insort_leftr� r� )�Z�q�tree�nodesr� s r3 �_order_cluster_treer� s� � � ���A� �1�:�:�D��H�H�T�N�N�N� �E�
� &��y�y�{�{���|�|�~�~� &� � �u�d� +� +� +�
�H�H�T�^�^�%�%� &� &� &�
�H�H�T�]�]�_�_� %� %� %� � &� �Lr2 c � � t | � � }t | � � }|�|�t d� � �|�|�t j |� � }n`|�4t j d� |D � � � � }t j ||� � }n*|t j t j |� � |� � z
} t |� � }n'# t $ r d}t j |g� � }Y nw xY wt j ||ft �� � }t j |� � } d|v r| |d< t |� � D ]�\ }
} | � � � } | �
� � }
| | � � � |
| < |
|
| | � � � k xx dz cc< |
dz |v r$|
|t j |
dz |k � � d < |
} ��|j S )aC
Given a linkage matrix Z, return the cut tree.
Parameters
----------
Z : scipy.cluster.linkage array
The linkage matrix.
n_clusters : array_like, optional
Number of clusters in the tree at the cut point.
height : array_like, optional
The height at which to cut the tree. Only possible for ultrametric
trees.
Returns
-------
cutree : array
An array indicating group membership at each agglomeration step. I.e.,
for a full cut tree, in the first column each data point is in its own
cluster. At the next step, two nodes are merged. Finally, all
singleton and non-singleton clusters are in one group. If `n_clusters`
or `height` are given, the columns correspond to the columns of
`n_clusters` or `height`.
Examples
--------
>>> from scipy import cluster
>>> import numpy as np
>>> from numpy.random import default_rng
>>> rng = default_rng()
>>> X = rng.random((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]]) # random
Nz8At least one of either height or n_clusters must be Nonec � � g | ] }|j ��
S r1 )r� )rH r� s r3 rI z cut_tree.<locals>.<listcomp>\ s � �2�2�2�q�A�F�2�2�2r2 r r; r )r' r� rP r? �arangerB � searchsorted�len� TypeError�zerosrz � enumerater� r> �min�max�nonzerorJ )r� �
n_clusters�height�nobsr� �cols_idx�heights�n_cols�groups�
last_group�ir� �idx�
this_groups r3 r r % s� � �\ �1� � �D� �� "� "�E�
��j� 4�� (� )� )� )� � �J� .��9�T�?�?��� � ��(�2�2�E�2�2�2�3�3���?�7�F�3�3����"�/�"�)�D�/�/�:�F�F�F��(��X� � ���� � (� (� (����8�X�J�'�'����(���� �X�v�t�n�C�
0�
0�
0�F���4� � �J��H�}�}� ��q� � �U�#�#� � ���4��n�n� � �� �_�_�&�&�
�$�S�/�-�-�/�/�
�3���:�
�3�� 3� 3� 5� 5�5�6�6�6�!�;�6�6�6� �q�5�H� � �7A�F�2�:�a�!�e�x� /�0�0��3� 4� �
�
� �8�Os �,B< �<!C � C c �v � t j | d�� � } t | dd�� � | j d dz }dg|d z dz
z }t d|� � D ]}t |� � ||< �d}t
| � � D ]�\ }}t |d � � }t |d � � }|||z k rt d
|z � � �|||z k rt d |z � � �t ||z || || |d � � }|d |j k rt d
|z � � �||||z < ��|r||fS |S )a�
Convert a linkage matrix into an easy-to-use tree object.
The reference to the root `ClusterNode` object is returned (by default).
Each `ClusterNode` object has a ``left``, ``right``, ``dist``, ``id``,
and ``count`` attribute. The left and right attributes point to
ClusterNode objects that were combined to generate the cluster.
If both are None then the `ClusterNode` object is a leaf node, its count
must be 1, and its distance is meaningless but set to 0.
*Note: This function is provided for the convenience of the library
user. ClusterNodes are not used as input to any of the functions in this
library.*
Parameters
----------
Z : ndarray
The linkage matrix in proper form (see the `linkage`
function documentation).
rd : bool, optional
When False (default), a reference to the root `ClusterNode` object is
returned. Otherwise, a tuple ``(r, d)`` is returned. ``r`` is a
reference to the root node while ``d`` is a list of `ClusterNode`
objects - one per original entry in the linkage matrix plus entries
for all clustering steps. If a cluster id is
less than the number of samples ``n`` in the data that the linkage
matrix describes, then it corresponds to a singleton cluster (leaf
node).
See `linkage` for more information on the assignment of cluster ids
to clusters.
Returns
-------
tree : ClusterNode or tuple (ClusterNode, list of ClusterNode)
If ``rd`` is False, a `ClusterNode`.
If ``rd`` is True, a list of length ``2*n - 1``, with ``n`` the number
of samples. See the description of `rd` above for more details.
See Also
--------
linkage, is_valid_linkage, ClusterNode
Examples
--------
>>> import numpy as np
>>> from scipy.cluster import hierarchy
>>> rng = np.random.default_rng()
>>> x = rng.random((5, 2))
>>> Z = hierarchy.linkage(x)
>>> hierarchy.to_tree(Z)
<scipy.cluster.hierarchy.ClusterNode object at ...
>>> rootnode, nodelist = hierarchy.to_tree(Z, rd=True)
>>> rootnode
<scipy.cluster.hierarchy.ClusterNode object at ...
>>> len(nodelist)
9
rc rd Tr� rf r r Nr z_Corrupt matrix Z. Index to derivative cluster is used before it is formed. See row %d, column 0z_Corrupt matrix Z. Index to derivative cluster is used before it is formed. See row %d, column 1r z1Corrupt matrix Z. The count Z[%d,3] is incorrect.)
r? ro r rt �ranger r� rz rP r� ) r� �rdr� �dr� r� �row�fi�fjs r3 r+ r+ x s� � �x �
�1�C� � � �A��Q�d��-�-�-�-�
���
�Q��A�
��!�a�%�!�)� �A� �1�a�[�[� � ���1�~�~��!���
�B��A�,�,� � ���3�
��Q��[�[��
��Q��[�[��
��A��:�:� � )�,.� /� 0� 0�
0� ��A��:�:� � )�,.� /� 0� 0�
0� ��Q���"��q��u�c�!�f�
5�
5�� �q�6�R�X� � � � +�./� 0� 1� 1�
1���!�a�%��� � ��A�w��� r2 c � � t j | d�� � } t | dd�� � t t j |d�� � � � }|j dk r*t j |dd�� � t |g� � \ }n�|j dk r�|j d |j d k rht j t j
|� � d � � rAt j |d k � � r)t j ||j � � rt d
� � t j ||� � }nt d � � �t j t j |� � � � st d � � �t# j | |� � S )
a9
Given a linkage matrix Z and distance, reorder the cut tree.
Parameters
----------
Z : ndarray
The hierarchical clustering encoded as a linkage matrix. See
`linkage` for more information on the return structure and
algorithm.
y : ndarray
The condensed distance matrix from which Z was generated.
Alternatively, a collection of m observation vectors in n
dimensions may be passed as an m by n array.
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_ordered : ndarray
A copy of the linkage matrix Z, reordered to minimize the distance
between adjacent leaves.
Examples
--------
>>> import numpy as np
>>> from scipy.cluster import hierarchy
>>> rng = np.random.default_rng()
>>> X = rng.standard_normal((10, 10))
>>> Z = hierarchy.ward(X)
>>> hierarchy.leaves_list(Z)
array([0, 3, 1, 9, 2, 5, 7, 4, 6, 8], dtype=int32)
>>> hierarchy.leaves_list(hierarchy.optimal_leaf_ordering(Z, X))
array([3, 0, 2, 5, 7, 4, 8, 6, 9, 1], dtype=int32)
rc rd Tr� rf r r[ r r ri rj rk )r? ro r rn rp rq rr rL rt ru rv rw rJ r9 rx rP ry r r( )r� r[ rX s r3 r( r( � se � �N �
�1�C� � � �A��Q�d��-�-�-�-��2�:�a�s�3�3�3�4�4�A��v��{�{���A�T��4�4�4�4�*�A�3�/�/����
��1��� �7�1�:����� #� #�� �B�G�A�J�J��(B�(B� #��v�a�1�f�~�~�
,�"�+�a���"5�"5�
,�� +� ,� ,� ,�
�N�1�f� %� %����:�;�;�;�
�6�"�+�a�.�.� !� !� +�� *� +� +� +� "� 7��1� =� =�=r2 c � � | j t k r| � t � � } | j j s| � � � } | S r� )r< �bool�astype�flags�
contiguousr> ��Xs r3 �_convert_to_boolr� s; � ��w�$���
�H�H�T�N�N�� �7� � �
�F�F�H�H�� �Hr2 c � � | j t j k r | � t j � � } | j j s| � � � } | S r� )r< r? rC r� r� r� r> r� s r3 rn rn $ sC � ��w�"�)���
�H�H�R�Y� � �� �7� � �
�F�F�H�H�� �Hr2 c � � t j | d�� � } t | dd�� � | j }|d dz }t j ||dz
z dz t j � � � }t
| � � } t j | |t |� � � � |�|S t j |d�� � }t j |dd �� � |� � � }|� � � }||z
}||z
}||z } |dz }
|dz } | �
� � t j |
�
� � | �
� � z � � z } | |fS ) a
Calculate 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`.
See Also
--------
linkage :
for a description of what a linkage matrix is.
scipy.spatial.distance.squareform :
transforming condensed matrices into square ones.
Examples
--------
>>> from scipy.cluster.hierarchy import single, cophenet
>>> from scipy.spatial.distance import pdist, squareform
Given a dataset ``X`` and a linkage matrix ``Z``, the cophenetic distance
between two points of ``X`` is the distance between the largest two
distinct clusters that each of the points:
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
``X`` corresponds to this dataset ::
x x x x
x x
x x
x x x x
>>> Z = single(pdist(X))
>>> Z
array([[ 0., 1., 1., 2.],
[ 2., 12., 1., 3.],
[ 3., 4., 1., 2.],
[ 5., 14., 1., 3.],
[ 6., 7., 1., 2.],
[ 8., 16., 1., 3.],
[ 9., 10., 1., 2.],
[11., 18., 1., 3.],
[13., 15., 2., 6.],
[17., 20., 2., 9.],
[19., 21., 2., 12.]])
>>> cophenet(Z)
array([1., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 1., 2., 2., 2., 2., 2.,
2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 1., 1., 2., 2.,
2., 2., 2., 2., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,
1., 1., 2., 2., 2., 1., 2., 2., 2., 2., 2., 2., 1., 1., 1.])
The output of the `scipy.cluster.hierarchy.cophenet` method is
represented in condensed form. We can use
`scipy.spatial.distance.squareform` to see the output as a
regular matrix (where each element ``ij`` denotes the cophenetic distance
between each ``i``, ``j`` pair of points in ``X``):
>>> squareform(cophenet(Z))
array([[0., 1., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2.],
[1., 0., 1., 2., 2., 2., 2., 2., 2., 2., 2., 2.],
[1., 1., 0., 2., 2., 2., 2., 2., 2., 2., 2., 2.],
[2., 2., 2., 0., 1., 1., 2., 2., 2., 2., 2., 2.],
[2., 2., 2., 1., 0., 1., 2., 2., 2., 2., 2., 2.],
[2., 2., 2., 1., 1., 0., 2., 2., 2., 2., 2., 2.],
[2., 2., 2., 2., 2., 2., 0., 1., 1., 2., 2., 2.],
[2., 2., 2., 2., 2., 2., 1., 0., 1., 2., 2., 2.],
[2., 2., 2., 2., 2., 2., 1., 1., 0., 2., 2., 2.],
[2., 2., 2., 2., 2., 2., 2., 2., 2., 0., 1., 1.],
[2., 2., 2., 2., 2., 2., 2., 2., 2., 1., 0., 1.],
[2., 2., 2., 2., 2., 2., 2., 2., 2., 1., 1., 0.]])
In this example, the cophenetic distance between points on ``X`` that are
very close (i.e., in the same corner) is 1. For other pairs of points is 2,
because the points will be located in clusters at different
corners - thus, the distance between these clusters will be larger.
rc rd Tr� rf r r r r; N�Y)r? ro r rt r� rC rn r �cophenetic_distancesrz rq rr �mean�sum�sqrt)
r� r� �Zsr� �zz�zr[ �Yy�Zz� numerator�denomA�denomBrc s
r3 r r , sF � �V �
�1�C� � � �A��Q�d��-�-�-�-�
��B�
�1��� �A� ��1��!��9��"�"�)� 4� 4� 4�B� �1� � �A��#�A�r�3�q�6�6�2�2�2��y�� �
�
�1�C� � � �A� ����C�0�0�0�0�
��� � �A� �����A�
�Q��B� �a��B��b��I�
��U�F�
��U�F��
�
���"�'�6�:�:�<�<�&�*�*�,�,�#>�@�@�@�A�
�r�7�Nr2 c � � t j | d�� � } | j }t | dd�� � |t j |� � k r|dk rt d� � �t
| g� � \ } |d dz }t j |dz
d ft j �
� � }t j
| |t |� � t |� � � � |S ) a�
Calculate 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 4 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.
Examples
--------
>>> from scipy.cluster.hierarchy import inconsistent, linkage
>>> from matplotlib import pyplot as plt
>>> X = [[i] for i in [2, 8, 0, 4, 1, 9, 9, 0]]
>>> Z = linkage(X, 'ward')
>>> print(Z)
[[ 5. 6. 0. 2. ]
[ 2. 7. 0. 2. ]
[ 0. 4. 1. 2. ]
[ 1. 8. 1.15470054 3. ]
[ 9. 10. 2.12132034 4. ]
[ 3. 12. 4.11096096 5. ]
[11. 13. 14.07183949 8. ]]
>>> inconsistent(Z)
array([[ 0. , 0. , 1. , 0. ],
[ 0. , 0. , 1. , 0. ],
[ 1. , 0. , 1. , 0. ],
[ 0.57735027, 0.81649658, 2. , 0.70710678],
[ 1.04044011, 1.06123822, 3. , 1.01850858],
[ 3.11614065, 1.40688837, 2. , 0.70710678],
[ 6.44583366, 6.76770586, 3. , 1.12682288]])
rc rd Tr� rf r z:The second argument d must be a nonnegative integer value.r r
r; ) r? ro rt r �floorrP rL r� rC r r rz )r� r� r� r� �Rs r3 r r � s� � �n �
�1�C� � � �A�
��B��Q�d��-�-�-�-�
���!��� � ��Q���� *� +� +� +�
'��s�
+�
+�C�Q�
�1��� �A�
��!�a�%���2�9�-�-�-�A���A�q�#�a�&�&�#�a�&�&�1�1�1� �Hr2 c �| � t j | t j d�� � } | j }t |� � dk s t |� � dk r |d dk r| � � � S t |� � dk rt
d� � �|d dk r| � � � S | � � � }|dd�dd�f � � � dk r<|dd�dd�f � � � d|d z k rt
d � � �|dd�dd�fxx dz cc< t j |d ft j �
� � }t j ||t |d � � dz � � t j
||� |d d� � g� � S ) a
Convert a linkage matrix generated by MATLAB(TM) to a new
linkage matrix compatible with this module.
The conversion does two things:
* the indices are converted from ``1..N`` to ``0..(N-1)`` form,
and
* a fourth column ``Z[:,3]`` is added where ``Z[i,3]`` represents the
number of original observations (leaves) in the non-singleton
cluster ``i``.
This function is useful when loading in linkages from legacy data
files generated by MATLAB.
Parameters
----------
Z : ndarray
A linkage matrix generated by MATLAB(TM).
Returns
-------
ZS : ndarray
A linkage matrix compatible with ``scipy.cluster.hierarchy``.
See Also
--------
linkage : for a description of what a linkage matrix is.
to_mlab_linkage : transform from SciPy to MATLAB format.
Examples
--------
>>> import numpy as np
>>> from scipy.cluster.hierarchy import ward, from_mlab_linkage
Given a linkage matrix in MATLAB format ``mZ``, we can use
`scipy.cluster.hierarchy.from_mlab_linkage` to import
it into SciPy format:
>>> mZ = np.array([[1, 2, 1], [4, 5, 1], [7, 8, 1],
... [10, 11, 1], [3, 13, 1.29099445],
... [6, 14, 1.29099445],
... [9, 15, 1.29099445],
... [12, 16, 1.29099445],
... [17, 18, 5.77350269],
... [19, 20, 5.77350269],
... [21, 22, 8.16496581]])
>>> Z = from_mlab_linkage(mZ)
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 2. , 12. , 1.29099445, 3. ],
[ 5. , 13. , 1.29099445, 3. ],
[ 8. , 14. , 1.29099445, 3. ],
[ 11. , 15. , 1.29099445, 3. ],
[ 16. , 17. , 5.77350269, 6. ],
[ 18. , 19. , 5.77350269, 6. ],
[ 20. , 21. , 8.16496581, 12. ]])
As expected, the linkage matrix ``Z`` returned includes an
additional column counting the number of original samples in
each cluster. Also, all cluster indices are reduced by 1
(MATLAB format uses 1-indexing, whereas SciPy uses 0-indexing).
rc )r< re r r r z&The linkage array must be rectangular.N� �?z%The format of the indices is not 1..Nr; )r? ro rC rt r� r> rP r� r� r� r �calculate_cluster_sizesrz �hstack�reshape)r� r� �Zpart�CSs r3 r r � s� � �L �
�1�B�I�S�1�1�1�A�
��B� �2�w�w�!�|�|��B���1� � ��A��!����v�v�x�x��
�2�w�w�!�|�|��A�B�B�B�
�!�u��z�z��v�v�x�x��
�F�F�H�H�E� �Q�Q�Q��!��V�}�����c�!�!�e�A�A�A�q��s�F�m�&7�&7�&9�&9�Q��A��Y�&F�&F��@�A�A�A� �!�!�!�Q�q�S�&�M�M�M�S��M�M�M� ��2�a�5�(�"�)� ,� ,� ,�B��&�u�b�#�b��e�*�*�q�.�A�A�A�
�9�e�R�Z�Z��1��q� 1� 1�2� 3� 3�3r2 c �r � t j | dt j �� � } | j }t |� � dk s t |� � dk r |d dk r| � � � S t
| dd�� � | dd�dd �f � � � }|dd�dd
�fxx d z
cc< |S ) a=
Convert 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.
See Also
--------
linkage : for a description of what a linkage matrix is.
from_mlab_linkage : transform from Matlab to SciPy format.
Examples
--------
>>> from scipy.cluster.hierarchy import ward, to_mlab_linkage
>>> from scipy.spatial.distance import pdist
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> Z = ward(pdist(X))
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 2. , 12. , 1.29099445, 3. ],
[ 5. , 13. , 1.29099445, 3. ],
[ 8. , 14. , 1.29099445, 3. ],
[11. , 15. , 1.29099445, 3. ],
[16. , 17. , 5.77350269, 6. ],
[18. , 19. , 5.77350269, 6. ],
[20. , 21. , 8.16496581, 12. ]])
After a linkage matrix ``Z`` has been created, we can use
`scipy.cluster.hierarchy.to_mlab_linkage` to convert it
into MATLAB format:
>>> mZ = to_mlab_linkage(Z)
>>> mZ
array([[ 1. , 2. , 1. ],
[ 4. , 5. , 1. ],
[ 7. , 8. , 1. ],
[ 10. , 11. , 1. ],
[ 3. , 13. , 1.29099445],
[ 6. , 14. , 1.29099445],
[ 9. , 15. , 1.29099445],
[ 12. , 16. , 1.29099445],
[ 17. , 18. , 5.77350269],
[ 19. , 20. , 5.77350269],
[ 21. , 22. , 8.16496581]])
The new linkage matrix ``mZ`` uses 1-indexing for all the
clusters (instead of 0-indexing). Also, the last column of
the original linkage matrix has been dropped.
rc �re r< r r Tr� rf Nr r r� )r? ro rC rt r� r> r )r� r� �ZPs r3 r* r* [ s� � �V �
�1�C�r�y�1�1�1�A�
��B�
�2�w�w�!�|�|��B���1� � ��A��!����v�v�x�x���Q�d��-�-�-�-�
�1�1�1�a��c�6�� � � � �B��q�q�q�!�A�#�v�J�J�J�#��J�J�J�
�Ir2 c � � t j | d�� � } t | dd�� � | dd�df | dd �df k � � � S )
a�
Return 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.
See Also
--------
linkage : for a description of what a linkage matrix is.
Examples
--------
>>> from scipy.cluster.hierarchy import median, ward, is_monotonic
>>> from scipy.spatial.distance import pdist
By definition, some hierarchical clustering algorithms - such as
`scipy.cluster.hierarchy.ward` - produce monotonic assignments of
samples to clusters; however, this is not always true for other
hierarchical methods - e.g. `scipy.cluster.hierarchy.median`.
Given a linkage matrix ``Z`` (as the result of a hierarchical clustering
method) we can test programmatically whether it has the monotonicity
property or not, using `scipy.cluster.hierarchy.is_monotonic`:
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> Z = ward(pdist(X))
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 2. , 12. , 1.29099445, 3. ],
[ 5. , 13. , 1.29099445, 3. ],
[ 8. , 14. , 1.29099445, 3. ],
[11. , 15. , 1.29099445, 3. ],
[16. , 17. , 5.77350269, 6. ],
[18. , 19. , 5.77350269, 6. ],
[20. , 21. , 8.16496581, 12. ]])
>>> is_monotonic(Z)
True
>>> Z = median(pdist(X))
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 2. , 12. , 1.11803399, 3. ],
[ 5. , 13. , 1.11803399, 3. ],
[ 8. , 15. , 1.11803399, 3. ],
[11. , 14. , 1.11803399, 3. ],
[18. , 19. , 3. , 6. ],
[16. , 17. , 3.5 , 6. ],
[20. , 21. , 3.25 , 12. ]])
>>> is_monotonic(Z)
False
Note that this method is equivalent to just verifying that the distances
in the third column of the linkage matrix appear in a monotonically
increasing order.
rc rd Tr� rf r Nr ���)r? ro r rw �r� s r3 r r � s_ � �\ �
�1�C� � � �A��Q�d��-�-�-�-�
�a�b�b�!�e�H��#�2�#�q�&� � !� &� &� (� (�(r2 c � � t j | d�� � } d}|rd|z nd} t | � � t j k rt d|z � � �| j t j k rt d|z � � �t | j � � dk rt d |z � � �| j d
d k rt d |z � � �| j d
d
k rt d|z � � �| dd�d
f d
k �
� � rt d|z � � �| dd�d
f d
k �
� � rt d|z � � �| dd�df d
k �
� � rt d|z � � �n:# t $ r-}|r� |r t t |� � � � d}Y d}~nd}~ww xY w|S )a� Return 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.
See Also
--------
linkage : for a description of what a linkage matrix is.
inconsistent : for the creation of a inconsistency matrix.
Examples
--------
>>> from scipy.cluster.hierarchy import ward, inconsistent, is_valid_im
>>> from scipy.spatial.distance import pdist
Given a data set ``X``, we can apply a clustering method to obtain a
linkage matrix ``Z``. `scipy.cluster.hierarchy.inconsistent` can
be also used to obtain the inconsistency matrix ``R`` associated to
this clustering process:
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> Z = ward(pdist(X))
>>> R = inconsistent(Z)
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 2. , 12. , 1.29099445, 3. ],
[ 5. , 13. , 1.29099445, 3. ],
[ 8. , 14. , 1.29099445, 3. ],
[11. , 15. , 1.29099445, 3. ],
[16. , 17. , 5.77350269, 6. ],
[18. , 19. , 5.77350269, 6. ],
[20. , 21. , 8.16496581, 12. ]])
>>> R
array([[1. , 0. , 1. , 0. ],
[1. , 0. , 1. , 0. ],
[1. , 0. , 1. , 0. ],
[1. , 0. , 1. , 0. ],
[1.14549722, 0.20576415, 2. , 0.70710678],
[1.14549722, 0.20576415, 2. , 0.70710678],
[1.14549722, 0.20576415, 2. , 0.70710678],
[1.14549722, 0.20576415, 2. , 0.70710678],
[2.78516386, 2.58797734, 3. , 1.15470054],
[2.78516386, 2.58797734, 3. , 1.15470054],
[6.57065706, 1.38071187, 3. , 1.15470054]])
Now we can use `scipy.cluster.hierarchy.is_valid_im` to verify that
``R`` is correct:
>>> is_valid_im(R)
True
However, if ``R`` is wrongly constructed (e.g., one of the standard
deviations is set to a negative value), then the check will fail:
>>> R[-1,1] = R[-1,1] * -1
>>> is_valid_im(R)
False
rc rd T�%r � z?Variable %spassed as inconsistency matrix is not a numpy array.z5Inconsistency matrix %smust contain doubles (double).r zCInconsistency matrix %smust have shape=2 (i.e. be two-dimensional).r r
z+Inconsistency matrix %smust have 4 columns.r z2Inconsistency matrix %smust have at least one row.Nz;Inconsistency matrix %scontains negative link height means.zIInconsistency matrix %scontains negative link height standard deviations.z5Inconsistency matrix %scontains negative link counts.F)r? ro r� �ndarrayr� r< rC r� rt rP �any� Exceptionr9 �str)r� �warningrg rh �valid�name_str�es r3 r r sU � �n �
�1�C� � � �A� �E� #�+�u�t�|�|��H� � ��7�7�b�j� � �� -�/7� 8� 9� 9�
9� �7�b�i� � �� (�*2� 3� 4� 4�
4� �q�w�<�<�1� � � � 4�6>� ?� @� @�
@� �7�1�:��?�?� � J� %� &� '� '�
'� �7�1�:��>�>� � $�&.� /� 0� 0�
0�
�a�a�a��d�G�a�K� � � � � 9� � -�/7� 8� 9� 9�
9�
�a�a�a��d�G�a�K� � � � � G� � ;�=E� F� G� G�
G�
�a�a�a��d�G�a�K� � � � � 3� � '�)1� 2� 3� 3�
3� 3�� � � � � � � � � � �S��V�V� � � ������������ ���� �Ls �E"F �
F=�#F8�8F=c �l � t j | d�� � } d}|rd|z nd} t | � � t j k rt d|z � � �| j t j k rt d|z � � �t | j � � dk rt d |z � � �| j d
d k rt d |z � � �| j d
d
k rt d� � �| j d
}|d
k r�| dd�d
f d
k �
� � s"| dd�d
f d
k �
� � rt d|z � � �| dd�df d
k �
� � rt d|z � � �| dd�df d
k �
� � rt d|z � � �t | � � rt d|z � � �t | � � rt d|z � � �n:# t $ r-}|r� |r t t |� � � � d}Y d}~nd}~ww xY w|S )a�
Check the validity of a linkage matrix.
A linkage matrix is valid if it is a 2-D 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.
See Also
--------
linkage: for a description of what a linkage matrix is.
Examples
--------
>>> from scipy.cluster.hierarchy import ward, is_valid_linkage
>>> from scipy.spatial.distance import pdist
All linkage matrices generated by the clustering methods in this module
will be valid (i.e., they will have the appropriate dimensions and the two
required expressions will hold for all the rows).
We can check this using `scipy.cluster.hierarchy.is_valid_linkage`:
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> Z = ward(pdist(X))
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 2. , 12. , 1.29099445, 3. ],
[ 5. , 13. , 1.29099445, 3. ],
[ 8. , 14. , 1.29099445, 3. ],
[11. , 15. , 1.29099445, 3. ],
[16. , 17. , 5.77350269, 6. ],
[18. , 19. , 5.77350269, 6. ],
[20. , 21. , 8.16496581, 12. ]])
>>> is_valid_linkage(Z)
True
However, if we create a linkage matrix in a wrong way - or if we modify
a valid one in a way that any of the required expressions don't hold
anymore, then the check will fail:
>>> Z[3][1] = 20 # the cluster number 20 is not defined at this point
>>> is_valid_linkage(Z)
False
rc rd Tr r z/Passed linkage argument %sis not a valid array.z&Linkage matrix %smust contain doubles.r z=Linkage matrix %smust have shape=2 (i.e. be two-dimensional).r r
z%Linkage matrix %smust have 4 columns.r z6Linkage must be computed on at least two observations.Nz$Linkage %scontains negative indices.z&Linkage %scontains negative distances.r z#Linkage %scontains negative counts.z9Linkage %suses non-singleton cluster before it is formed.z/Linkage %suses the same cluster more than once.F)r? ro r� r r� r< rC r� rt rP r
�+_check_hierarchy_uses_cluster_before_formed�,_check_hierarchy_uses_cluster_more_than_oncer r9 r )r� r
rg rh r r r� r s r3 r r � s� � �b �
�1�C� � � �A� �E� #�+�u�t�|�|��H�$� ��7�7�b�j� � �� M� $� %� &� &�
&� �7�b�i� � �� D�x� O�P�P� P� �q�w�<�<�1� � � � 1�3;� <� =� =�
=� �7�1�:��?�?� � D�x� O�P�P� P� �7�1�:��?�?� � -� .� .�
.�
�G�A�J�� �q�5�5��1�1�1�a�4��1��!�!�#�#�
+��!�!�!�Q�$��!� �'8�'8�':�':�
+� �!G�!)�"*� +� +� +��!�!�!�Q�$��!� � � �"�"�
+� �!I�!)�"*� +� +� +��!�!�!�Q�$��!� � � �"�"�
+� �!F�!)�"*� +� +� +� 6�q� 9� 9� 9� � -�/7� 8� 9� 9�
9� 7�� :� :� )� � N� '� (� )� )�
)� )�� � � � � � � � � � �S��V�V� � � ������������ ���� �Ls �GG: �:
H1�#H,�,H1c � � | j d dz }t d|dz
� � D ]'}| |df ||z k s| |df ||z k r dS �(dS �Nr r TF)rt r� )r� r� r� s r3 r r sj � � ���
�Q��A�
�1�a�!�e�_�_� � �� �Q��T�7�a�!�e� � �q��A��w�!�a�%� /� /��4�4� 0� �5r2 c �F � | j d dz }t g � � }t d|dz
� � D ]m}| |df |v s"| |df |v s| |df | |df k r dS |� | |df � � |� | |df � � �ndS r )rt r� r� r� )r� r� �chosenr� s r3 r r s� � � ���
�Q��A�
��W�W�F�
�1�a�!�e�_�_� � ��
�a��d�G�v� � �1�Q��T�7�f�#4�#4��1�a�4��A�a��d�G�9K�9K��4�4��
�
�1�Q��T�7�����
�
�1�Q��T�7����� �5r2 c � � | j d dz }t g � � }t d|dz
� � D ]V}|� t | |df � � � � |� t | |df � � � � �Wt t dd|z dz
� � � � }t |� |� � � � dk S )Nr r r )rt r� r� r� rz r� �
difference)r� r� r r� � must_chosens r3 �&_check_hierarchy_not_all_clusters_usedr s� � � ���
�Q��A�
��W�W�F�
�1�a�!�e�_�_� !� !���
�
�3�q��A��w�<�<� � � ��
�
�3�q��A��w�<�<� � � � ��e�A�q�1�u�q�y�)�)�*�*�K� �{�%�%�f�-�-� .� .�� 2�2r2 c �r � t j | d�� � } t | dd�� � | j d dz S )a
Return 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.
Examples
--------
>>> from scipy.cluster.hierarchy import ward, num_obs_linkage
>>> from scipy.spatial.distance import pdist
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> Z = ward(pdist(X))
``Z`` is a linkage matrix obtained after using the Ward clustering method
with ``X``, a dataset with 12 data points.
>>> num_obs_linkage(Z)
12
rc rd Tr� rf r r )r? ro r rt r s r3 r' r' s> � �B �
�1�C� � � �A��Q�d��-�-�-�-�
�G�A�J��N�r2 c �� � t | d�� � t j |d�� � t j | d�� � } t j |d�� � }t j |� � t
| � � k S )a�
Check 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.
See Also
--------
linkage : for a description of what a linkage matrix is.
Examples
--------
>>> from scipy.cluster.hierarchy import ward, correspond
>>> from scipy.spatial.distance import pdist
This method can be used to check if a given linkage matrix ``Z`` has been
obtained from the application of a cluster method over a dataset ``X``:
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> X_condensed = pdist(X)
>>> Z = ward(X_condensed)
Here, we can compare ``Z`` and ``X`` (in condensed form):
>>> correspond(Z, X_condensed)
True
T)rg rc rd )r rq rr r? ro r{ r' )r� r� s r3 r r D st � �b �Q�d�#�#�#�#� ����&�&�&�&�
�
�1�C� � � �A�
�
�1�C� � � �A� � �a� � �O�A�$6�$6� 6�6r2 r c � � t j | d�� � } t | dd�� � | j d dz }t j |fd� � � }t | g� � \ } |d
k r�|�t
| |� � }n:t j |d�� � }t |dd �� � t |g� � \ }t j | ||t |� � t |� � � � �n%|d
k r2t j | |t |� � t |� � � � n�|dk r2t j
| |t |� � t |� � � � n�|dk rEt |g� � \ }t j | ||t |� � t |� � � � nj|dk rEt |g� � \ }t j | ||t |� � t |� � � � n t! dt# |� � z � � �|S )a�
Form 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 : scalar
For criteria 'inconsistent', 'distance' or 'monocrit',
this is the threshold to apply when forming flat clusters.
For 'maxclust' or 'maxclust_monocrit' criteria,
this would be max number of clusters requested.
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)
fcluster(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)
fcluster(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.
See Also
--------
linkage : for information about hierarchical clustering methods work.
Examples
--------
>>> from scipy.cluster.hierarchy import ward, fcluster
>>> from scipy.spatial.distance import pdist
All cluster linkage methods - e.g., `scipy.cluster.hierarchy.ward`
generate a linkage matrix ``Z`` as their output:
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> Z = ward(pdist(X))
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 2. , 12. , 1.29099445, 3. ],
[ 5. , 13. , 1.29099445, 3. ],
[ 8. , 14. , 1.29099445, 3. ],
[11. , 15. , 1.29099445, 3. ],
[16. , 17. , 5.77350269, 6. ],
[18. , 19. , 5.77350269, 6. ],
[20. , 21. , 8.16496581, 12. ]])
This matrix represents a dendrogram, where the first and second elements
are the two clusters merged at each step, the third element is the
distance between these clusters, and the fourth element is the size of
the new cluster - the number of original data points included.
`scipy.cluster.hierarchy.fcluster` can be used to flatten the
dendrogram, obtaining as a result an assignation of the original data
points to single clusters.
This assignation mostly depends on a distance threshold ``t`` - the maximum
inter-cluster distance allowed:
>>> fcluster(Z, t=0.9, criterion='distance')
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=int32)
>>> fcluster(Z, t=1.1, criterion='distance')
array([1, 1, 2, 3, 3, 4, 5, 5, 6, 7, 7, 8], dtype=int32)
>>> fcluster(Z, t=3, criterion='distance')
array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4], dtype=int32)
>>> fcluster(Z, t=9, criterion='distance')
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32)
In the first case, the threshold ``t`` is too small to allow any two
samples in the data to form a cluster, so 12 different clusters are
returned.
In the second case, the threshold is large enough to allow the first
4 points to be merged with their nearest neighbors. So, here, only 8
clusters are returned.
The third case, with a much higher threshold, allows for up to 8 data
points to be connected - so 4 clusters are returned here.
Lastly, the threshold of the fourth case is large enough to allow for
all data points to be merged together - so a single cluster is returned.
rc rd Tr� rf r r r� r; r Nr� rq �maxclust�monocrit�maxclust_monocritz'Invalid cluster formation criterion: %s)r? ro r rt r� rL r r r �
cluster_in�floatrz � cluster_dist�cluster_maxclust_dist�cluster_monocrit�cluster_maxclust_monocritrP r )r� �t� criterion�depthr� r r� rJ s r3 r r | s� � �n �
�1�C� � � �A��Q�d��-�-�-�-� ���
�Q��A�
��!��S�!�!�!�A� '��s�
+�
+�C�Q��N�"�"� �9� �Q��&�&�A�A��
�1�C�(�(�(�A� ���C� 0� 0� 0� 0� /��s�3�3�C�Q�� �a��A�u�Q�x�x��Q���8�8�8�8� �j� � �� ��1�e�A�h�h��A���7�7�7�7� �j� � ��(��A�s�1�v�v�s�1�v�v�>�>�>�>� �j� � �1�8�*�=�=�
���#�A�x��E�!�H�H�c�!�f�f�E�E�E�E� �)� )� )�1�8�*�=�=�
���,�Q��!�S��V�V�S��V�V�L�L�L�L��B� �y�>�>�*� +� +� +� �Hr2 c � � t j | dt j �� � } t | � � t j k st | j � � dk rt d� � �t j | |�� � }t ||�� � }|�t ||�� � }nt j |d� � � }t |||||�
� � } | S ) a�
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 1-D 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 : scalar
For criteria 'inconsistent', 'distance' or 'monocrit',
this is the threshold to apply when forming flat clusters.
For 'maxclust' or 'maxclust_monocrit' criteria,
this would be max number of clusters requested.
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 or function, 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``.
Examples
--------
>>> from scipy.cluster.hierarchy import fclusterdata
This is a convenience method that abstracts all the steps to perform in a
typical SciPy's hierarchical clustering workflow.
* Transform the input data into a condensed matrix with `scipy.spatial.distance.pdist`.
* Apply a clustering method.
* Obtain flat clusters at a user defined distance threshold ``t`` using `scipy.cluster.hierarchy.fcluster`.
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> fclusterdata(X, t=1)
array([3, 3, 3, 4, 4, 4, 2, 2, 2, 1, 1, 1], dtype=int32)
The output here (for the dataset ``X``, distance threshold ``t``, and the
default settings) is four clusters with three data points each.
rc r r z7The observation matrix X must be an n by m numpy array.)rX )rW N)r� rd )r) r* r� r( )
r? ro rC r� r r� rt r� rq rx r# r r )
r� r( r) rX r* rW r� r� r� rJ s
r3 r r 7
s� � �f �
�1�C�r�y�1�1�1�A� �A�w�w�"�*� � ��A�G� � �� 1� 1�� !� "� "� "� ��q��(�(�(�A���&�!�!�!�A��y� ��e� $� $� $��� �J�q�� $� $� $����i�u��Q�?�?�?�A� �Hr2 c � � t j | d�� � } t | dd�� � | j d dz }t j |fd� � � }t | g� � \ } t
j | |t |� � � � |S )
aA
Return 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.
See Also
--------
dendrogram : for information about dendrogram structure.
Examples
--------
>>> from scipy.cluster.hierarchy import ward, dendrogram, leaves_list
>>> from scipy.spatial.distance import pdist
>>> from matplotlib import pyplot as plt
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> Z = ward(pdist(X))
The linkage matrix ``Z`` represents a dendrogram, that is, a tree that
encodes the structure of the clustering performed.
`scipy.cluster.hierarchy.leaves_list` shows the mapping between
indices in the ``X`` dataset and leaves in the dendrogram:
>>> leaves_list(Z)
array([ 2, 0, 1, 5, 3, 4, 8, 6, 7, 11, 9, 10], dtype=int32)
>>> fig = plt.figure(figsize=(25, 10))
>>> dn = dendrogram(Z)
>>> plt.show()
rc rd Tr� rf r r r� r; ) r? ro r rt r� rL r �prelistrz )r� r� �MLs r3 r" r" �
s� � �` �
�1�C� � � �A��Q�d��-�-�-�-� ���
�Q��A� ��1�$�c� "� "� "�B�
&��s�
+�
+�C�Q���q�"�c�!�f�f�%�%�%�
�Ir2 � � � �
�2 � �U �( �- �Z c � � t g � � }g }| D ]0}||vr*|� |� � |� |� � �1|S )z}
Remove duplicates AND preserve the original order of the elements.
The set class is not guaranteed to do this.
)r� r� r� )�L� seen_before�L2r� s r3 � _remove_dupsr= �
sU � � �b�'�'�K� �B�
� � �� �K� � � �O�O�A� � � � �I�I�a�L�L�L��
�Ir2 c �D � t D ]}| |k rt | c S �d S r� )�_dtextsortedkeys� _dtextsizes��pr� s r3 �_get_tick_text_sizerC �
s9 � �
� "� "�� ��6�6� �q�>� !� !� !� �"� "r2 c �D � t D ]}| |k rt | c S �d S r� )�_drotationsortedkeys�
_drotationrA s r3 �_get_tick_rotationrG �
s9 � �
!� !� !�� ��6�6� �a�=� � � � �!� !r2 �C0c �T
� | �dd l }dd l}dd l}n"# t $ r}t d� � |�d }~ww xY w| � |j � � � } d}nd}t
|� � dz }||dz z }t j dt
|� � dz dz d� � }|dv �r�|d k r/| � d|g� � | �
d|g� � n.| � |dg� � | �
d|g� � | }|}|r,| � g � � | � g � � �nd| � |� � |d k r| j
� d
� � n| j
� d � � | � � � D ]}|� d� � �|
�)t# t% t
|� � � � � � n|
}| �)t# t' t
|� � � � � � n| }| � |||� � � �nt|d v �ro|d
k r/| �
|dg� � | � d|g� � n.| �
d|g� � | � d|g� � |}| }|r+| � g � � | � g � � n�| � |� � |d
k r| j � d� � n| j � d
� � | � � � D ]}|� d� � �| �)t# t' t
|� � � � � � n| }|
�| � ||
|� � � n| � ||�� � t1 |� � }i }|D ]}g ||< �t3 |||� � D ]<\ } } }|| � t7 t3 | | � � � � � � �=i } |D ]*}|j � || |f�� � } | | |< �+|D ]#}||
k r| � | | � � �$|
| v r| � | |
� � | ��|j j } | D ]�\ }!}"|d v r | |"|!f|dz d�� � }n | |!|"fd|dz �� � }| �! |� � |�" | j# � � |�$ d� � |�% d� � ��|r|j �& � � d S d S )Nr z~You must install the matplotlib library to plot the dendrogram. Use no_plot=True to calculate the dendrogram without plotting.TFr2 g�������?r )�top�bottomrJ rK )�rotation�size)r� r� r� r� )rM )�colors�d r� )�widthr� g �?r� )'�matplotlib.pylab�matplotlib.patches�matplotlib.collections� ImportError�pylab�gcar� r? r� �set_ylim�set_xlim�
set_xticks�set_xticklabels�xaxis�set_ticks_position�get_xticklines� set_visibler# rG rC �
set_yticks�set_yticklabels�yaxis�get_yticklinesr= �zipr� �list� collections�LineCollection�add_collection�patches�Ellipse�
add_artist� set_clip_box�bbox� set_alpha�
set_facecolor�draw_if_interactive)#�icoords�dcoords�ivlrB r� �mh� orientation� no_labels�
color_list�leaf_font_size�
leaf_rotation�contraction_marks�ax�above_threshold_color�
matplotlibr �trigger_redraw�ivw�dvw�iv_ticks�xlines�ylines�line�leaf_rot� leaf_font� colors_used�color_to_lines�color�xline�yline�colors_to_collections�collri r� r[ s# r3 �_plot_dendrogramr� �
s3 � � A�
�:� #� #� #� #�!�!�!�!�%�%�%�%�%�� � A� A� A�� 9� :� :�?@� A�����A����
�z�
�
�
!�
!�
#�
#�� ��� �� �c�(�(�R�-�C�
�r�D�y�.�C��y��C��H�H�r�M�A� -�r�2�2�H��'�'�'� �%� � � �K�K��C�� !� !� !� �K�K��C�� !� !� !� !� �K�K��a�� !� !� !� �K�K��C�� !� !� !����� � G� �M�M�"� � � � � � �r� "� "� "� "� �M�M�(� #� #� #��e�#�#���+�+�H�5�5�5�5���+�+�E�2�2�2� �)�)�+�+�
(�
(��� � ��'�'�'�'� *� 1� � 0��S��� :� :�;�;�;�8E�
� ,� 3� � 2�3�s�8�8� <� <�=�=�=�:H�
� � � �s�X�I� � F� F� F� F� �)� )� )� �&� � � �K�K��a�� !� !� !� �K�K��C�� !� !� !� !� �K�K��C�� !� !� !� �K�K��C�� !� !� !����� � 8� �M�M�"� � � � � � �r� "� "� "� "� �M�M�(� #� #� #��f�$�$���+�+�G�4�4�4�4���+�+�F�3�3�3� �)�)�+�+�
(�
(��� � ��'�'�'�'� ,� 3� � 2�3�s�8�8� <� <�=�=�=�:H�
� �(��"�"�3� �Y�"�O�O�O�O��"�"�3�Y�"�7�7�7� �z�*�*�K��N� � #� #�� "��u� � �!$�V�V�Z�!@�!@� >� >� ���u��u� �$�$�T�#�e�U�*;�*;�%<�%<�=�=�=�=� �� � ,� ,���%�4�4�^�E�5J�=B�H� 5� F� F��'+� �e�$�$� � <� <�� �)� )� )� � � � 3�E� :� ;� ;� ;�� � 5�5�5�
���/�0E�F�G�G�G��$� �$�,��'� !� !�F�Q��� /�/�/��G�Q��F�#��)�C�@�@�@����G�Q��F�#�c�C�i�@�@�@�� �M�M�!� � � �
�N�N�2�7� #� #� #�
�K�K�� � � �
�O�O�C� � � � �� /���,�,�.�.�.�.�.�/� /s � �
0�+�0) �C1�C2�C3�C4�C5�C6�C7�C8�C9c � � | �t } n,t | � � t t fvrt d� � �d� | D � � }d|v rt d� � �| adS )a$
Set list of matplotlib color codes for use by dendrogram.
Note that this palette is global (i.e., setting it once changes the colors
for all subsequent calls to `dendrogram`) and that it affects only the
the colors below ``color_threshold``.
Note that `dendrogram` also accepts a custom coloring function through its
``link_color_func`` keyword, which is more flexible and non-global.
Parameters
----------
palette : list of str or None
A list of matplotlib color codes. The order of the color codes is the
order in which the colors are cycled through when color thresholding in
the dendrogram.
If ``None``, resets the palette to its default (which are matplotlib
default colors C1 to C9).
Returns
-------
None
See Also
--------
dendrogram
Notes
-----
Ability to reset the palette with ``None`` added in SciPy 0.17.0.
Examples
--------
>>> import numpy as np
>>> 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']
['C1', 'C0', 'C0', 'C0', 'C0']
>>> hierarchy.set_link_color_palette(['c', 'm', 'y', 'k'])
>>> dn = hierarchy.dendrogram(Z, no_plot=True, above_threshold_color='b')
>>> 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)
Nz palette must be a list or tuplec �8 � g | ]}t |t � � ��S r1 )r� r )rH rB s r3 rI z*set_link_color_palette.<locals>.<listcomp>� s" � �3�3�3�a�z�!�S�!�!�3�3�3r2 Fz/all palette list elements must be color strings)�_link_line_colors_defaultr� rd �tupler� �_link_line_colors)�palette�_ptypess r3 r) r) � sp � �r ��+���
�g� � �t�U�m� +� +��9�:�:�:�3�3�7�3�3�3�G� �����I�J�J�J� ���r2 TrJ c � � t j | d�� � } |dvrt d� � �|�0| j d dz t |� � k rt d� � �t | d d
� � � | j }|d dz }t
|� � t t fv rt |� � }nt d � � �|d
vrt d� � �|dk r||k s|dk r|}|dk rd}|dk r|dk r t j
}|rg }nd}g }g }g }dg}dg}g }|�t |t � � r"|dk r t | dd�df � � dz }|||||d�} |rg nd} t d1i d
| �d|�d|�d|�d|�d|�d |�d |�d |�d | �d d|z dz
�d!d"�d#|�d$|�d%|�d&|�d'|�d(|�d)|�d*|�d+|�d,| �d-|�d.|�� |
s6t | dd�df � � } t |||||| || || |
| ||�/� � t! | � � | d0< | S )2a�*
Plot 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 final 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
with de default matplotlib color ``'C0'``. If :math:`t` is less
than or equal to zero, all nodes are colored ``'C0'``.
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
sequence, with ``n == Z.shape[0] + 1``. 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.
``'descending'``
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)
# leaf_label_func can also be used together with ``truncate_mode`` parameter,
# in which case you will get your leaves labeled after truncation:
dendrogram(Z, leaf_label_func=llf, leaf_rotation=90,
truncate_mode='level', p=2)
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 ``'C0'``.
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.
``'leaves_color_list'``
A list of color names. The k'th element represents the color of the
k'th leaf.
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
--------
>>> import numpy as np
>>> 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()
rc rd )rJ r� rK r� z>orientation must be one of 'top', 'left', 'bottom', or 'right'Nr r z.Dimensions of Z and labels must be consistent.Tr� rf z$The second argument must be a number)�lastp�mtica�level�noneNzInvalid truncation mode.r� r� r� F�defaultr gffffff�?)�icoord�dcoordrr �leavesrv rB �
truncate_mode�color_threshold�
get_leavesrt �labels�
count_sort�
distance_sort�show_leaf_countsr� �iv� rr r� � icoord_list� dcoord_list�lvs�
current_colorrv �currently_below_threshold�leaf_label_funcry �link_color_funcr{ )rw rx ry rz r{ �leaves_color_listr1 )r? ro rP rt r� r r� rz r# r� �infr� r r� �_dendrogram_calculate_infor� �_get_leaves_color_list) r� rB r� r� r� rt r� r� r� r� �no_plotru rw rx r� �show_contractedr� rz r{ r� r� r� r� r� rv r� r� rr r� ry rs s r3 r r � s� � �f �
�1�C� � � �A��<�<�<�� 0� 1� 1� 1� ��a�g�a�j�1�n��F� � � ;� ;��I�J�J�J��Q�d��-�-�-�-�
��B�
�1��� �A� �A�w�w�3��,� � � ��F�F����>�?�?�?�� E�E�E��3�4�4�4��� � � �q�5�5�A��F�F��A��� � � �
��� � � ��6�6���A�� �������K��K��J��C�M�!&�� �
�C�� �:�o�s�#C�#C� �#2�i�#?�#?� �a����1��g�,�,��,�� �+�c��j� 2� 2�A� .�7���4�� � 5� 5� 5�
�!�5��q�5�#�m�5� (��5� �:� 5�
�K� 5� �v�
5� �:�5� $�m�5� *�)�5� �A�#��'�'�5� �3�5�
�C�5� �!�5� �K� 5� �K� 5�
�C�!5�" $�m�#5�$ �:�%5�& #<�";�'5�( (��)5�* ,�+�+5�, (��-5�. 4� 3�/5� 5�2 � F�
��1�1�1�a�4��\�\����k�3��1�b�+�"�J�(6�'4�+<� �/D�
F� F� F� F� 4�A� 6� 6�A��� �Hr2 c � � d gt | d � � z }t | d | d | d � � D ]N\ }}}t ||� � D ]7\ }}|dk r,|dz dk r#|dz d k rt |� � dz
d
z }|||< �8�O|S ) Nr� r� r� rv r� r r r r r2 )r� rc rz )r� r� �link_x�link_y�
link_color�xi�yi�
leaf_indexs r3 r� r� A
s� � � ���Q�x�[�!1�!1�1��&)�!�H�+�*+�H�+�*+�L�/�';� ';� ;� ;�"���
� �F�F�+�+� ;� ;�H�R���S�y�y�b�1�f��k�k�b�1�f��k�k�
"�"�g�g��k�b� 0�
�0:�!�*�-�� ;� � r2 c �p � |�"|� t |� � � � |��|r-|� |t |� � � � � � d S |�-|� |t ||z
� � � � d S |� t t |� � � � � � d S d S r� �r� rz r ) r� rB r� r� r� rr r� r� r� s r3 �_append_singleton_leaf_noder� R
s� � � �� �
�
�3�q�6�6���� �� � (� �J�J���s�1�v�v�.�.� /� /� /� /� /� �!��
�
�6�#�a�!�e�*�*�-�.�.�.�.�.� �
�
�3�s�1�v�v�;�;�'�'�'�'�'� �r2 c
�f � |�"|� t |� � � � |��|r-|� |t |� � � � � � d S | rB|� dt t | ||z
df � � � � z dz � � d S |� d� � d S d S )N�(r �)r r� )
r� rB r� r� r� rr r� r� r� r� s
r3 � _append_nonsingleton_leaf_noder� l
s� � � �� �
�
�3�q�6�6����
�� � � �J�J���s�1�v�v�.�.� /� /� /� /� /� �
��
�
�3��S��1�q�5�!�8��%5�%5�!6�!6�6��<�=�=�=�=�=��
�
�2������ �r2 c � � t | |t | ||z
df � � ||� � t | |t | ||z
df � � ||� � d S )Nr r )� _append_contraction_marks_subrz �r� r� r� r� ry s r3 �_append_contraction_marksr� ~
s^ � �!�!�R��Q�q�1�u�a�x�[�)9�)9�1�>O�P�P�P�!�!�R��Q�q�1�u�a�x�[�)9�)9�1�>O�P�P�P�P�Pr2 c � � ||k rz|� || ||z
df f� � t | |t | ||z
df � � ||� � t | |t | ||z
df � � ||� � d S d S )Nr r r )r� r� rz r� s r3 r� r� �
s� � ��A�v�v�� � �"�a��A��q��k�!2�3�3�3�%�a��S��1�q�5�!�8��-=�-=�q�BS�T�T�T�%�a��S��1�q�5�!�8��-=�-=�q�BS�T�T�T�T�T� �vr2 r r� c �4 � |
dk rt d� � �|
dk rt d� � �|dk r�d|
z |z
|
cxk r|
k rIn nF| |
|
z
df }t | ||
||| ||
|| �
�
|�t | | dz |
|
|� � | dz d d
|fS |
|
k r t | ||
||| ||
|� � | dz d d
d
fS n~|d k rx|
|
k rL||k rF| |
|
z
df }t | ||
||| ||
|| �
�
|�t | | dz |
|
|� � | dz d d
|fS |
|
k r t | ||
||| ||
|� � | dz d d
d
fS |
|
k r t | ||
||| ||
|� � | dz d d
d
fS t | |
|
z
df � � }t | |
|
z
d f � � } ||
k r| ||
z
d
f } | ||
z
df } nd } d
} | |
k r| | |
z
d
f } | | |
z
df } nd } d
} |dk s|dk r| | k r| }!|}"nQ|}!| }"nL|dk r| | k r|}!| }"n;| }!|}"n6|dk s|dk r| | k r| }!|}"n |}!| }"n|dk r| | k r|}!| }"n | }!|}"n|}!| }"t d+i d| �d|�d|�d|�d|�d|�d|�d|�d|�d| �d|!�d | �d | �d |
�d |�d |�d!|�d"|�d#|�d$|�d%|�d |d z �d&|�d'|�d(|��\ }#}$}%}&| |
|
z
df }'|'|k s|dk r3|}(|d r#|d d z t
t � � z |d< d)|d< nd|d< t |d }(t d+i d| �d|�d|�d|�d|�d|�d|�d|�d|�d| �d|"�d | |$z �d | �d |
�d |�d |�d!|�d"|�d#|�d$|�d%|�d |d z �d&|�d'|�d(|��\ })}*}+},t |&|,|'� � }-|� |#|#|)|)g� � |� |%|'|'|+g� � |�R |t |
� � � � }.t |.t � � st d*� � �|� |.� � n|� |(� � |#|)z dz |$|*z |'|-fS ),a�
Calculate the endpoints of the links as well as the labels for the
the dendrogram rooted at the node with index i. iv is the independent
variable value to plot the left-most leaf node below the root node i
(if orientation='top', this would be the left-most x value where the
plotting of this root node i and its descendents should begin).
ivl is a list to store the labels of the leaf nodes. The leaf_label_func
is called whenever ivl != None, labels == None, and
leaf_label_func != None. When ivl != None and labels != None, the
labels list is used only for labeling the leaf nodes. When
ivl == None, no labels are generated for leaf nodes.
When get_leaves==True, a list of leaves is built as they are visited
in the dendrogram.
Returns a tuple with l being the independent variable coordinate that
corresponds to the midpoint of cluster to the left of cluster i if
i is non-singleton, otherwise the independent coordinate of the leaf
node if i is a leaf node.
Returns
-------
A tuple (left, w, h, md), where:
* left is the independent variable coordinate of the center of the
the U of the subtree
* w is the amount of space used for the subtree (in independent
variable units)
* h is the height of the subtree in dependent variable units
* md is the ``max(Z[*,2]``) for all nodes ``*`` below and including
the target node.
r z"Invalid singleton cluster count n.r z Invalid root cluster index i.r� r Ng @g $@r� r� r r � ascendingT�
descendingr� rB r� r� r� rt r� r� r� r� r� r� rr r� r� r� r� r� rv r� r� ry r� r{ Fz6link_color_func must return a matplotlib color string!r1 )
rP r� r� r� rz r� r� r� r� r� r� r r� )/r� rB r� r� r� rt r� r� r� r� r� r� rr r� r� r� r� �mhrr� rv r� r� r� ry r� r{ r� �aa�ab�na�da�nb�db�ua�ub�uiva�uwa�uah�uamd�hrc �uivb�uwb�ubh�ubmd�max_dist�vs/ r3 r� r� �
s� � �b �A�v�v��=�>�>�>��B�w�w��8�9�9�9��� � �
�Q�3��7�Q� � � � �!� � � � � ��!�a�%��(� �A� *�1�a��E�3��+:�A�v�+;�
=�
=�
=� !�,�)�!�R�#�X�q�!�=N�O�O�O���H�d�C��+� +�
��U�U� '��1�a���S�(7��F�
D�
D�
D���H�d�C��-� -� �
�'� !� !� �q�5�5�U�Q�Y�Y��!�a�%��(� �A� *�1�a��E�3��+:�A�v�+;�
=�
=�
=� !�,�)�!�R�#�X�q�!�=N�O�O�O���H�d�C��+� +�
��U�U� '��1�a���S�(7��F�
D�
D�
D���H�d�C��-� -�
�1�u�u�#�A�q�!�U�C��$3�Q�� @� @� @��S��$��S�)�)�
�Q�q�1�u�a�x�[� � �B� �Q�q�1�u�a�x�[� � �B� �Q�w�w�
�r�A�v�q�y�\��
�r�A�v�q�y�\���
��
�� �Q�w�w�
�r�A�v�q�y�\��
�r�A�v�q�y�\���
��
���[� � �J�$�$6�$6� ��7�7� �B��B�B��B��B�B� �|� #� #� ��7�7��B��B�B��B��B�B� �+� %� %� �$�)>�)>� ��7�7��B��B�B��B��B�B� �,� &� &� ��7�7��B��B�B��B��B�B�
��
�� #� 9� 9� 9��a� 9��1� 9�'�-� 9� ,�O� 9� "�z� 9�
$� � 9� �6�
9� "�z� 9� (�-� 9� .� -� 9� �b� 9� �R� 9� !�S� 9� %&�A� 9� $� � 9� $� � 9� *-�� 9� (�-� 9� "�z� 9� '@�&?� 9� ,�O�! 9�" �!�)�)�# 9�" 0A�/@�# 9�$ ,�O�% 9�& #8�"7�' 9� �T�3��T�,
�!�a�%��(� �A��O����!� 3� 3� !�� $�Q� '� O� -�a� 0�1� 4��<M�8N�8N� N�M�!� �',�!�!�$�$�'+�!�!�$� �m�A� .� /�� #� 9� 9� 9��a� 9��1� 9�'�-� 9� ,�O� 9� "�z� 9�
$� � 9� �6�
9� "�z� 9� (�-� 9� .� -� 9� �b� 9� �#�X�X� 9� $'�3� 9� +,�!� 9� $� � 9� $� � 9� *-�� 9� (�-� 9� "�z� 9� '@�&?� 9� ,�O�! 9�" �!�)�)�# 9�" 0A�/@�# 9�$ ,�O�% 9�& #8�"7�' 9� �T�3��T�, �4��q�!�!�H�����d�D�$�/�0�0�0�����Q��3�'�(�(�(��"� �O�C��F�F� #� #���!�S�!�!� -�� ,� -� -�
-����!� � � � ����!� � � ��T�k�Q�
��s��A�x� 8�8r2 c �& � t j | d�� � } t j |d�� � }t | � � t j k rt d� � �t |� � t j k rt d� � �| j }|j }t
|� � dk rt d� � �t
|� � dk rt d� � �|d |d k rt d � � �|d }i }i }t d|� � D ]|}| | |v rA|| |vr d
S || | || k s||| | | k r d
S �M|| |v r d
S || || | < | | ||| < �}d S ) a3
Determine if two different cluster assignments are equivalent.
Parameters
----------
T1 : array_like
An assignment of singleton cluster ids to flat cluster ids.
T2 : array_like
An assignment of singleton cluster ids to flat cluster ids.
Returns
-------
b : bool
Whether the flat cluster assignments `T1` and `T2` are
equivalent.
See Also
--------
linkage : for a description of what a linkage matrix is.
fcluster : for the creation of flat cluster assignments.
Examples
--------
>>> from scipy.cluster.hierarchy import fcluster, is_isomorphic
>>> from scipy.cluster.hierarchy import single, complete
>>> from scipy.spatial.distance import pdist
Two flat cluster assignments can be isomorphic if they represent the same
cluster assignment, with different labels.
For example, we can use the `scipy.cluster.hierarchy.single`: method
and flatten the output to four clusters:
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> Z = single(pdist(X))
>>> T = fcluster(Z, 1, criterion='distance')
>>> T
array([3, 3, 3, 4, 4, 4, 2, 2, 2, 1, 1, 1], dtype=int32)
We can then do the same using the
`scipy.cluster.hierarchy.complete`: method:
>>> Z = complete(pdist(X))
>>> T_ = fcluster(Z, 1.5, criterion='distance')
>>> T_
array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4], dtype=int32)
As we can see, in both cases we obtain four clusters and all the data
points are distributed in the same way - the only thing that changes
are the flat cluster labels (3 => 1, 4 =>2, 2 =>3 and 4 =>1), so both
cluster assignments are isomorphic:
>>> is_isomorphic(T, T_)
True
rc rd zT1 must be a numpy array.zT2 must be a numpy array.r zT1 must be one-dimensional.zT2 must be one-dimensional.r z0T1 and T2 must have the same number of elements.FT) r? ro r� r r� rt r� rP r� )�T1�T2�T1S�T2Sr� �d1�d2r� s r3 r r o s� � �z
��B�c� "� "� "�B� ��B�c� "� "� "�B� �B�x�x�2�:� � ��3�4�4�4� �B�x�x�2�:� � ��3�4�4�4�
�(�C�
�(�C�
�3�x�x�1�}�}��6�7�7�7�
�3�x�x�1�}�}��6�7�7�7�
�1�v��Q�����K�L�L�L� �A��A� �B� �B�
�1�a�[�[�
�
��
�a�5�B�;�;��a�5�B�;�;� �u�u��"�Q�%�y�B�q�E�!�!�R��1��Y�"�Q�%�%7�%7� �u�u� &8�
��U�b�[�[��5�5��1��B�r�!�u�I��1��B�r�!�u�I�I� �4r2 c �& � t j | dt j �� � } t | dd�� � | j d dz }t j |dz
f� � }t
| g� � \ } t j | |t |� � � � |S )a�
Return 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.
See Also
--------
linkage : for a description of what a linkage matrix is.
is_monotonic : for testing for monotonicity of a linkage matrix.
Examples
--------
>>> from scipy.cluster.hierarchy import median, maxdists
>>> from scipy.spatial.distance import pdist
Given a linkage matrix ``Z``, `scipy.cluster.hierarchy.maxdists`
computes for each new cluster generated (i.e., for each row of the linkage
matrix) what is the maximum distance between any two child clusters.
Due to the nature of hierarchical clustering, in many cases this is going
to be just the distance between the two child clusters that were merged
to form the current one - that is, Z[:,2].
However, for non-monotonic cluster assignments such as
`scipy.cluster.hierarchy.median` clustering this is not always the
case: There may be cluster formations were the distance between the two
clusters merged is smaller than the distance between their children.
We can see this in an example:
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> Z = median(pdist(X))
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 2. , 12. , 1.11803399, 3. ],
[ 5. , 13. , 1.11803399, 3. ],
[ 8. , 15. , 1.11803399, 3. ],
[11. , 14. , 1.11803399, 3. ],
[18. , 19. , 3. , 6. ],
[16. , 17. , 3.5 , 6. ],
[20. , 21. , 3.25 , 12. ]])
>>> maxdists(Z)
array([1. , 1. , 1. , 1. , 1.11803399,
1.11803399, 1.11803399, 1.11803399, 3. , 3.5 ,
3.5 ])
Note that while the distance between the two clusters merged when creating the
last cluster is 3.25, there are two children (clusters 16 and 17) whose distance
is larger (3.5). Thus, `scipy.cluster.hierarchy.maxdists` returns 3.5 in
this case.
rc r Tr� rf r r )
r? ro rC r rt r� rL r � get_max_dist_for_each_clusterrz )r� r� �MDs r3 r% r% � s� � �R �
�1�C�r�y�1�1�1�A��Q�d��-�-�-�-� ���
�Q��A� ��1�q�5�(� � �B�
&��s�
+�
+�C�Q��,�Q��C��F�F�;�;�;�
�Ir2 c � � t j | d�� � } t j |d�� � }t | dd�� � t |dd�� � | j d dz }| j d |j d k rt d � � �t j |dz
f� � }t | |g� � \ } }t j | ||t |� � d
� � |S ) a�
Return the maximum inconsistency coefficient for each
non-singleton cluster and its children.
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.
See Also
--------
linkage : for a description of what a linkage matrix is.
inconsistent : for the creation of a inconsistency matrix.
Examples
--------
>>> from scipy.cluster.hierarchy import median, inconsistent, maxinconsts
>>> from scipy.spatial.distance import pdist
Given a data set ``X``, we can apply a clustering method to obtain a
linkage matrix ``Z``. `scipy.cluster.hierarchy.inconsistent` can
be also used to obtain the inconsistency matrix ``R`` associated to
this clustering process:
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> Z = median(pdist(X))
>>> R = inconsistent(Z)
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 2. , 12. , 1.11803399, 3. ],
[ 5. , 13. , 1.11803399, 3. ],
[ 8. , 15. , 1.11803399, 3. ],
[11. , 14. , 1.11803399, 3. ],
[18. , 19. , 3. , 6. ],
[16. , 17. , 3.5 , 6. ],
[20. , 21. , 3.25 , 12. ]])
>>> R
array([[1. , 0. , 1. , 0. ],
[1. , 0. , 1. , 0. ],
[1. , 0. , 1. , 0. ],
[1. , 0. , 1. , 0. ],
[1.05901699, 0.08346263, 2. , 0.70710678],
[1.05901699, 0.08346263, 2. , 0.70710678],
[1.05901699, 0.08346263, 2. , 0.70710678],
[1.05901699, 0.08346263, 2. , 0.70710678],
[1.74535599, 1.08655358, 3. , 1.15470054],
[1.91202266, 1.37522872, 3. , 1.15470054],
[3.25 , 0.25 , 3. , 0. ]])
Here, `scipy.cluster.hierarchy.maxinconsts` can be used to compute
the maximum value of the inconsistency statistic (the last column of
``R``) for each non-singleton cluster and its children:
>>> maxinconsts(Z, R)
array([0. , 0. , 0. , 0. , 0.70710678,
0.70710678, 0.70710678, 0.70710678, 1.15470054, 1.15470054,
1.15470054])
rc rd Tr� rf r� r r �QThe inconsistency matrix and linkage matrix each have a different number of rows.r ) r? ro r r rt rP r� rL r � get_max_Rfield_for_each_clusterrz )r� r� r� �MIs r3 r& r& ! s� � �V �
�1�C� � � �A�
�
�1�C� � � �A��Q�d��-�-�-�-����C�(�(�(�(� ���
�Q��A��w�q�z�Q�W�Q�Z� � �� <� =� =� =� ��1�q�5�(� � �B�
)�1�a�&�
1�
1�F�Q���.�q�!�R��Q����C�C�C�
�Ir2 c �> � t j | d�� � } t j |d�� � }t | dd�� � t |dd�� � t |� � t
urt
d� � �|dk s|d k rt d
� � �| j d |j d k rt d � � �| j d d z }t j |d z
f� � }t | |g� � \ } }t j | ||t |� � |� � |S )
a;
Return the maximum statistic for each non-singleton cluster and its
children.
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``.
See Also
--------
linkage : for a description of what a linkage matrix is.
inconsistent : for the creation of a inconsistency matrix.
Examples
--------
>>> from scipy.cluster.hierarchy import median, inconsistent, maxRstat
>>> from scipy.spatial.distance import pdist
Given a data set ``X``, we can apply a clustering method to obtain a
linkage matrix ``Z``. `scipy.cluster.hierarchy.inconsistent` can
be also used to obtain the inconsistency matrix ``R`` associated to
this clustering process:
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> Z = median(pdist(X))
>>> R = inconsistent(Z)
>>> R
array([[1. , 0. , 1. , 0. ],
[1. , 0. , 1. , 0. ],
[1. , 0. , 1. , 0. ],
[1. , 0. , 1. , 0. ],
[1.05901699, 0.08346263, 2. , 0.70710678],
[1.05901699, 0.08346263, 2. , 0.70710678],
[1.05901699, 0.08346263, 2. , 0.70710678],
[1.05901699, 0.08346263, 2. , 0.70710678],
[1.74535599, 1.08655358, 3. , 1.15470054],
[1.91202266, 1.37522872, 3. , 1.15470054],
[3.25 , 0.25 , 3. , 0. ]])
`scipy.cluster.hierarchy.maxRstat` can be used to compute
the maximum value of each column of ``R``, for each non-singleton
cluster and its children:
>>> maxRstat(Z, R, 0)
array([1. , 1. , 1. , 1. , 1.05901699,
1.05901699, 1.05901699, 1.05901699, 1.74535599, 1.91202266,
3.25 ])
>>> maxRstat(Z, R, 1)
array([0. , 0. , 0. , 0. , 0.08346263,
0.08346263, 0.08346263, 0.08346263, 1.08655358, 1.37522872,
1.37522872])
>>> maxRstat(Z, R, 3)
array([0. , 0. , 0. , 0. , 0.70710678,
0.70710678, 0.70710678, 0.70710678, 1.15470054, 1.15470054,
1.15470054])
rc rd Tr� rf r� z&The third argument must be an integer.r r z/i must be an integer between 0 and 3 inclusive.r� r )
r? ro r r r� rz r� rP rt r� rL r r� )r� r� r� r� �MRs r3 r$ r$ { s$ � �Z �
�1�C� � � �A�
�
�1�C� � � �A��Q�d��-�-�-�-����C�(�(�(�(� �A�w�w�c����@�A�A�A��1�u�u��A����J�K�K�K��w�q�z�Q�W�Q�Z� � �� <� =� =� =�
���
�Q��A� ��1�q�5�(� � �B�
)�1�a�&�
1�
1�F�Q���.�q�!�R��Q����C�C�C�
�Ir2 c
�� � t j | d�� � } t j |d�� � }t |� � t j k s |j dk rt d� � �t
| dd�� � t |� � | j d d z k rt d
� � �t j
|� � }t |� � }t j |fd� � � }t j |fd� � � }| j d d z }t | |g� � \ } }t j | |||t |� � t |� � � � }|dk rt d |z � � �||fS )
a^
Return 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 descendants 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 descendant leaf nodes
with cluster node :math:`i`)
* there does not exist a leaf that is not a descendant 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.
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.
For example: if ``L[3]=2`` and ``M[3]=8``, the flat cluster with
id 8's leader is linkage node 2.
See Also
--------
fcluster : for the creation of flat cluster assignments.
Examples
--------
>>> from scipy.cluster.hierarchy import ward, fcluster, leaders
>>> from scipy.spatial.distance import pdist
Given a linkage matrix ``Z`` - obtained after apply a clustering method
to a dataset ``X`` - and a flat cluster assignment array ``T``:
>>> X = [[0, 0], [0, 1], [1, 0],
... [0, 4], [0, 3], [1, 4],
... [4, 0], [3, 0], [4, 1],
... [4, 4], [3, 4], [4, 3]]
>>> Z = ward(pdist(X))
>>> Z
array([[ 0. , 1. , 1. , 2. ],
[ 3. , 4. , 1. , 2. ],
[ 6. , 7. , 1. , 2. ],
[ 9. , 10. , 1. , 2. ],
[ 2. , 12. , 1.29099445, 3. ],
[ 5. , 13. , 1.29099445, 3. ],
[ 8. , 14. , 1.29099445, 3. ],
[11. , 15. , 1.29099445, 3. ],
[16. , 17. , 5.77350269, 6. ],
[18. , 19. , 5.77350269, 6. ],
[20. , 21. , 8.16496581, 12. ]])
>>> T = fcluster(Z, 3, criterion='distance')
>>> T
array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4], dtype=int32)
`scipy.cluster.hierarchy.leaders` returns the indices of the nodes
in the dendrogram that are the leaders of each flat cluster:
>>> L, M = leaders(Z, T)
>>> L
array([16, 17, 18, 19], dtype=int32)
(remember that indices 0-11 point to the 12 data points in ``X``,
whereas indices 12-22 point to the 11 rows of ``Z``)
`scipy.cluster.hierarchy.leaders` also returns the indices of
the flat clusters in ``T``:
>>> M
array([1, 2, 3, 4], dtype=int32)
rc rd r� z4T must be a one-dimensional numpy array of integers.Tr� rf r r z!Mismatch: len(T)!=Z.shape[0] + 1.r; zXT is not a valid assignment vector. Error found when examining linkage node %d (< 2n-1).)r? ro r� r r< r� r r� rt rP �uniquer� rL r r! rz )r� rJ �Cl�kkr: �Mr� r8 s r3 r! r! � s\ � �L �
�1�C� � � �A�
�
�1�C� � � �A� �A�w�w�"�*� � ���3����N�O�O�O��Q�d��-�-�-�-�
�1�v�v�����a� � � ��<�=�=�=� ��1� � �B� �R���B�
��"��c�"�"�"�A�
��"��c�"�"�"�A� ���
�Q��A�
)�1�a�&�
1�
1�F�Q����1�a��A�s�2�w�w��A���7�7�A��A�v�v�� E�HI�J� K� K� K�
�q�6�Mr2 )r
rU F)NN)F)rU r� )r )FFN)r r NN)r rU r r
N)NNNNrH )r1 NNTrJ NFFTFFNNNFNNrH )Tr� r6 r� re r �numpyr? r r r �scipy.spatial.distance�spatialrq �scipy._lib._disjoint_setr rl rs �__all__� UserWarningr- r9 rE rL rS r
r r r r r r r# r � _cnode_barer� � _cnode_typer� r r+ r( r� rn r r r r* r r r r r r r' r r r r" r� r@ rF rd �keysr? �sortrE r= rC rG r� r� r� r) r r� r� r� r� r� r� r r% r& r$ r! r1 r2 r3 �<module>r s ��[� [�B ����
�
�
�
� � � � � � � � � � � 0� 0� 0� 0� 0� 0� 0� 0� )� )� )� )� )� )� )� )� )� 0� 0� 0� 0� 0� 0� �Q�1�!� ���;� ;� �3� � � � �� � � � � �[� � � �I� I� I� � � �
�
�
�
�
�
�,K;� K;� K;�\O=� O=� O=�dO<� O<� O<�dR=� R=� R=�jc=� c=� c=�Lc;� c;� c;�L`9� `9� `9�Ft� t� t� t�nF� F� F� F� F� F� F� F�R �k�!�n�n� ��d�;� � � �� � �8P� P� P� P�fa� a� a� a�H=>� =>� =>� =>�@
�
�
�
�
�
�D� D� D� D�NG
� G
� G
� G
�T[4� [4� [4�|T� T� T�nR)� R)� R)�jz� z� z� z�zz� z� z� z�z� � �� � �3� 3� 3�# � # � # �L57� 57� 57�px
� x
� x
� x
�v "0�AE�`
� `
� `
� `
�F6� 6� 6�@ �2�r�2�r�1�b�!�R�V�Q�7� ��!�R��R�V�R�
(�
��4� �(�(�*�*�+�+� � � � � � � ��t�J�O�O� -� -�.�.� � � � � � � � � � � "� "� "� !� !� !� <@�;?�48�C/� C/� C/� C/�N S� ��D�2�3�3� �D � D � D �N =A�:>�GK�>B�37�?C�%)�
o
� o
� o
� o
�d � � �"(� (� (�4 � � �$Q� Q� Q�
U� U� U� 02�v�$�+0��*/�u�05���#%����#'�U�-/�B�9;�/3�1�15�/3�59�b9� b9� b9� b9�J\� \� \�~P� P� P�fW� W� W�t^� ^� ^�Bx� x� x� x� xr2