Plotando Elipses de Confiança com Matplotlib

Introdução

Este laboratório demonstrará como plotar elipses de confiança de um conjunto de dados bidimensional usando Python Matplotlib. Uma elipse de confiança é uma representação gráfica da covariância de um conjunto de dados, mostrando a incerteza da média e do desvio padrão estimados. As elipses são plotadas usando o coeficiente de correlação de Pearson.

Dicas para a VM

Após a inicialização da VM, clique no canto superior esquerdo para mudar para a aba Notebook e acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão, e resolveremos o problema prontamente para você.

Importar as Bibliotecas Necessárias

O primeiro passo é importar as bibliotecas necessárias. Precisaremos de numpy e matplotlib.pyplot para este laboratório.

import matplotlib.pyplot as plt
import numpy as np

Definir a Função confidence_ellipse

Em seguida, definimos a função confidence_ellipse que receberá as coordenadas x e y do conjunto de dados, o objeto de eixos para desenhar a elipse e o número de desvios padrão. Ela retorna um objeto patch do Matplotlib representando a elipse.

def confidence_ellipse(x, y, ax, n_std=3.0, facecolor='none', **kwargs):
    """
    Cria um gráfico da elipse de confiança da covariância de *x* e *y*.

    Parâmetros
    ----------
    x, y : array-like, shape (n, )
        Dados de entrada.

    ax : matplotlib.axes.Axes
        O objeto de eixos para desenhar a elipse.

    n_std : float
        O número de desvios padrão para determinar os raios da elipse.

    **kwargs
        Encaminhado para `~matplotlib.patches.Ellipse`

    Retorna
    -------
    matplotlib.patches.Ellipse
    """
    if x.size != y.size:
        raise ValueError("x and y must be the same size")

    cov = np.cov(x, y)
    pearson = cov[0, 1]/np.sqrt(cov[0, 0] * cov[1, 1])
    ## Using a special case to obtain the eigenvalues of this
    ## two-dimensional dataset.
    ell_radius_x = np.sqrt(1 + pearson)
    ell_radius_y = np.sqrt(1 - pearson)
    ellipse = Ellipse((0, 0), width=ell_radius_x * 2, height=ell_radius_y * 2,
                      facecolor=facecolor, **kwargs)

    ## Calculating the standard deviation of x from
    ## the squareroot of the variance and multiplying
    ## with the given number of standard deviations.
    scale_x = np.sqrt(cov[0, 0]) * n_std
    mean_x = np.mean(x)

    ## calculating the standard deviation of y ...
    scale_y = np.sqrt(cov[1, 1]) * n_std
    mean_y = np.mean(y)

    transf = transforms.Affine2D() \
        .rotate_deg(45) \
        .scale(scale_x, scale_y) \
        .translate(mean_x, mean_y)

    ellipse.set_transform(transf + ax.transData)
    return ax.add_patch(ellipse)

Definir a Função get_correlated_dataset

Também precisamos de uma função para gerar um conjunto de dados bidimensional com média, dimensões e correlação especificadas.

def get_correlated_dataset(n, dependency, mu, scale):
    """
    Cria um conjunto de dados bidimensional aleatório com a
    média bidimensional especificada (mu) e dimensões (scale).
    A correlação pode ser controlada pelo parâmetro 'dependency',
    uma matriz 2x2.
    """
    latent = np.random.randn(n, 2)
    dependent = latent.dot(dependency)
    scaled = dependent * scale
    scaled_with_offset = scaled + mu
    ## return x and y of the new, correlated dataset
    return scaled_with_offset[:, 0], scaled_with_offset[:, 1]

Plotando Correlações Positivas, Negativas e Fracas

Agora, podemos usar essas funções para plotar as elipses de confiança de conjuntos de dados com correlações positivas, negativas e fracas.

np.random.seed(0)

PARAMETERS = {
    'Positive correlation': [[0.85, 0.35],
                             [0.15, -0.65]],
    'Negative correlation': [[0.9, -0.4],
                             [0.1, -0.6]],
    'Weak correlation': [[1, 0],
                         [0, 1]],
}

mu = 2, 4
scale = 3, 5

fig, axs = plt.subplots(1, 3, figsize=(9, 3))
for ax, (title, dependency) in zip(axs, PARAMETERS.items()):
    x, y = get_correlated_dataset(800, dependency, mu, scale)
    ax.scatter(x, y, s=0.5)

    ax.axvline(c='grey', lw=1)
    ax.axhline(c='grey', lw=1)

    confidence_ellipse(x, y, ax, edgecolor='red')

    ax.scatter(mu[0], mu[1], c='red', s=3)
    ax.set_title(title)

plt.show()

Plotando Diferentes Números de Desvios Padrão

Também podemos plotar as elipses de confiança com diferentes números de desvios padrão.

fig, ax_nstd = plt.subplots(figsize=(6, 6))

dependency_nstd = [[0.8, 0.75],
                   [-0.2, 0.35]]
mu = 0, 0
scale = 8, 5

ax_nstd.axvline(c='grey', lw=1)
ax_nstd.axhline(c='grey', lw=1)

x, y = get_correlated_dataset(500, dependency_nstd, mu, scale)
ax_nstd.scatter(x, y, s=0.5)

confidence_ellipse(x, y, ax_nstd, n_std=1,
                   label=r'$1\sigma$', edgecolor='firebrick')
confidence_ellipse(x, y, ax_nstd, n_std=2,
                   label=r'$2\sigma$', edgecolor='fuchsia', linestyle='--')
confidence_ellipse(x, y, ax_nstd, n_std=3,
                   label=r'$3\sigma$', edgecolor='blue', linestyle=':')

ax_nstd.scatter(mu[0], mu[1], c='red', s=3)
ax_nstd.set_title('Different standard deviations')
ax_nstd.legend()
plt.show()

Usando Argumentos de Palavra-Chave

Finalmente, podemos personalizar a aparência das elipses usando argumentos de palavra-chave.

fig, ax_kwargs = plt.subplots(figsize=(6, 6))
dependency_kwargs = [[-0.8, 0.5],
                     [-0.2, 0.5]]
mu = 2, -3
scale = 6, 5

ax_kwargs.axvline(c='grey', lw=1)
ax_kwargs.axhline(c='grey', lw=1)

x, y = get_correlated_dataset(500, dependency_kwargs, mu, scale)
## Plot the ellipse with zorder=0 in order to demonstrate
## its transparency (caused by the use of alpha).
confidence_ellipse(x, y, ax_kwargs,
                   alpha=0.5, facecolor='pink', edgecolor='purple', zorder=0)

ax_kwargs.scatter(x, y, s=0.5)
ax_kwargs.scatter(mu[0], mu[1], c='red', s=3)
ax_kwargs.set_title('Using keyword arguments')

fig.subplots_adjust(hspace=0.25)
plt.show()

Resumo

Neste laboratório, aprendemos como plotar elipses de confiança de um conjunto de dados bidimensional usando Python Matplotlib. Definimos as funções confidence_ellipse e get_correlated_dataset, e as usamos para plotar elipses de conjuntos de dados com diferentes correlações e números de desvios padrão. Também mostramos como personalizar a aparência das elipses usando argumentos de palavra-chave.