Comment tracer plusieurs Seaborn Jointplot dans l'intrigue secondaire

Je vais avoir des problèmes en plaçant Seaborn Jointplot à l'intérieur d'un multicolumn subplot.

import pandas as pd
import seaborn as sns

df = pd.DataFrame({'C1': {'a': 1,'b': 15,'c': 9,'d': 7,'e': 2,'f': 2,'g': 6,'h': 5,'k': 5,'l': 8},
          'C2': {'a': 6,'b': 18,'c': 13,'d': 8,'e': 6,'f': 6,'g': 8,'h': 9,'k': 13,'l': 15}})

fig = plt.figure();   
ax1 = fig.add_subplot(121);  
ax2 = fig.add_subplot(122);

sns.jointplot("C1", "C2", data=df, kind='reg', ax=ax1)
sns.jointplot("C1", "C2", data=df, kind='kde', ax=ax2)

Avis que seule une partie de la jointplot est placé à l'intérieur de l'intrigue secondaire et le reste de la gauche à l'intérieur d'une parcelle deux images. Ce que je veux est à la fois le distributions également inséré à l'intérieur de la subplots.

Quelqu'un peut-il aider?

haha, Michael, avec assez de piratage, il peut être possible 🙂

OriginalL'auteur Afloz | 2016-01-27

  1. 22

    Il ne peut pas être fait facilement sans le piratage. jointplot appels JointGrid méthode, qui à son tour crée une nouvelle figure objet à chaque fois qu'il est appelé.

    Donc, l'astuce est de faire deux jointplots (JG1 JG2), puis faites une nouvelle figure, puis migrer les axes des objets à partir de JG1 JG2 à la nouvelle figure créé.

    Enfin, nous pouvons nous ajuster les tailles et les positions des sous-intrigues dans la nouvelle figure que nous venons de créer. 

    JG1 = sns.jointplot("C1", "C2", data=df, kind='reg')
JG2 = sns.jointplot("C1", "C2", data=df, kind='kde')

#subplots migration
f = plt.figure()
for J in [JG1, JG2]:
    for A in J.fig.axes:
        f._axstack.add(f._make_key(A), A)

#subplots size adjustment
f.axes[0].set_position([0.05, 0.05, 0.4,  0.4])
f.axes[1].set_position([0.05, 0.45, 0.4,  0.05])
f.axes[2].set_position([0.45, 0.05, 0.05, 0.4])
f.axes[3].set_position([0.55, 0.05, 0.4,  0.4])
f.axes[4].set_position([0.55, 0.45, 0.4,  0.05])
f.axes[5].set_position([0.95, 0.05, 0.05, 0.4])

    C'est un hack parce que nous sommes maintenant à l'aide de _axstack et _add_key méthodes privées, qui pourrait et pourrait ne pas rester le même, car ils sont maintenant dans matplotlib les futures versions.

    Comment tracer plusieurs Seaborn Jointplot dans l'intrigue secondaire

    Il est difficile pour moi d'imaginer ce que cela va donner tout ce mal est une meilleure idée que tout simplement la mise en place de l'intrigue secondaire de la grille de dessin et de distplot, regplot, et kdeplot sur elle.
    Tout à fait d'accord. Mais la réutilisabilité sage, cela signifierait pour dupliquer beaucoup de codes déjà écrit dans joint_plot. Peut-être JointGird peut prendre un paramètre optionnel pour spécifier le traçage des axes/de l'axe. Comportement actuel signifie que si l'un approvisionnement ax=some_axis, seul le regplot intrigue va aller que some_axis.
    C'est juste le comportement qui résulte de quelqu'un à l'aide de la fonction d'une manière qui n'a jamais été prévu.
    Tout simplement incroyable, c'est la seule solution que j'ai pu trouver. Merci
    Comment voulez-vous dire, "à l'aide de la fonction d'une manière qui n'a jamais été destiné"? Pouvez-vous expliquer?

    OriginalL'auteur CT Zhu

  2. 20

    Déplacer les axes dans matplotlib n'est pas aussi facile qu'il l'habitude d'être dans les versions précédentes. Ci-dessous est de travailler avec la version actuelle de matplotlib.

    Comme cela a été souligné à plusieurs endroits (cette question, aussi ce problème) plusieurs seaborn commandes de créer leur propre figure automatiquement. C'est codé en dur dans le seaborn code, donc il n'y a actuellement aucun moyen de produire de telles parcelles existantes sur les chiffres. Ceux-ci sont PairGrid, FacetGrid, JointGrid, pairplot, jointplot et lmplot.

    Il y a un seaborn fourche disponible qui permettrait de fournir une intrigue secondaire grille pour les classes respectives telles que la parcelle est créé dans une figure. Pour l'utiliser, vous devez copier le axisgrid.py de la fourche à la seaborn dossier. Notez que ce n'est actuellement limités à être utilisé avec matplotlib 2.1 (éventuellement 2.0).

    Une alternative pourrait être de créer une seaborn figure et de copier les axes d'une autre figure. Le principe de ce qui est montré dans cette réponse et pourrait être étendu à Searborn parcelles. La mise en œuvre est un peu plus compliqué que je l'avais initialement prévu. Ce qui suit est une classe SeabornFig2Grid qui peut être appelée avec un seaborn grille d'instance (le retour de l'une des commandes ci-dessus), un matplotlib figure et un subplot_spec, qui est une position d'un gridspec de la grille. 

    import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import seaborn as sns
import numpy as np
class SeabornFig2Grid():
def __init__(self, seaborngrid, fig,  subplot_spec):
self.fig = fig
self.sg = seaborngrid
self.subplot = subplot_spec
if isinstance(self.sg, sns.axisgrid.FacetGrid) or \
isinstance(self.sg, sns.axisgrid.PairGrid):
self._movegrid()
elif isinstance(self.sg, sns.axisgrid.JointGrid):
self._movejointgrid()
self._finalize()
def _movegrid(self):
""" Move PairGrid or Facetgrid """
self._resize()
n = self.sg.axes.shape[0]
m = self.sg.axes.shape[1]
self.subgrid = gridspec.GridSpecFromSubplotSpec(n,m, subplot_spec=self.subplot)
for i in range(n):
for j in range(m):
self._moveaxes(self.sg.axes[i,j], self.subgrid[i,j])
def _movejointgrid(self):
""" Move Jointgrid """
h= self.sg.ax_joint.get_position().height
h2= self.sg.ax_marg_x.get_position().height
r = int(np.round(h/h2))
self._resize()
self.subgrid = gridspec.GridSpecFromSubplotSpec(r+1,r+1, subplot_spec=self.subplot)
self._moveaxes(self.sg.ax_joint, self.subgrid[1:, :-1])
self._moveaxes(self.sg.ax_marg_x, self.subgrid[0, :-1])
self._moveaxes(self.sg.ax_marg_y, self.subgrid[1:, -1])
def _moveaxes(self, ax, gs):
#https://stackoverflow.com/a/46906599/4124317
ax.remove()
ax.figure=self.fig
self.fig.axes.append(ax)
self.fig.add_axes(ax)
ax._subplotspec = gs
ax.set_position(gs.get_position(self.fig))
ax.set_subplotspec(gs)
def _finalize(self):
plt.close(self.sg.fig)
self.fig.canvas.mpl_connect("resize_event", self._resize)
self.fig.canvas.draw()
def _resize(self, evt=None):
self.sg.fig.set_size_inches(self.fig.get_size_inches())

    L'utilisation de cette classe devrait ressembler à ceci:

    import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import seaborn as sns; sns.set()
import SeabornFig2Grid as sfg
iris = sns.load_dataset("iris")
tips = sns.load_dataset("tips")
# An lmplot
g0 = sns.lmplot(x="total_bill", y="tip", hue="smoker", data=tips, 
palette=dict(Yes="g", No="m"))
# A PairGrid
g1 = sns.PairGrid(iris, hue="species")
g1.map(plt.scatter, s=5)
# A FacetGrid
g2 = sns.FacetGrid(tips, col="time",  hue="smoker")
g2.map(plt.scatter, "total_bill", "tip", edgecolor="w")
# A JointGrid
g3 = sns.jointplot("sepal_width", "petal_length", data=iris,
kind="kde", space=0, color="g")
fig = plt.figure(figsize=(13,8))
gs = gridspec.GridSpec(2, 2)
mg0 = sfg.SeabornFig2Grid(g0, fig, gs[0])
mg1 = sfg.SeabornFig2Grid(g1, fig, gs[1])
mg2 = sfg.SeabornFig2Grid(g2, fig, gs[3])
mg3 = sfg.SeabornFig2Grid(g3, fig, gs[2])
gs.tight_layout(fig)
#gs.update(top=0.7)
plt.show()

    Comment tracer plusieurs Seaborn Jointplot dans l'intrigue secondaire

    Note qu'il pourrait y avoir certains inconvénients à partir de la copie de haches et de la ci-dessus n'est pas (encore) testé à fond.

    C'est vraiment une superbe réponse. J'ai copié votre classe directement dans mon code, et l'exemple clairement comment l'utiliser. Tout fonctionne exactement comme je l'espère 🙂
    Génial! Elle fonctionne.
    Quelles sont les modifications qui seraient nécessaires pour ClusterGrid?
    Vous essentiellement besoin de recréer de la grille utilisée par seaborn. Ce serait similaire à _movejointgrid mais avec quatre axes.
    Je pense que je me souviens pas y compris clustergrid ici, car il faudrait presque autant de code que de la création de la sorte de complot manuellement.

    OriginalL'auteur ImportanceOfBeingErnest