Matplotlib: Vermeiden Sie überlappende Datenpunkte in einem "Streu / Punkt / Bienenwarm" -Plot

Beim zeichnen eines dot-plot mit matplotlib, ich möchte offset-überlappender Datenpunkte zu halten Sie alle sichtbar. Für Beispiele, wenn ich 

CategoryA: 0,0,3,0,5  
CategoryB: 5,10,5,5,10

Ich wollen, dass jeder die CategoryA "0" Datenpunkte festgelegt werden, Seite an Seite, anstatt direkt auf der jeweils anderen, während immer noch deutlich vom CategoryB.

In R (ggplot2) es ist ein "jitter" option, die dies tut. Gibt es eine ähnliche option in matplotlib, oder gibt es einen anderen Ansatz, der dazu führen würde, zu einem ähnlichen Ergebnis?

Edit: zu klären, die "beeswarm" plot in R ist im wesentlichen, was ich im Auge habe, und pybeeswarm ist ein Anfang, aber nützlich beginnen bei einem matplotlib/Python-version.

Edit: hinzufügen, die Seaborn ' s Swarmplot, eingeführt in version 0.7, ist eine hervorragende Umsetzung von dem, was ich wollte.

Kommentar zu dem Problem - Öffnen
In einem dot-plot diese Punkte sind bereits getrennt in Ihre Spalte Kommentarautor: joaquin
Die wiki-definition von "dot plot" ist nicht das, was ich versuche zu beschreiben, aber ich habe noch nie gehört, ein Begriff, der andere als "dot-plot". Es ist etwa ein scatter-plot, sondern mit beliebigen (nicht zwingend numerisch) x Etiketten. Also in dem Beispiel beschreibe ich in der Frage, es würde eine Spalte mit Werten für "CategoryA", eine zweite Spalte für "CategoryB", etc. (Edit: Die wikipedia-definition von "Cleveland dot plot" ist mehr ähnlich wie was ich Suche, aber nicht genau das gleiche.) Kommentarautor: iayork

InformationsquelleAutor der Frage iayork | 2011-12-29

  1. 30

    Erweiterung der Antwort von @user2467675, hier ist, wie ich es gemacht habe:

    def rand_jitter(arr):
    stdev = .01*(max(arr)-min(arr))
    return arr + np.random.randn(len(arr)) * stdev

def jitter(x, y, s=20, c='b', marker='o', cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, verts=None, hold=None, **kwargs):
    return scatter(rand_jitter(x), rand_jitter(y), s=s, c=c, marker=marker, cmap=cmap, norm=norm, vmin=vmin, vmax=vmax, alpha=alpha, linewidths=linewidths, verts=verts, hold=hold, **kwargs)

    Den stdev variable stellt sicher, dass der jitter ist genug, um zu sehen, die auf verschiedenen Skalen, aber es wird davon ausgegangen, dass die Grenzwerte der Achsen 0 und der max-Wert.

    Können Sie dann rufen jitter statt scatter.

    InformationsquelleAutor der Antwort yoavram

  2. 7

    Ich verwendet numpy.zufällig "scatter/beeswarm" die Daten entlang der X-Achse, sondern um einen festen Punkt in jeder Kategorie, und dann im Grunde tun pyplot.scatter() für jede Kategorie:

    import matplotlib.pyplot as plt
import numpy as np

#random data for category A, B, with B "taller"
yA, yB = np.random.randn(100), 5.0+np.random.randn(1000)

xA, xB = np.random.normal(1, 0.1, len(yA)), 
         np.random.normal(3, 0.1, len(yB))

plt.scatter(xA, yA)
plt.scatter(xB, yB)
plt.show()

    Matplotlib: Vermeiden Sie überlappende Datenpunkte in einem

    InformationsquelleAutor der Antwort sun.huaiyu

  3. 6

    Nicht zu wissen, der eine direkte mpl alternative hier aus haben Sie einen sehr rudimentären Vorschlag:

    from matplotlib import pyplot as plt
from itertools import groupby

CA = [0,4,0,3,0,5]  
CB = [0,0,4,4,2,2,2,2,3,0,5]  

x = []
y = []
for indx, klass in enumerate([CA, CB]):
    klass = groupby(sorted(klass))
    for item, objt in klass:
        objt = list(objt)
        points = len(objt)
        pos = 1 + indx + (1 - points) / 50.
        for item in objt:
            x.append(pos)
            y.append(item)
            pos += 0.04

plt.plot(x, y, 'o')
plt.xlim((0,3))

plt.show()

    Matplotlib: Vermeiden Sie überlappende Datenpunkte in einem

    InformationsquelleAutor der Antwort joaquin

  4. 5

    Ein Weg der Annäherung an das problem zu denken, jede 'Zeile' in der scatter/dot/beeswarm plot " als ein bin in einem Histogramm:

    data = np.random.randn(100)

width = 0.8     # the maximum width of each 'row' in the scatter plot
xpos = 0        # the centre position of the scatter plot in x

counts, edges = np.histogram(data, bins=20)

centres = (edges[:-1] + edges[1:]) / 2.
yvals = centres.repeat(counts)

max_offset = width / counts.max()
offsets = np.hstack((np.arange(cc) - 0.5 * (cc - 1)) for cc in counts)
xvals = xpos + (offsets * max_offset)

fig, ax = plt.subplots(1, 1)
ax.scatter(xvals, yvals, s=30, c='b')

    Dieser offensichtlich beinhaltet die Gruppierung der Daten, so verlieren Sie möglicherweise einige Präzision. Wenn Sie diskrete Daten, die Sie ersetzen könnte:

    counts, edges = np.histogram(data, bins=20)
centres = (edges[:-1] + edges[1:]) / 2.

    mit:

    centres, counts = np.unique(data, return_counts=True)

    Einen alternativen Ansatz, der erhält die genaue y-Koordinaten, auch für kontinuierliche Daten, ist die Verwendung eines kernel-Dichte-Schätzung zum skalieren der amplitude der random-jitter in der x-Achse:

    from scipy.stats import gaussian_kde

kde = gaussian_kde(data)
density = kde(data)     # estimate the local density at each datapoint

# generate some random jitter between 0 and 1
jitter = np.random.rand(*data.shape) - 0.5 

# scale the jitter by the KDE estimate and add it to the centre x-coordinate
xvals = 1 + (density * jitter * width * 2)

ax.scatter(xvals, data, s=30, c='g')
for sp in ['top', 'bottom', 'right']:
    ax.spines[sp].set_visible(False)
ax.tick_params(top=False, bottom=False, right=False)

ax.set_xticks([0, 1])
ax.set_xticklabels(['Histogram', 'KDE'], fontsize='x-large')
fig.tight_layout()

    Diese zweite Methode basiert lose auf, wie violin plots Arbeit. Dennoch ist es nicht garantiert, dass keiner der Punkte überschneiden, aber ich finde, dass in der Praxis neigt dazu, ganz nett aussehende Ergebnisse so lange, wie es eine anständige Anzahl der Punkte (>20), und die Verteilung kann einigermaßen gut angenähert durch eine Summe von gaussfunktionen.

    Matplotlib: Vermeiden Sie überlappende Datenpunkte in einem

    InformationsquelleAutor der Antwort ali_m

  5. 3

    Seaborn bietet eine Histogramm-wie beim kategorischen dot-plots durch sns.swarmplot() und jittered kategorische dot-plots über sns.stripplot():

    import seaborn as sns

sns.set(style='ticks', context='talk')
iris = sns.load_dataset('iris')

sns.swarmplot('species', 'sepal_length', data=iris)
sns.despine()

    Matplotlib: Vermeiden Sie überlappende Datenpunkte in einem 

    sns.stripplot('species', 'sepal_length', data=iris, jitter=0.2)
sns.despine()

    Matplotlib: Vermeiden Sie überlappende Datenpunkte in einem

    InformationsquelleAutor der Antwort Joel Ostblom

  6. 1

    Seaborn 's swarmplot scheint, wie die meisten apt-fit für das, was Sie im Sinn haben, aber Sie können auch jitter mit Seaborn' s regplot:

    import seaborn as sns
iris = sns.load_dataset('iris')

sns.regplot(x='sepal_length',
            y='sepal_width',
            data=iris,
            fit_reg=False,  # do not fit a regression line
            x_jitter=0.1,  # could also dynamically set this with range of data
            y_jitter=0.1,
            scatter_kws={'alpha': 0.5})  # set transparency to 50%

    InformationsquelleAutor der Antwort wordsforthewise

Schreibe einen Kommentar