Python seaborn 模块，FacetGrid() 实例源码

def create_plot(json_data, output):
    all_data = pd.DataFrame(json_data)
    df = all_data[all_data['ProductDescription'] == 'Linux/UNIX']
    df = df.drop_duplicates(subset=['DateTime', 'AvailabilityZone', 'InstanceType'])
    x_min = df['DateTime'].min()
    x_max = df['DateTime'].max()
    border_pad = (x_max - x_min) * 5 / 100

    g = sns.FacetGrid(
        df,
        col='InstanceType',
        hue='AvailabilityZone',
        xlim=(x_min - border_pad, x_max + border_pad),
        legend_out=True,
        size=10,
        palette="Set1"
    )
    g.map(plt.scatter, 'DateTime', 'SpotPrice', s=4).add_legend()
    plt.subplots_adjust(top=.9)
    g.fig.suptitle('AWS Spot Prices between {start} and {end}'.format(start=x_min, end=x_max))
    g.savefig(output, format='png')

def map_data(self, func):
        """
        Map the dataframe using :func:`func`.

        This method wraps the function :func:`func` so that a facet is
        plotted for the grouping variables. In order for this to work,
        :func:`func` has to take two values: `data`, which is a sub-
        dataframe after grouping, and `color`, which is currently not
        used, but which must be handled by `func` anyway.

        Technically, it calls :func:`FacetGrid.map_dataframe` from
        `seaborn` with `func` as a parameter if more than one plot
        is required. Otherwise, it calls `func` directly, as `FacetGrid`
        can have problems if only one plot is drawn.

        Parameters
        ----------
        func : function
            The plotting function.
        """
        if self._col_factor:
            self.g.map_dataframe(func)
        else:
            func(self._table, None)

def adc_attack_speed():
    m_data = [champion_full.get_item_with_key(n) for n in _Marksman]
    champion_objects = [Champion(c['name'], **c['stats']) for c in m_data]
    data_as = {'champion': [],
               'attack speed': [],
               'level': []}

    for c in champion_objects:
        for i in range(1, 19):
            c.update_lv(i)
            data_as['champion'].append(c.name)
            data_as['attack speed'].append(c.attackspeed)
            data_as['level'].append(i)

    dff = pd.DataFrame(data_as)
    g = sns.FacetGrid(dff, hue='champion', size=5, aspect=1.5)
    g = g.map(plt.plot, 'level', 'attack speed').add_legend()
    g.set_axis_labels('??', '??')
    g.set_titles("??????????")
    g.set(xticks=np.arange(1, 20, 1))
    g.set(yticks=np.arange(0.5, 1.2, 0.05))
    sns.plt.show()

def display_covariate_dist(self, covariate_list, save_file=None):
        '''
        '''

        n_covars = len(covariate_list)

        for covariate in covariate_list:
            g = sns.FacetGrid(self.data, col="arm_assignment")
            if len(self.data[covariate].unique())>2:
                g.map(sns.distplot, covariate, kde=False)
            else:
                g.map(sns.distplot, covariate, kde=False)
            if save_file:
                g.savefig(save_file, dpi=450)

        if save_file is None:
            sns.plt.show()

def plot_polar(theta, N):
    """Plot polar plot.

    theta -- the dataframe with the turning angles
    N -- number of bins to use
    """
    hist, bins = np.histogram(theta.ta, bins=N)

    # the width of the bins interval
    width = [t - s for s, t in zip(bins, bins[1:])]
    bins_ = bins[0:N]  # exclude the last value

    # the actual plotting logic
    g = sns.FacetGrid(theta, size=4)

    radii = hist / max(hist)

    for ax in g.axes.flat:
        ax2 = plt.subplot(111, projection='polar')
        bars = ax2.bar(bins_, radii, width, bottom=0.0)
        for r, bar in zip(radii, bars):
            bar.set_facecolor(plt.cm.Spectral(r))
            bar.set_alpha(0.5)

    sns.plt.savefig("turning_angles.png")

def plot_llk(train_elbo, test_elbo):
    import matplotlib.pyplot as plt
    import numpy as np
    import scipy as sp
    import seaborn as sns
    import pandas as pd
    plt.figure(figsize=(30, 10))
    sns.set_style("whitegrid")
    data = np.concatenate([np.arange(len(test_elbo))[:, sp.newaxis], -test_elbo[:, sp.newaxis]], axis=1)
    df = pd.DataFrame(data=data, columns=['Training Epoch', 'Test ELBO'])
    g = sns.FacetGrid(df, size=10, aspect=1.5)
    g.map(plt.scatter, "Training Epoch", "Test ELBO")
    g.map(plt.plot, "Training Epoch", "Test ELBO")
    plt.savefig('./vae_results/test_elbo_vae.png')
    plt.close('all')

def plot_actions(cue=0):
    mpl.rcParams['axes.labelsize'] = 'large'
    d_map = {3:1, 8:2, 14:3, 23:4}
    df = pd.read_pickle('data.pkl').reset_index()
    df = df.loc[df['cue'] == cue]
    g = sns.FacetGrid(df, col='subject',
                      col_wrap=6, size=1.5, ylim=(0, 5), aspect=1.5)

    g.map(plt.plot, 'action')
    g.set(xticks=[], yticks=[0,1,2,3], yticklabels=['3', '8', '14', '23'])
    g.set(ylim=(-0.5, 4))
    g.set_ylabels('choice')
    g.fig.tight_layout()
    g.fig.subplots_adjust(top=0.93)


    subjects = df['subject'].unique()
    for ax, subject in zip(g.axes, subjects):
        df_subject = df.loc[df['subject'] == subject]
        df_subject.reset_index(inplace=True)
        df_wins = df_subject.loc[df_subject['reward'] > 0]
        df_lose = df_subject.loc[df_subject['reward'] < 0]
        pos_win = df_wins.loc[df_wins['subject'] == subject].index
        pos_lose = df_lose.loc[df_lose['subject'] == subject].index
        ax.eventplot(pos_win, lineoffsets=3.5, linelength=0.75,
                     linewidths=0.4)
        ax.eventplot(pos_lose, lineoffsets=3.5, linelength=0.75,
                     color='r', linewidths=0.4)
    plt.tight_layout()
    plt.savefig('actions_0.pdf')
    plt.show()
    globals().update(locals())

def setup_figure(self):
        """
        Prepare the matplotlib figure for plotting.

        This method sets the default font, and the overall apearance of the
        figure.
        """

        if options.cfg.xkcd:
            fonts = QtGui.QFontDatabase().families()
            for x in ["Humor Sans", "DigitalStrip", "Comic Sans MS"]:
                if x in fonts:
                    self.options["figure_font"] = QtGui.QFont(x, pointSize=self.options["figure_font"].pointSize())
                    break
            else:
                for x in ["comic", "cartoon"]:
                    for y in fonts:
                        if x.lower() in y.lower():
                            self.options["figure_font"] = QtGui.QFont(x, pointSize=self.options["figure_font"].pointSize())
                            break
            plt.xkcd()

        with sns.plotting_context("paper"):
            self.g = sns.FacetGrid(self._table,
                                   col=self._col_factor,
                                   col_wrap=self._col_wrap,
                                   row=self._row_factor,
                                   sharex=True,
                                   sharey=True)

def get_grid(self, **kwargs):
        kwargs["data"] = self.df
        with sns.axes_style(self.axes_style):
            with sns.plotting_context(self.plotting_context):
                grid = sns.FacetGrid(**kwargs)
        return grid

def plot_lc(lc, metrics=None, outputs=False):
    lc = pd.melt(lc, id_vars=['split', 'epoch'], var_name='output')
    if metrics:
        if not isinstance(metrics, list):
            metrics = [metrics]
        tmp = '(%s)' % ('|'.join(metrics))
        lc = lc.loc[lc.output.str.contains(tmp)]
    metrics = lc.output[~lc.output.str.contains('_')].unique()
    lc['metric'] = ''

    for metric in metrics:
        lc.loc[lc.output.str.contains(metric), 'metric'] = metric
        lc.loc[lc.output == metric, 'output'] = 'mean'
        lc.output = lc.output.str.replace('_%s' % metric, '')
        lc.output = lc.output.str.replace('cpg_', '')

    if outputs:
        lc = lc.loc[lc.output != 'mean']
    else:
        lc = lc.loc[lc.output == 'mean']

    grid = sns.FacetGrid(lc, col='split', row='metric', hue='output',
                         sharey=False, size=3, aspect=1.2, legend_out=True)
    grid.map(mpl.pyplot.plot, 'epoch', 'value', linewidth=2)
    grid.set(ylabel='')
    grid.add_legend()
    return grid

def plot_stats(stats):
    stats = stats.sort_values('frac_obs', ascending=False)
    stats = pd.melt(stats, id_vars=['output'], var_name='metric')
    #  stats = stats.loc[stats.metric.isin(['frac_obs', 'frac_one'])]
    #  stats.metric = stats.metric.str.replace('frac_obs', 'cov')
    #  stats.metric = stats.metric.str.replace('frac_one', 'met')
    grid = sns.FacetGrid(data=stats, col='metric', sharex=False)
    grid.map(sns.barplot, 'value', 'output')
    for ax in grid.axes.ravel():
        ax.set(xlabel='', ylabel='')
    return grid

def errorplot(x, y, minconf, maxconf, **kwargs):
    '''
    e.g.
    g = sns.FacetGrid(attr, col='run', hue='subj_pos', col_wrap=5)
    g = g.map(errorplot, 'n_diff_intervening', 'errorprob',
        'minconf', 'maxconf').add_legend()
    '''
    plt.errorbar(x, y, yerr=[y - minconf, maxconf - y], fmt='o-', **kwargs)

def plotXY(df, id_, x_coord, y_coord):
    """Plot the raw trajectories.

    df -- the trajectories dataframe
    id_ -- an identifier (for linear connections of objects)
    x_coord -- the x coordinate
    y_coord -- the y coordinate
    """
    grid = sns.FacetGrid(df, hue=id_,
                         size=6, palette=sns.color_palette("Set1", 10))
    grid.fig.suptitle('XY trajectories')
    grid.map(plt.plot, x_coord, y_coord, marker=".", ms=0.3)
    grid.map(plt.scatter, x_coord, y_coord, marker="o", s=20)
    grid.set_xticklabels(rotation=90)
    sns.plt.savefig("trajectories.png")

def plot_predictive_baseline(env, samples, stddev_mult=3., title_name=None):
    # single var regression only
    samples = samples.squeeze()

    train_x, train_y = env.get_train_x(), env.get_train_y()
    test_x, test_y = env.get_test_x(), env.get_test_y()

    pad_width = test_x.shape[0] - train_x.shape[0]
    train_x_padded = np.pad(train_x[:, 0], (0, pad_width), 'constant', constant_values=np.nan)
    train_y_padded = np.pad(train_y[:, 0], (0, pad_width), 'constant', constant_values=np.nan)

    data = samples

    df = pd.DataFrame.from_dict({
        'time': test_x[:, 0],
        'true_y': test_y[:, 0],
        'train_x': train_x_padded,
        'train_y': train_y_padded,
        'mean': data.mean(axis=0),
        'std': stddev_mult * data.std(axis=0),
        # 'stdn': 2. * (data.std(axis=0) + .5 ** .5),
    }).reset_index()

    g = sns.FacetGrid(df, size=9, aspect=1.8)

    g.map(plt.errorbar, 'time', 'mean', 'std', color=(0.7, 0.1, 0.1, 0.09))
    g.map(plt.plot, 'time', 'mean', color='b', lw=1)
    g.map(plt.plot, 'time', 'true_y', color='r', lw=1)
    g.map(plt.scatter, 'train_x', 'train_y', color='g', s=20)

    ax = g.ax
    ax.set_title('Posterior Predictive Distribution' + (': ' + title_name) if title_name is not None else '')
    ax.set(xlabel='X', ylabel='Y')
    ax.set_xlim(env.view_xrange[0], env.view_xrange[1])
    ax.set_ylim(env.view_yrange[0], env.view_yrange[1])

    legend = ['Prediction mean', 'True f(x)', 'Training data', 'StdDev']
    plt.legend(legend)

    # ax.annotate("MSE: {:.03f}".format(0), xy=(0.1, 0.9), xytext=(0.1, 0.9), xycoords='figure fraction',
    #             textcoords='figure fraction')

    name = utils.DATA_DIR.replace('/', '-')
    plt.tight_layout(pad=0.6)
    utils.save_fig('predictive-distribution-' + name)

def plot_predictive_comparison(env, baseline_samples, target_samples, stddev_mult=3., target_metrics=None,
                               title_name=None):
    # single var regression only
    baseline_samples = baseline_samples.squeeze()
    target_samples = target_samples.squeeze()

    train_x, train_y = env.get_train_x(), env.get_train_y()
    test_x, test_y = env.get_test_x(), env.get_test_y()

    pad_width = test_x.shape[0] - train_x.shape[0]
    train_x_padded = np.pad(train_x[:, 0], (0, pad_width), 'constant', constant_values=np.nan)
    train_y_padded = np.pad(train_y[:, 0], (0, pad_width), 'constant', constant_values=np.nan)

    df = pd.DataFrame.from_dict({
        'time': test_x[:, 0],
        'true_y': test_y[:, 0],
        'train_x': train_x_padded,
        'train_y': train_y_padded,
        'mean': target_samples.mean(axis=0),
        'std': stddev_mult * target_samples.std(axis=0),
        'base_mean': baseline_samples.mean(axis=0),
        'base_std': stddev_mult * baseline_samples.std(axis=0),
    }).reset_index()

    g = sns.FacetGrid(df, size=9, aspect=1.8)

    g.map(plt.errorbar, 'time', 'base_mean', 'base_std', color=(0.7, 0.1, 0.1, 0.09))
    g.map(plt.errorbar, 'time', 'mean', 'std', color=(0.1, 0.1, 0.7, 0.09))
    g.map(plt.plot, 'time', 'mean', color='b', lw=1)
    g.map(plt.plot, 'time', 'true_y', color='r', lw=1)
    g.map(plt.scatter, 'train_x', 'train_y', color='g', s=20)

    ax = g.ax
    ax.set_title('Posterior Predictive Distribution' + (': ' + title_name) if title_name is not None else '')
    ax.set(xlabel='X', ylabel='Y')
    ax.set_xlim(env.view_xrange[0], env.view_xrange[1])
    ax.set_ylim(env.view_yrange[0], env.view_yrange[1])

    legend = ['Prediction mean', 'True f(x)', 'Training data', 'True StdDev', 'Predicted StdDev']
    plt.legend(legend)

    if target_metrics is not None:
        offset = 0
        for tm, tv in target_metrics.items():
            ax.annotate(f'{tm}: {tv:.02f}', xy=(0.08, 0.92 - offset), xytext=(0.08, 0.92 - offset),
                        xycoords='figure fraction', textcoords='figure fraction')
            offset += 0.04

    name = utils.DATA_DIR.replace('/', '-')
    plt.tight_layout(pad=0.6)
    utils.save_fig('predictive-distribution-' + name)

def plot_facet_grid(df, target, frow, fcol, tag='eda', directory=None):
    r"""Plot a Seaborn faceted histogram grid.

    Parameters
    ----------
    df : pandas.DataFrame
        The dataframe containing the features.
    target : str
        The target variable for contrast.
    frow : list of str
        Feature names for the row elements of the grid.
    fcol : list of str
        Feature names for the column elements of the grid.
    tag : str
        Unique identifier for the plot.
    directory : str, optional
        The full specification of the plot location.

    Returns
    -------
    None : None.

    References
    ----------

    http://seaborn.pydata.org/generated/seaborn.FacetGrid.html

    """

    logger.info("Generating Facet Grid")

    # Calculate the number of bins using the Freedman-Diaconis rule.

    tlen = len(df[target])
    tmax = df[target].max()
    tmin = df[target].min()
    trange = tmax - tmin
    iqr = df[target].quantile(Q3) - df[target].quantile(Q1)
    h = 2 * iqr * (tlen ** (-1/3))
    nbins = math.ceil(trange / h)

    # Generate the pair plot

    sns.set(style="darkgrid")

    fg = sns.FacetGrid(df, row=frow, col=fcol, margin_titles=True)
    bins = np.linspace(tmin, tmax, nbins)
    fg.map(plt.hist, target, color="steelblue", bins=bins, lw=0)

    # Save the plot
    write_plot('seaborn', fg, 'facet_grid', tag, directory)


#
# Function plot_distribution
#

def plot_alphadf(alphasdf, col_order, labeldict, metric='alpha'):
    """
    Plot faceted alpha diversity.

    Parameters
    ----------
    alphasdf : pandas DataFrame
        columns ['study', 'alpha', 'DiseaseState']
    col_order : list
        dataset IDs in the order they should be plotted
    labeldict : dict
        dictionary with {dataset: label}
    mteric : str
        alpha diversity metric, to use in labeling y axis

    Returns
    -------
    fig : Figure
    """
    sns.set_style('white')
    g = sns.FacetGrid(alphasdf, col='study', col_wrap=6,
                      col_order=col_order, sharex=False, sharey=False)
    g = g.map(sns.boxplot, "DiseaseState", "alpha")
    g = g.map(sns.stripplot, "DiseaseState", "alpha", split=True, jitter=True,
              size=5, linewidth=0.6)

    fig = plt.gcf()
    fig.set_size_inches(14.2, 9)

    # Fix y-axis gridlines
    axs = g.axes
    for i in range(len(axs)):
        ax = axs[i]
        yticks = ax.get_yticks()
        # If bottom limit is between 0 and 1 (i.e. not simpson)
        if not (yticks[0] < 1 and yticks[0] > 0):
            ax.set_ylim(floor(yticks[0]), floor(yticks[-1]))
        if yticks[0] < 0:
            ax.set_ylim(0, floor(yticks[-1]))

        yticks = ax.get_yticks()
        if (yticks[0] < 1 and yticks[0] > 0):
            ax.set_yticks(yticks[1::2])
        else:
            ax.set_yticks(yticks[::2])
            # Need some space on the y-axis for p-values
            ax.set_ylim(ax.get_ylim()[0], 1.2*ax.get_ylim()[1])
        # Update title
        oldtitle = ax.get_title()
        newtitle = labeldict[oldtitle.split('=')[1].strip()]
        ax.set_title(newtitle)

        # Update y label
        if i % 6 == 0:
            ax.set_ylabel(metric)

    plt.tight_layout()
    return fig