Eu tenho um conjunto de dados com um grande número de recursos, portanto, analisar a matriz de correlação se tornou muito difícil. Eu quero traçar uma matriz de correlação que obtemos usando a dataframe.corr()função da biblioteca de pandas. Existe alguma função interna fornecida pela biblioteca do pandas para plotar essa matriz?

Você pode usar pyplot.matshow() em matplotlib:

import matplotlib.pyplot as plt

plt.matshow(dataframe.corr())
plt.show()

Editar:

Nos comentários, havia uma solicitação de como alterar os rótulos dos marcadores do eixo. Aqui está uma versão de luxo desenhada em um tamanho de figura maior, com rótulos de eixo para corresponder ao quadro de dados e uma legenda da barra de cores para interpretar a escala de cores.

Estou incluindo como ajustar o tamanho e a rotação dos rótulos e estou usando uma proporção de figura que faz com que a barra de cores e a figura principal tenham a mesma altura.

f = plt.figure(figsize=(19, 15))
plt.matshow(df.corr(), fignum=f.number)
plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=45)
plt.yticks(range(df.shape[1]), df.columns, fontsize=14)
cb = plt.colorbar()
cb.ax.tick_params(labelsize=14)
plt.title('Correlation Matrix', fontsize=16);

Se seu objetivo principal é visualizar a matriz de correlação, em vez de criar um gráfico propriamente dito, as convenientes pandas opções de estilo são uma solução interna viável:

import pandas as pd
import numpy as np

rs = np.random.RandomState(0)
df = pd.DataFrame(rs.rand(10, 10))
corr = df.corr()
corr.style.background_gradient(cmap='coolwarm')
# 'RdBu_r' & 'BrBG' are other good diverging colormaps

Observe que isso precisa estar em um back-end que suporte a renderização HTML, como o Notebook JupyterLab. (O texto claro automático em fundos escuros é de um PR existente e não da versão mais recente lançada, pandas0,23).

Styling

Você pode limitar facilmente a precisão dos dígitos:

corr.style.background_gradient(cmap='coolwarm').set_precision(2)

Ou se livrar dos dígitos completamente, se você preferir a matriz sem anotações:

corr.style.background_gradient(cmap='coolwarm').set_properties(**{'font-size': '0pt'})

A documentação de estilo também inclui instruções de estilos mais avançados, como alterar a exibição da célula sobre a qual o ponteiro do mouse está passando o mouse. Para salvar a saída, você pode retornar o HTML anexando o render()método e depois gravá-lo em um arquivo (ou apenas fazer uma captura de tela para fins menos formais).

Comparação de tempo

Nos meus testes, style.background_gradient()foi 4x mais rápido que plt.matshow()e 120x mais rápido que sns.heatmap()com uma matriz 10x10. Infelizmente, não é tão dimensionável quanto plt.matshow(): os dois demoram quase o mesmo tempo para uma matriz 100x100 e plt.matshow()são 10x mais rápidos para uma matriz 1000x1000.

Salvando

Existem algumas maneiras possíveis de salvar o quadro de dados estilizado:

• Retorne o HTML anexando o render() método e, em seguida, grave a saída em um arquivo.
• Salve como um .xslxarquivo com formatação condicional anexando o to_excel()método
• Combine com imgkit para salvar um bitmap
• Faça uma captura de tela (para fins menos formais).

Atualização para pandas> = 0,24

Ao definir axis=None, agora é possível calcular as cores com base em toda a matriz, e não por coluna ou linha:

corr.style.background_gradient(cmap='coolwarm', axis=None)

Experimente esta função, que também exibe nomes de variáveis ​​para a matriz de correlação:

def plot_corr(df,size=10):
    '''Function plots a graphical correlation matrix for each pair of columns in the dataframe.

    Input:
        df: pandas DataFrame
        size: vertical and horizontal size of the plot'''

    corr = df.corr()
    fig, ax = plt.subplots(figsize=(size, size))
    ax.matshow(corr)
    plt.xticks(range(len(corr.columns)), corr.columns);
    plt.yticks(range(len(corr.columns)), corr.columns);

Versão do mapa de calor do Seaborn:

import seaborn as sns
corr = dataframe.corr()
sns.heatmap(corr, 
            xticklabels=corr.columns.values,
            yticklabels=corr.columns.values)

Você pode observar a relação entre os recursos desenhando um mapa de calor do mar ou a matriz de dispersão dos pandas.

Matriz de dispersão:

pd.scatter_matrix(dataframe, alpha = 0.3, figsize = (14,8), diagonal = 'kde');

Se você deseja visualizar a assimetria de cada recurso também - use gráficos de pares marítimos.

sns.pairplot(dataframe)

Sns Heatmap:

import seaborn as sns

f, ax = pl.subplots(figsize=(10, 8))
corr = dataframe.corr()
sns.heatmap(corr, mask=np.zeros_like(corr, dtype=np.bool), cmap=sns.diverging_palette(220, 10, as_cmap=True),
            square=True, ax=ax)

A saída será um mapa de correlação dos recursos. ou seja, veja o exemplo abaixo.

A correlação entre mercearia e detergentes é alta. Similarmente:

1. Mercearia e detergentes.

1. Leite e Mercearia
2. Leite e Detergentes_ Papel

1. Milk and Deli
2. Congelado e Fresco.
3. Congelado e Deli.

Dos gráficos em pares: é possível observar o mesmo conjunto de relações dos gráficos em pares ou da matriz de dispersão. Mas a partir disso, podemos dizer que, se os dados são normalmente distribuídos ou não.

Nota: O gráfico acima é o mesmo retirado dos dados, usado para desenhar o mapa de calor.

Você pode usar o método imshow () no matplotlib

import pandas as pd
import matplotlib.pyplot as plt
plt.style.use('ggplot')

plt.imshow(X.corr(), cmap=plt.cm.Reds, interpolation='nearest')
plt.colorbar()
tick_marks = [i for i in range(len(X.columns))]
plt.xticks(tick_marks, X.columns, rotation='vertical')
plt.yticks(tick_marks, X.columns)
plt.show()

Se você é o dataframe, dfpode simplesmente usar:

import matplotlib.pyplot as plt
import seaborn as sns

plt.figure(figsize=(15, 10))
sns.heatmap(df.corr(), annot=True)

Os gráficos statmodels também oferecem uma boa visão da matriz de correlação

import statsmodels.api as sm
import matplotlib.pyplot as plt

corr = dataframe.corr()
sm.graphics.plot_corr(corr, xnames=list(corr.columns))
plt.show()

Por uma questão de completude, a solução mais simples que conheço com os marinhos no final de 2019, se alguém estiver usando o Jupyter :

import seaborn as sns
sns.heatmap(dataframe.corr())

Juntamente com outros métodos, também é bom ter um gráfico de pares que fornecerá o gráfico de dispersão para todos os casos -

import pandas as pd
import numpy as np
import seaborn as sns
rs = np.random.RandomState(0)
df = pd.DataFrame(rs.rand(10, 10))
sns.pairplot(df)

Matriz de correlação de formulários, no meu caso, zdf é o quadro de dados que eu preciso para executar a matriz de correlação.

corrMatrix =zdf.corr()
corrMatrix.to_csv('sm_zscaled_correlation_matrix.csv');
html = corrMatrix.style.background_gradient(cmap='RdBu').set_precision(2).render()

# Writing the output to a html file.
with open('test.html', 'w') as f:
   print('<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-widthinitial-scale=1.0"><title>Document</title></head><style>table{word-break: break-all;}</style><body>' + html+'</body></html>', file=f)

Então podemos tirar uma captura de tela. ou converter html em um arquivo de imagem.