Grundstück das dendrogramm mit sklearn.AgglomerativeClustering

Ich versuche zu bauen, das dendrogramm mit der children_ - Attribut zur Verfügung gestellt von AgglomerativeClustering, aber bisher bin ich aus Glück. Ich kann nicht mit scipy.cluster seit agglomerative clustering in scipy fehlen einige Optionen, die mir wichtig sind (wie die option zum angeben der Anzahl von Clustern). Ich wäre wirklich dankbar für irgendwelche Ratschläge gibt. 

    import sklearn.cluster
    clstr = cluster.AgglomerativeClustering(n_clusters=2)
    clusterer.children_
  • Poste bitte ein code-Beispiel, um zu vergrößern die Chancen auf gute Antworten
  • Ist deine Frage damit beantwortet? link
InformationsquelleAutor Shukhrat Khannanov | 2015-03-18
  1. 13

    Hier ist ein einfache Funktion für die Aufnahme eines hierarchischen clustering Modell aus sklearn und Plotten Sie mit Hilfe der scipy dendrogram Funktion. Scheint, wie die Grafik-Funktionen werden oft nicht direkt unterstützt sklearn. Sie finden hier eine interessante Diskussion, die im Zusammenhang mit der pull-request für diese plot_dendrogram code-snippet hier.

    Ich würde klären, dass die Verwendung Fall, dass Sie beschreiben (definieren der Anzahl von Clustern) ist in scipy: nachdem Sie ausgeführt haben, die hierarchischen clustering mit scipy ist linkage Sie können schneiden Sie die Hierarchie an beliebige Anzahl von Clustern, die Sie wollen mit fcluster mit der Anzahl der Cluster angegeben, in der t argument und criterion='maxclust' argument.

    InformationsquelleAutor David Diaz
  2. 11

    Verwenden Sie die scipy Umsetzung der agglomerative clustering statt. Hier ist ein Beispiel. 

    from scipy.cluster.hierarchy import dendrogram, linkage

data = [[0., 0.], [0.1, -0.1], [1., 1.], [1.1, 1.1]]

Z = linkage(data)

dendrogram(Z)

    Finden Sie Dokumentation für linkage hier und Dokumentation für dendrogram hier.

    • Diese Antwort ist hilfreich, weil er aufzeigt, eine alternative Art der Erstellung und Visualisierung einer hierarchischen clustering über scipy, so dass ich es von Ihnen positiv bewertet werden. Jedoch ist dies nicht die Antwort auf die ursprüngliche Frage, die dabei war, wie zu visualisieren, die das dendrogramm der Clusterung erstellt von scikit-learn. Es wäre schön, wenn Sie Hinzugefügt, eine Funktion, die nahm scikit-learn-Ausgabe und erstellt eine Datenstruktur, wie Z.
    InformationsquelleAutor sebastianspiegel
  3. 3

    Stieß ich auf genau das gleiche problem vor einiger Zeit. Die Art und Weise habe ich es geschafft, um den Verlauf der verdammt dendogram wurde mit dem software-Paket ete3. Dieses Paket ist in der Lage, flexibel plot Bäume mit verschiedenen Optionen. Die einzige Schwierigkeit war, zu konvertieren sklearn's children_ Ausgabe der Newick-Baum-format, die gelesen und verstanden werden können, indem ete3. Außerdem muss ich mich manuell berechnen die Dendriten der span, da diese Informationen nicht zur Verfügung gestellt wurde mit der children_. Hier ist ein Ausschnitt von dem code, den ich verwendet. Er berechnet das Newick-Baum und zeigt dann die ete3 Tree-datastructure. Für weitere details zum Grundstück, werfen Sie einen Blick hier

    import numpy as np
from sklearn.cluster import AgglomerativeClustering
import ete3

def build_Newick_tree(children,n_leaves,X,leaf_labels,spanner):
    """
    build_Newick_tree(children,n_leaves,X,leaf_labels,spanner)

    Get a string representation (Newick tree) from the sklearn
    AgglomerativeClustering.fit output.

    Input:
        children: AgglomerativeClustering.children_
        n_leaves: AgglomerativeClustering.n_leaves_
        X: parameters supplied to AgglomerativeClustering.fit
        leaf_labels: The label of each parameter array in X
        spanner: Callable that computes the dendrite's span

    Output:
        ntree: A str with the Newick tree representation

    """
    return go_down_tree(children,n_leaves,X,leaf_labels,len(children)+n_leaves-1,spanner)[0]+';'

def go_down_tree(children,n_leaves,X,leaf_labels,nodename,spanner):
    """
    go_down_tree(children,n_leaves,X,leaf_labels,nodename,spanner)

    Iterative function that traverses the subtree that descends from
    nodename and returns the Newick representation of the subtree.

    Input:
        children: AgglomerativeClustering.children_
        n_leaves: AgglomerativeClustering.n_leaves_
        X: parameters supplied to AgglomerativeClustering.fit
        leaf_labels: The label of each parameter array in X
        nodename: An int that is the intermediate node name whos
            children are located in children[nodename-n_leaves].
        spanner: Callable that computes the dendrite's span

    Output:
        ntree: A str with the Newick tree representation

    """
    nodeindex = nodename-n_leaves
    if nodename<n_leaves:
        return leaf_labels[nodeindex],np.array([X[nodeindex]])
    else:
        node_children = children[nodeindex]
        branch0,branch0samples = go_down_tree(children,n_leaves,X,leaf_labels,node_children[0])
        branch1,branch1samples = go_down_tree(children,n_leaves,X,leaf_labels,node_children[1])
        node = np.vstack((branch0samples,branch1samples))
        branch0span = spanner(branch0samples)
        branch1span = spanner(branch1samples)
        nodespan = spanner(node)
        branch0distance = nodespan-branch0span
        branch1distance = nodespan-branch1span
        nodename = '({branch0}:{branch0distance},{branch1}:{branch1distance})'.format(branch0=branch0,branch0distance=branch0distance,branch1=branch1,branch1distance=branch1distance)
        return nodename,node

def get_cluster_spanner(aggClusterer):
    """
    spanner = get_cluster_spanner(aggClusterer)

    Input:
        aggClusterer: sklearn.cluster.AgglomerativeClustering instance

    Get a callable that computes a given cluster's span. To compute
    a cluster's span, call spanner(cluster)

    The cluster must be a 2D numpy array, where the axis=0 holds
    separate cluster members and the axis=1 holds the different
    variables.

    """
    if aggClusterer.linkage=='ward':
        if aggClusterer.affinity=='euclidean':
            spanner = lambda x:np.sum((x-aggClusterer.pooling_func(x,axis=0))**2)
    elif aggClusterer.linkage=='complete':
        if aggClusterer.affinity=='euclidean':
            spanner = lambda x:np.max(np.sum((x[:,None,:]-x[None,:,:])**2,axis=2))
        elif aggClusterer.affinity=='l1' or aggClusterer.affinity=='manhattan':
            spanner = lambda x:np.max(np.sum(np.abs(x[:,None,:]-x[None,:,:]),axis=2))
        elif aggClusterer.affinity=='l2':
            spanner = lambda x:np.max(np.sqrt(np.sum((x[:,None,:]-x[None,:,:])**2,axis=2)))
        elif aggClusterer.affinity=='cosine':
            spanner = lambda x:np.max(np.sum((x[:,None,:]*x[None,:,:]))/(np.sqrt(np.sum(x[:,None,:]*x[:,None,:],axis=2,keepdims=True))*np.sqrt(np.sum(x[None,:,:]*x[None,:,:],axis=2,keepdims=True))))
        else:
            raise AttributeError('Unknown affinity attribute value {0}.'.format(aggClusterer.affinity))
    elif aggClusterer.linkage=='average':
        if aggClusterer.affinity=='euclidean':
            spanner = lambda x:np.mean(np.sum((x[:,None,:]-x[None,:,:])**2,axis=2))
        elif aggClusterer.affinity=='l1' or aggClusterer.affinity=='manhattan':
            spanner = lambda x:np.mean(np.sum(np.abs(x[:,None,:]-x[None,:,:]),axis=2))
        elif aggClusterer.affinity=='l2':
            spanner = lambda x:np.mean(np.sqrt(np.sum((x[:,None,:]-x[None,:,:])**2,axis=2)))
        elif aggClusterer.affinity=='cosine':
            spanner = lambda x:np.mean(np.sum((x[:,None,:]*x[None,:,:]))/(np.sqrt(np.sum(x[:,None,:]*x[:,None,:],axis=2,keepdims=True))*np.sqrt(np.sum(x[None,:,:]*x[None,:,:],axis=2,keepdims=True))))
        else:
            raise AttributeError('Unknown affinity attribute value {0}.'.format(aggClusterer.affinity))
    else:
        raise AttributeError('Unknown linkage attribute value {0}.'.format(aggClusterer.linkage))
    return spanner

clusterer = AgglomerativeClustering(n_clusters=2,compute_full_tree=True) # You can set compute_full_tree to 'auto', but I left it this way to get the entire tree plotted
clusterer.fit(X) # X for whatever you want to fit
spanner = get_cluster_spanner(clusterer)
newick_tree = build_Newick_tree(clusterer.children_,clusterer.n_leaves_,X,leaf_labels,spanner) # leaf_labels is a list of labels for each entry in X
tree = ete3.Tree(newick_tree)
tree.show()
    InformationsquelleAutor lucianopaz
  4. 0

    Für jene, die bereit sind, einen Schritt aus Python und verwenden das robuste D3-Bibliothek, es ist nicht super schwierig zu benutzen, die d3.cluster() (oder, denke ich, d3.tree()) APIs zum erreichen einer schönen, anpassbare Ergebnis.

    Sehen die jsfiddle für eine demo.

    Den children_ array zum Glück Funktionen einfach als JS-array, und das nur Zwischenschritt ist die Verwendung d3.stratify() zu drehen, Sie in eine hierarchische Darstellung. Konkret brauchen wir jeden Knoten, um eine id und ein parentId:

    var N = 272;  //Your n_samples/corpus size.
var root = d3.stratify()
  .id((d,i) => i + N)
  .parentId((d, i) => {
    var parIndex = data.findIndex(e => e.includes(i + N));
    if (parIndex < 0) {
      return; //The root should have an undefined parentId.
    }
    return parIndex + N;
  })(data); //Your children_

    Dass Sie am Ende mit mindestens O(n^2) Verhalten hier aufgrund der findIndex Linie, aber es wahrscheinlich egal, bis Ihre n_samples wird riesig, in diesem Fall, könnte man vorausberechnen ein effizienter index.

    Darüber hinaus, es ist ziemlich viel plug-and-chug Einsatz von d3.cluster(). Sehen mbostock ist canonical block oder mein JSFiddle.

    N. B. Für meinen Anwendungsfall reicht es lediglich zu zeigen, nicht-Blatt-Knoten; es ist ein bisschen schwieriger zu visualisieren Muster/Blätter, da diese möglicherweise nicht alle werden in der children_ array explizit.

    InformationsquelleAutor jagthebeetle
Schreibe einen Kommentar