Ploco de violino Matplotlib

Matplotlib é uma biblioteca de plotagem utilizada em Python. Para incorporar gráficos em programas, inclui interfaces orientadas a objetos. É uma estrutura para criar gráficos 2D usando dados da matriz. Um gráfico de violino geralmente está relacionado a um gráfico de boxe, mas esse gráfico também descreve a função de distribuição de probabilidade dos dados em vários parâmetros.

Como nos gráficos de caixas padrão, esses números fornecem um marcador para o valor médio dos dados e uma caixa que denota os quartis. Uma avaliação estatística é aplicada a este gráfico de caixa. Gráficos de violino, como gráficos de caixas, estão sendo usados ​​para mostrar como uma dispersão variável se compara entre muitas “classes.”Neste artigo, vamos discutir como criar parcelas de violino em matplotlib.

Visualize as parcelas de violino pelo uso da Biblioteca Matplotlib:

O matplotlib.Pyplot.O módulo ViolinPlot () gera um gráfico de violino para todos os conjuntos de seções ou variáveis ​​de dados em um conjunto de dados da série. Usando linhas adicionais no valor médio, médio, de menor valor, valor máximo e séries de dados definidas pelo usuário, cada área coberta se estende para indicar toda a amostra. Os cinco pontos de dados de dispersão erraticamente são construídos com Numpy na instância abaixo.

Cada coleção possui 1000 entradas; No entanto, o valor do desvio padrão e dos valores médios são variados. O uso de pontos de dados cria um gráfico de violino.

importar matplotlib.pyplot como plt
importar numpy como np
NP.aleatório.semente (3)
data_1 = np.aleatório.Normal (20, 50, 2000)
data_2 = np.aleatório.Normal (60, 10, 2000)
data_3 = np.aleatório.Normal (40, 70, 2000)
data_4 = np.aleatório.Normal (30, 80, 2000)
data_5 = np.aleatório.Normal (0, 10, 2000)
Data = [Data_1, Data_2, Data_3, Data_4, Data_5]
fig, ax = pLT.subtramas ()
machado.ViolinPlot (Dados, ShowMedians = True)
plt.mostrar()

Temos que incluir as bibliotecas necessárias matplotlib.pyplot tão plt e numpy como np para iniciar o código. Matplotlib é utilizado para desenhar gráficos. Agora chamamos a função aleatória () usando a biblioteca Numpy. Definimos pontos de dados para criar parcelas de violino. Aqui fazemos cinco variáveis ​​diferentes, que são usadas para armazenar os conjuntos de dados.

A função np.aleatório.Normal é aplicado para todos os conjuntos de dados. Além disso, criamos uma nova variável que mantém esses cinco conjuntos de dados. Declaramos um novo objeto da figura. E também empregamos o PLT.subtramas (). Para desenhar gráficos de violino, usamos o machado.Função ViolinPlot (). Aqui passamos 'verdadeiro' para o argumento 'ShowMedians' para esta função. No final, exibimos o gráfico usando o PLT.show () função.

Adicione linhas Gird às parcelas de violino:

Usando o machado de Matplotlib.Técnica ViolinPlot () para fazer um gráfico de violino. Showmeans e Showmedians são dois argumentos adicionais que podem ser usados. O programa subsequente cria um gráfico de violino com quatro "violinos com conjuntos de dados criados aleatoriamente.”

importar matplotlib.pyplot como plt
importar numpy como np
data_1 = np.aleatório.Normal (10, 12, 300)
data_2 = np.aleatório.Normal (10, 15, 300)
data_3 = np.aleatório.Normal (10, 22, 300)
data_4 = np.aleatório.Normal (10, 20, 300)
Data = List ([Data_1, Data_2, Data_3, Data_4])
fig, ax = pLT.subtramas ()
machado.ViolinPlot (dados, showmeans = true, showmedians = false)
machado.set_title ('gráfico de violino')
machado.set_xlabel ('x')
machado.set_ylabel ('y')
XtickLabels = ['Primeiro Lote', 'Segundo Plot', 'Terceira Lote', 'Quarto Plot']
machado.set_xticks ([0.9,1.9,2.9,3.9])
machado.set_xticklabels (xticklabels)
machado.yaxis.grade (verdadeira)
plt.mostrar()

Nós importamos matplotlib.Pyplot e bibliotecas Numpy. Na próxima etapa, começamos a criar quatro pontos de dados diferentes. E esses pontos de dados são armazenados em diferentes variáveis. Agora declaramos uma matriz contendo esses quatro pontos de dados. Utilizamos o PLT.Método Subparcelas ().

Além disso, o machado.o método de violinplot () é definido. Definimos o valor de Showmeans e Showmedians e passamos para a função. Agora inserimos o título do gráfico aplicando a função set_title (). Da mesma forma, utilizamos a função set_xlabel () e set_ylabel para modificar os rótulos de ambos os eixos. Os rótulos de tick () são usados ​​para criar uma lista.

Definimos a posição dos rótulos dessas quatro parcelas. E colocamos rótulos dessas parcelas no eixo x. Antes de utilizar o PLT.mostrar () para representar o gráfico, inserimos linhas de grade horizontal usando um machado.yaxis.Método Gird (). E definimos o valor 'verdadeiro' para esta função aqui.

Visualize gráficos de violino verticais:

Aqui vamos levar três conjuntos de dados aleatórios para criar parcelas de violino.

importar matplotlib.pyplot como plt
importar numpy como np
NP.aleatório.semente (50)
data_1 = np.aleatório.Normal (300, 20, 300)
data_2 = np.aleatório.Normal (40, 70, 300)
data_3 = np.aleatório.Normal (10, 30, 300)
data_list = [data_1, data_2, data_3,]
fig = plt.figura()
ax = fig.add_axes ([5,5,2,2])
bp = ax.ViolinPlot (Data_List)
machado.Xaxis.grade (verdadeira)
plt.mostrar()

No início do código, adquirimos bibliotecas Matplotlib.pyplot tão plt e numpy quanto np. Geramos aleatoriamente três conjuntos de dados pelo uso do módulo Numpy. Agora temos que combinar esses três conjuntos de dados em uma matriz. Então aqui declaramos uma matriz.

Além disso, chamamos o PLT.Figura () Função para criar um gráfico. Agora ajustamos os eixos do gráfico, por isso empregamos a função fig.add_axes (). Também geramos um gráfico de violino, então aplicamos o machado.Método ViolinPlot (). Para criar linhas de grade no eixo x, definimos o valor 'verdadeiro' para o machado.Xaxis.função gri (). Terminamos o código ligando para o PLT.show () função.

Visualize a trama de violino horizontal:

Com o uso do argumento 'vert', podemos criar um gráfico de violino horizontal, conforme apresentado abaixo.

importar matplotlib.pyplot como plt
importar numpy como np
NP.aleatório.semente (5)
data_1 = np.aleatório.Normal (30, 30, 3000)
data_2 = np.aleatório.Normal (80, 20, 3000)
data_3 = np.aleatório.Normal (10, 40, 3000)
data_4 = np.aleatório.Normal (20, 60, 300)
data_5 = np.aleatório.Normal (70, 50, 3000)
data_6 = np.aleatório.Normal (50, 10, 3000)
d = [data_1, data_2, data_3, data_4, data_5, data_6]
fig, ax = pLT.subtramas ()
machado.ViolinPlot (D, Vert = Falso, ShowMedians = True)
plt.mostrar()

Primeiro, apresentamos as bibliotecas no código que podem ser utilizadas para criar gráficos de violino. Agora aplicamos aleatórios.semente () usando a biblioteca Numpy. Agora tomamos conjuntos de dados aleatórios para os gráficos de violino. Esses conjuntos de dados são armazenados em diferentes variáveis. Em seguida, criamos a lista que contém todos esses conjuntos de dados. Além disso, empregamos PLT.subparcelas (), e também declaramos um novo objeto. Para criar parcelas de violino na figura, temos que utilizar o método ViolinPlot (), fornecendo os conjuntos de dados como um parâmetro. Também passamos o argumento 'vert' para esta função. Aqui, o valor deste parâmetro é 'falso', que mostra que temos que fazer parcelas de violino horizontais. Depois de tudo isso, exibimos o gráfico usando o PLT.show () função.

Conclusão:

Neste tutorial, nos comunicamos sobre as parcelas de violino Matplotlib. Usando o argumento 'vert', podemos criar essas parcelas nas direções verticais e horizontais. Nós também adicionamos linhas Gird ao enredo de violino. Essas parcelas podem ser modificadas para demonstrar os valores medianos e médios. Um gráfico de violino é muito mais útil do que um simples gráfico de caixa. Embora um gráfico de caixa simplesmente exiba resultados estatísticos e valores de quartis, um gráfico de violino exibe toda a dispersão de dados.