tamanho do marcador de plotagem de dispersão pyplot

No documento pyplot para plotagem de dispersão:

matplotlib.pyplot.scatter(x, y, s=20, c='b', marker='o', cmap=None, norm=None,
                          vmin=None, vmax=None, alpha=None, linewidths=None,
                          faceted=True, verts=None, hold=None, **kwargs)

O tamanho do marcador

s: tamanho em pontos ^ 2. É um escalar ou uma matriz do mesmo comprimento que x e y.

Que tipo de unidade é points^2? O que isso significa? Será que s=100quer dizer 10 pixel x 10 pixel?

Basicamente, estou tentando fazer gráficos de dispersão com tamanhos de marcador diferentes e quero descobrir o que esse snúmero significa.

Essa pode ser uma maneira um pouco confusa de definir o tamanho, mas você está basicamente especificando a área do marcador. Isso significa que, para dobrar a largura (ou altura) do marcador, é necessário aumentar sum fator de 4. [porque A = W H => (2W) (2H) = 4A]

Há uma razão, no entanto, que o tamanho dos marcadores é definido dessa maneira. Devido ao dimensionamento da área como o quadrado da largura, dobrar a largura na verdade parece aumentar o tamanho em mais de um fator 2 (na verdade, aumenta em um fator de 4). Para ver isso, considere os dois exemplos a seguir e a saída que eles produzem.

# doubling the width of markers
x = [0,2,4,6,8,10]
y = [0]*len(x)
s = [20*4**n for n in range(len(x))]
plt.scatter(x,y,s=s)
plt.show()

dá

Observe como o tamanho aumenta muito rapidamente. Se, em vez disso, temos

# doubling the area of markers
x = [0,2,4,6,8,10]
y = [0]*len(x)
s = [20*2**n for n in range(len(x))]
plt.scatter(x,y,s=s)
plt.show()

dá

Agora, o tamanho aparente dos marcadores aumenta aproximadamente linearmente de maneira intuitiva.

Quanto ao significado exato do que é um "ponto", é bastante arbitrário para fins de plotagem, você pode apenas dimensionar todos os seus tamanhos por uma constante até que pareçam razoáveis.

Espero que isto ajude!

Edit: (Em resposta ao comentário de @Emma)

Provavelmente é uma redação confusa da minha parte. A pergunta feita sobre dobrar a largura de um círculo, portanto, na primeira figura para cada círculo (à medida que avançamos da esquerda para a direita), sua largura é o dobro da anterior; portanto, para a área, é um exponencial com a base 4. Da mesma forma, o segundo exemplo cada círculo tem área duas vezes maior que a exponencial com base 2.

No entanto, é o segundo exemplo (onde estamos escalando a área) que a área duplicada parece fazer o círculo duas vezes maior do que o olho. Assim, se quisermos que um círculo apareça um fator nmaior, aumentaremos a área por um fator e nnão o raio, de modo que o tamanho aparente seja dimensionado linearmente com a área.

Edite para visualizar o comentário de @TomaszGandor:

É assim que parece para diferentes funções do tamanho do marcador:

x = [0,2,4,6,8,10,12,14,16,18]
s_exp = [20*2**n for n in range(len(x))]
s_square = [20*n**2 for n in range(len(x))]
s_linear = [20*n for n in range(len(x))]
plt.scatter(x,[1]*len(x),s=s_exp, label='$s=2^n$', lw=1)
plt.scatter(x,[0]*len(x),s=s_square, label='$s=n^2$')
plt.scatter(x,[-1]*len(x),s=s_linear, label='$s=n$')
plt.ylim(-1.5,1.5)
plt.legend(loc='center left', bbox_to_anchor=(1.1, 0.5), labelspacing=3)
plt.show()

Como outras respostas aqui alegam que sdenota a área do marcador, estou adicionando esta resposta para esclarecer que esse não é necessariamente o caso.

Tamanho em pontos ^ 2

O argumento sem plt.scatterdenota o markersize**2. Como a documentação diz

s: escalar ou array_like, forma (n),
tamanho opcional nos pontos ^ 2. O padrão é rcParams ['lines.markersize'] ** 2.

Isso pode ser tomado literalmente. Para obter um marcador com x pontos grandes, você precisa quadrá-lo e apresentá-lo ao sargumento.

Portanto, a relação entre o tamanho do marcador de um gráfico de linha e o argumento do tamanho da dispersão é o quadrado. Para produzir um marcador de dispersão do mesmo tamanho que um marcador de plotagem de tamanho 10 pontos, você chamaria scatter( .., s=100).

import matplotlib.pyplot as plt

fig,ax = plt.subplots()

ax.plot([0],[0], marker="o",  markersize=10)
ax.plot([0.07,0.93],[0,0],    linewidth=10)
ax.scatter([1],[0],           s=100)

ax.plot([0],[1], marker="o",  markersize=22)
ax.plot([0.14,0.86],[1,1],    linewidth=22)
ax.scatter([1],[1],           s=22**2)

plt.show()

Conexão com "área"

Então, por que outras respostas e até a documentação falam sobre "área" quando se trata do sparâmetro?

Obviamente, as unidades de pontos ** 2 são unidades de área.

• Para o caso especial de um marcador quadrado marker="s", a área do marcador é de fato diretamente o valor do sparâmetro.
• Para um círculo, a área do círculo é area = pi/4*s.
• Para outros marcadores, pode até não haver nenhuma relação óbvia com a área do marcador.

Em todos os casos, porém, a área do marcador é proporcional ao sparâmetro . Essa é a motivação para chamá-la de "área", embora na maioria dos casos não seja realmente.

A especificação do tamanho dos marcadores de dispersão em termos de alguma quantidade proporcional à área do marcador faz sentido até agora, pois é a área do marcador que é percebida ao comparar diferentes amostras em vez de seu comprimento ou diâmetro lateral. Ou seja, dobrar a quantidade subjacente deve dobrar a área do marcador.

O que são pontos?

Até agora, a resposta para o significado do tamanho de um marcador de dispersão é dada em unidades de pontos. Os pontos são frequentemente usados ​​em tipografia, onde as fontes são especificadas em pontos. As larguras de linha também são frequentemente especificadas em pontos. O tamanho padrão dos pontos no matplotlib é 72 pontos por polegada (ppi) - 1 ponto é, portanto, 1/72 polegadas.

Pode ser útil poder especificar tamanhos em pixels em vez de pontos. Se a figura dpi também for 72, um ponto é um pixel. Se a figura dpi for diferente (o padrão matplotlib é fig.dpi=100),

1 point == fig.dpi/72. pixels

Embora o tamanho do marcador de dispersão em pontos pareça diferente para diferentes dpi de figura, pode-se produzir um marcador de 10 por 10 pixels ^ 2, que sempre terá o mesmo número de pixels cobertos:

import matplotlib.pyplot as plt

for dpi in [72,100,144]:

    fig,ax = plt.subplots(figsize=(1.5,2), dpi=dpi)
    ax.set_title("fig.dpi={}".format(dpi))

    ax.set_ylim(-3,3)
    ax.set_xlim(-2,2)

    ax.scatter([0],[1], s=10**2, 
               marker="s", linewidth=0, label="100 points^2")
    ax.scatter([1],[1], s=(10*72./fig.dpi)**2, 
               marker="s", linewidth=0, label="100 pixels^2")

    ax.legend(loc=8,framealpha=1, fontsize=8)

    fig.savefig("fig{}.png".format(dpi), bbox_inches="tight")

plt.show() 

Se você estiver interessado em uma dispersão nas unidades de dados, verifique esta resposta .

Você pode usar markersize para especificar o tamanho do círculo no método de plotagem

import numpy as np
import matplotlib.pyplot as plt

x1 = np.random.randn(20)
x2 = np.random.randn(20)
plt.figure(1)
# you can specify the marker size two ways directly:
plt.plot(x1, 'bo', markersize=20)  # blue circle with size 10 
plt.plot(x2, 'ro', ms=10,)  # ms is just an alias for markersize
plt.show()

A partir daqui

É a área do marcador. Quero dizer, se você tem s1 = 1000e, em seguida s2 = 4000, a relação entre o raio de cada círculo é: r_s2 = 2 * r_s1. Veja o seguinte gráfico:

plt.scatter(2, 1, s=4000, c='r')
plt.scatter(2, 1, s=1000 ,c='b')
plt.scatter(2, 1, s=10, c='g')

Eu tinha a mesma dúvida quando vi o post, então fiz este exemplo e usei uma régua na tela para medir os raios.

Também tentei usar 'scatter' inicialmente para esse fim. Depois de muito tempo perdido - decidi pela seguinte solução.

import matplotlib.pyplot as plt
input_list = [{'x':100,'y':200,'radius':50, 'color':(0.1,0.2,0.3)}]    
output_list = []   
for point in input_list:
    output_list.append(plt.Circle((point['x'], point['y']), point['radius'], color=point['color'], fill=False))
ax = plt.gca(aspect='equal')
ax.cla()
ax.set_xlim((0, 1000))
ax.set_ylim((0, 1000))
for circle in output_list:    
   ax.add_artist(circle)

Isso é baseado em uma resposta a esta pergunta

Se o tamanho dos círculos corresponder ao quadrado do parâmetro em s=parameter, atribua uma raiz quadrada a cada elemento que você anexa à sua matriz de tamanho, assim: de s=[1, 1.414, 1.73, 2.0, 2.24]modo que, quando ele pega esses valores e os retorna, seu aumento relativo de tamanho será a raiz quadrada da progressão ao quadrado, que retorna uma progressão linear.

Se eu fosse para quadrados cada um como ele fica de saída até ao terreno: output=[1, 2, 3, 4, 5]. Tente a interpretação da lista:s=[numpy.sqrt(i) for i in s]