Graphique des coordonnées parallèles dans Matplotlib

les données bidimensionnelles et tridimensionnelles peuvent être visualisées de façon relativement directe en utilisant les types de placettes traditionnels. Même avec quatre dimensions données, nous pouvons souvent trouver un moyen pour afficher les données. Les Dimensions au-dessus de quatre, cependant, deviennent de plus en plus difficiles à afficher. Heureusement, parallèle coordonnées parcelles fournir un mécanisme pour l'affichage des résultats avec les dimensions supérieures.

plusieurs les tracés fournissent des tracés de coordonnées parallèles, comme Matlab , R , VTK type 1 et VTK type 2 , mais je ne vois pas comment en créer un en utilisant Matplotlib.

1. y a-t-il un tracé intégré de coordonnées parallèles dans Matplotlib? Je ne vois certainement pas un dans la galerie .
2. s'il n'y a pas de type incorporé, est il est possible de construire un tracé de coordonnées parallèle en utilisant les caractéristiques standard de Matplotlib?

modifier :

basé sur la réponse fournie par Zhenya ci-dessous, j'ai développé la généralisation suivante qui supporte un nombre arbitraire d'axes. En suivant le style de l'exemple que j'ai posté dans la question originale ci-dessus, chaque axe obtient sa propre échelle. J'ai accompli ceci en normalisant les données à chaque point d'axe et rendre les axes ont une gamme de 0 à 1. Je reviens ensuite en arrière et applique des étiquettes à chaque marque de tique qui donnent la valeur correcte à cette interception.

la fonction fonctionne en acceptant un itérable d'ensembles de données. Chaque ensemble de données est considéré comme un ensemble de points où chaque point se situe sur un axe différent. L'exemple dans __main__ saisit des nombres aléatoires pour chaque axe en deux ensembles de 30 lignes. Les lignes sont aléatoires à l'intérieur des fourchettes qui causent le regroupement des lignes; un comportement que je voulais vérifier.

Cette solution n'est pas aussi bonne qu'une solution intégrée car vous avez un comportement de souris étrange et je simule les plages de données à travers les étiquettes, mais Jusqu'à ce que Matplotlib ajoute une solution intégrée, c'est acceptable.

#!/usr/bin/python
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker

def parallel_coordinates(data_sets, style=None):

    dims = len(data_sets[0])
    x    = range(dims)
    fig, axes = plt.subplots(1, dims-1, sharey=False)

    if style is None:
        style = ['r-']*len(data_sets)

    # Calculate the limits on the data
    min_max_range = list()
    for m in zip(*data_sets):
        mn = min(m)
        mx = max(m)
        if mn == mx:
            mn -= 0.5
            mx = mn + 1.
        r  = float(mx - mn)
        min_max_range.append((mn, mx, r))

    # Normalize the data sets
    norm_data_sets = list()
    for ds in data_sets:
        nds = [(value - min_max_range[dimension][0]) / 
                min_max_range[dimension][2] 
                for dimension,value in enumerate(ds)]
        norm_data_sets.append(nds)
    data_sets = norm_data_sets

    # Plot the datasets on all the subplots
    for i, ax in enumerate(axes):
        for dsi, d in enumerate(data_sets):
            ax.plot(x, d, style[dsi])
        ax.set_xlim([x[i], x[i+1]])

    # Set the x axis ticks 
    for dimension, (axx,xx) in enumerate(zip(axes, x[:-1])):
        axx.xaxis.set_major_locator(ticker.FixedLocator([xx]))
        ticks = len(axx.get_yticklabels())
        labels = list()
        step = min_max_range[dimension][2] / (ticks - 1)
        mn   = min_max_range[dimension][0]
        for i in xrange(ticks):
            v = mn + i*step
            labels.append('%4.2f' % v)
        axx.set_yticklabels(labels)


    # Move the final axis' ticks to the right-hand side
    axx = plt.twinx(axes[-1])
    dimension += 1
    axx.xaxis.set_major_locator(ticker.FixedLocator([x[-2], x[-1]]))
    ticks = len(axx.get_yticklabels())
    step = min_max_range[dimension][2] / (ticks - 1)
    mn   = min_max_range[dimension][0]
    labels = ['%4.2f' % (mn + i*step) for i in xrange(ticks)]
    axx.set_yticklabels(labels)

    # Stack the subplots 
    plt.subplots_adjust(wspace=0)

    return plt


if __name__ == '__main__':
    import random
    base  = [0,   0,  5,   5,  0]
    scale = [1.5, 2., 1.0, 2., 2.]
    data = [[base[x] + random.uniform(0., 1.)*scale[x]
            for x in xrange(5)] for y in xrange(30)]
    colors = ['r'] * 30

    base  = [3,   6,  0,   1,  3]
    scale = [1.5, 2., 2.5, 2., 2.]
    data.extend([[base[x] + random.uniform(0., 1.)*scale[x]
                 for x in xrange(5)] for y in xrange(30)])
    colors.extend(['b'] * 30)

    parallel_coordinates(data, style=colors).show()

Edit 2:

voici un exemple de ce qui ressort du code ci-dessus en traçant Fisher'S Iris data . Il n'est pas assez aussi agréable que L'image de référence de Wikipedia, mais il est acceptable si tout ce que vous avez Est Matplotlib et vous avez besoin de tracés multidimensionnels.