Python/Matplotlib: In zufälliger Reihenfolge wählen „Probe“ Streupunkte für verschiedenen Marker

Question

So ziemlich genau das, was die Frage Staaten, aber ein wenig Kontext:

Ich bin ein Programm der Schaffung eine große Anzahl von Punkten plotten (~ 10.000 , aber es wird später mehr sein). Dies wird mit Hilfe von matplotlibs plt.scatter gemacht. Dieser Befehl ist Teil einer Schleife, die die Figur speichert, damit ich sie später animieren kann.

Was ich tun möchte, ist zufällig einen kleinen Teil dieser Partikel (sagen wir vielleicht 100?) Auszuwählen und ihnen einen anderen Marker als den Rest zu geben, obwohl sie Teil des gleichen Datensatzes sind. Dies ist so, dass ich sie als Platzhalter verwenden kann, um die Bewegung der einzelnen Partikel sowie das Schüttgut zu sehen.

Gibt es eine Möglichkeit, einen anderen Marker für eine kleine Teilmenge der gleichen Daten zu verwenden?

Als Referenz werden die Teilchen gleichmäßig gerade verteilt, um den numpy Zufallssampler verwendet wird, aber mein Code für das heißt:

for i in range(N): # N number of particles 
    particle_position[i] = np.random.uniform(0, xmax) # Initialize in spatial domain 
    particle_velocity[i] = np.random.normal(0, 5)  # Initialize in velocity space 

for i in range(maxtime): 
    plt.scatter(particle_position, particle_velocity, s=1, c=norm_xvel, cmap=br_disc, lw=0) 

die Position und Geschwindigkeit bei jeder Iteration der Hauptschleife Änderung (es gibt ziemlich viel von Code), aber dies sind die Hauptinitialisierungs- und Zeichenroutinen.

Ich hatte eine Idee, dass ich vielleicht eine Reihe von i Werten aus dem Bereich (N) zufällig auswählen und einen ax.scatter() Befehl verwenden könnte, um sie auf den gleichen Achsen zu zeichnen?

Answer 1

Der folgende Code erfüllt Ihre Wünsche. Ich habe eine zufällige Menge v_sub_index von N_sub Indizes im richtigen Bereich ausgewählt (0 bis N) und zeichne diese (mit _sub Suffix) aus den größeren Proben particle_position und particle_velocity. Beachten Sie, dass Sie keine Schleife erstellen müssen, um Stichproben zu generieren. Numpy hat eine großartige Funktionalität dafür, ohne for Loops verwenden zu müssen.

import numpy as np 
import matplotlib.pyplot as pl 

N = 100 
xmax = 1. 
v_sigma = 2.5/2. # 95% of the samples contained within 0, 5 
v_mean = 2.5  # mean at 2.5 

N_sub = 10 
v_sub_index = np.random.randint(0, N, N_sub) 

particle_position = np.random.rand (N) * xmax 
particle_velocity = np.random.randn(N) 

particle_position_sub = np.array(particle_position[v_sub_index]) 
particle_velocity_sub = np.array(particle_velocity[v_sub_index]) 
particle_position_nosub = np.delete(particle_position, v_sub_index) 
particle_velocity_nosub = np.delete(particle_velocity, v_sub_index) 

pl.scatter(particle_position_nosub, particle_velocity_nosub, color='b', marker='o') 
pl.scatter(particle_position_sub , particle_velocity_sub , color='r', marker='^') 
pl.show() 

Answer 2

Hier ist eine mögliche Lösung, die eine Teilmenge der Punkte mit einem anderen Marker identifiziert haben:

import matplotlib.pyplot as plt 
import numpy as np 

SIZE = 100 
SAMPLE_SIZE = 10 

def select_subset(seq, size): 
    """selects a subset of the data using ... 
    """ 
    return seq[:size] 

points_x = np.random.uniform(-1, 1, size=SIZE) 
points_y = np.random.uniform(-1, 1, size=SIZE) 

plt.scatter(points_x, points_y, marker=".", color="blue") 
plt.scatter(select_subset(points_x, SAMPLE_SIZE), 
      select_subset(points_y, SAMPLE_SIZE), 
      marker="o", color="red") 

plt.show() 

Es verwendet plt.scatter zweimal; einmal auf den gesamten Datensatz, der andere auf die Beispielpunkte.

Sie müssen entscheiden, wie Sie die Probe Punkte auswählen möchten - es in der select_subset Funktion isoliert ..

Sie auch die Probenpunkte aus dem Datensatz extrahieren könnte, sie zu verhindern Markierung zweimal, aber numpy ist beim Löschen oder Ändern der Größe ziemlich ineffizient.

Vielleicht ist eine bessere Methode, eine Maske zu verwenden? Eine Maske hat den Vorteil, dass Ihre Originaldaten intakt und in der richtigen Reihenfolge bleiben.

ist hier eine Weise, mit Masken, um fortzufahren:

import matplotlib.pyplot as plt 
import numpy as np 
import random 

SIZE = 100 
SAMPLE_SIZE = 10 

def make_mask(data_size, sample_size): 
    mask = np.array([True] * sample_size + [False ] * (data_size - sample_size)) 
    np.random.shuffle(mask) 
    return mask 

points_x = np.random.uniform(-1, 1, size=SIZE) 
points_y = np.random.uniform(-1, 1, size=SIZE) 
mask = make_mask(SIZE, SAMPLE_SIZE) 
not_mask = np.invert(mask) 

plt.scatter(points_x[not_mask], points_y[not_mask], marker=".", color="blue") 
plt.scatter(points_x[mask], points_y[mask], marker="o", color="red") 

plt.show() 

Wie Sie sehen, ist scatter einmal auf einer Teilmenge der Datenpunkte genannt (die, die nicht in die Stichprobe ausgewählt) und eine auf der zweiten Mal die abgetastete Teilmenge und zeichnet jede Teilmenge mit ihrer eigenen Markierung. Es ist effizient & lässt die ursprünglichen Daten intakt.