Zum Inhalt

Mapping

Als Mapping bezeichnen wir das Umwandeln von Attributwerten aus einem Graphen in Farb- und Größenattribute für die grafische Darstellung.

Mappings können auf eine Vielzahl von Elementen angewandt werden:

Es gibt 3 Möglichkeiten für das Basis-Mapping:

  • fixed: Übernimmt einen festgelegten Wert für Farbe oder Größe, also einen float, int oder str. Dieser wird für alle Elementattribute übernommen.
  • qualitative: Damit werden qualitative Attributsausprägungen auf Graphenelemente gemappt. Beispielsweise hat das Attribut "pet" die Ausprägungen "cat", "dog", "mouse". Die Ausprägungen sind unterschiedlich, verfügen allerdings über keine natürliche Rangfolge.
  • sequential: Damit werden sequentielle Attributsausprägungen auf Graphenelemente gemappt. Beispielsweise kann dafür das Degree eines Knoten verwendet werden. Die Ausprägungen sind unterschiedlich, kontinuierlich und besitzen eine natürliche Rangfolge.

Dazu gibt es drei mögliche Mappings, um Attributen andere grafische Darstellung zu geben, auf Basis einer gegebenen Bedingung:

  • filtering: Damit wird ein neues Mapping auf das ursprüngliche Mapping gemappt, wenn ein Attribut eine Wahr/Falsch-Bedingung erfüllt.
  • percentile: Damit wird ein neues Mapping auf das ursprüngliche Mapping gemappt, wenn die Perzentile eines Attributs ausserhalb der gegebenen Perzentile liegt.
  • from_node: Übernimmt die Werte des Mappings von Knoten (oder Labels) für das Mapping von Kanten. Entweder kann das Mapping des Start- oder Endknotens zugrunde gelegt werden oder die Bedingung, dass Start- und Endknoten gleich müssen.

Diese Mappings sind für komplexere Abbildungen gedacht.

Anwendung

Das Mapping steht in engem Zusammenhang mit dem ImageGenerator. Für einen Einstieg in das Zeichnen siehe hier.

Fixe Werte

G = nx.Graph() # (1)
G.add_node("a")
G.add_node("b")
ig = dsstools.ImageGenerator(graph) # (2)

fix = fixed(12) # (3)
ig.nodes.set_sizes(fix) # (4)
  1. Erstellung eines einfachen Graphens.
  2. Erstellung eines ImageGenerators.
  3. Hier wird ein Objekt mit einem fixen Wert von 12 initialisiert und der Variable fix zugewiesen.
  4. Hier wird das Objekt fix den Knoten zugewiesen. Alle Knoten im Netzwerk werden nun mit dem Durchmesser 12 gezeichnet.

Die letzten zwei Zeilen können auch kürzer zusammengefasst werden:

ig.nodes.set_sizes(fixed(12))
Fixed ist das default mapping also float und str können direkt benutzt werden:

ig.nodes.set_sizes(12)

Qualitative Werte

G = nx.Graph() # (1)
G.add_node("a", pet="dog") # (2)
G.add_node("b", pet="cat")
ig = dsstools.ImageGenerator(graph) # (3)

qual = qualitative("pet", {"cat": "red", "dog": "green"}) # (4)
ig.nodes.set_colors(qual) # (5)
  1. Erstellung eines einfachen Graphens.
  2. Hier werden Knoten mit Daten erstellt: Der Knoten a hat für das Attribut pet den Wert dog.
  3. Erstellung eines ImageGenerators.
  4. Hier wird ein Objekt mit einem Attributschlüssel ("pet") und einem dict initialisiert, welches die Zuweisung von Wert zu Farbe erhält. Dies wird der Variable qual zugewiesen.
  5. Hier wird das Objekt qual den Knoten des Graphen als Farbe zugewiesen. Alle Knoten im Netzwerk werden nun mit den Farben der Zuweisung aus dem dict gezeichnet.

Auch hier lassen sich die letzten zwei Zeilen kürzer schreiben:

ig.nodes.set_colors(
    qualitative("pet", {"cat": "red", "dog": "green"}
                )

Falls ein qualitatives Mapping für Größen verwendet werden soll, so müssen in das dict entsprechend statt der Farben Zahlenwerte eingetragen, die die Größe repräsentieren. Katzenmenschen würden das entsprechend so darstellen:

ig.nodes.set_sizes(qualitative("pet", {"cat": 50, "dog": 5})

Sequentielle Werte

G = nx.Graph() # (1)
G.add_node("a") # (2)
G.add_node("b")
ig = dsstools.ImageGenerator(graph) # (3)

sequ = sequential("degree", out_range=(10, 50) ) # (4)
ig.nodes.set_sizes(sequ) # (5)
  1. Erstellung eines einfachen Graphens.
  2. Hier werden Knoten ohne zusätzliche Daten erstellt, da wir bereits vorhandene Attribute des Graphen und seiner Knoten nutzen.
  3. Erstellung eines ImageGenerators.
  4. Hier wird ein Objekt mit einem Attributschlüssel ("degree") und einer out_range initialisiert, welches die im Netzwerk vorhandenen Werte zu einer Größe zuweist. Dies wird der Variable sequ zugewiesen.
  5. Hier wird das Objekt sequ den Knoten zugewiesen. Alle Knoten im Netzwerk werden nun mit den Größen der Zuweisung aus der out_range gezeichnet.

Hinweis

Hier ist die Angabe des "degree" natürlich nicht sonderlich sinnvoll, da keine Kanten im Netzwerk bestehen.

Die Kurzschreibweise sollte jetzt aus den bisherigen Beispielen bekannt sein. Genauso lassen sich sequentielle Werte auf das Farben übertragen. Dann muss allerdings anstatt des Parameters out_range der Parameter cmap (Colormap) verwendet werden. In diesem Fall wählen wir die Colormap viridis:

ig.nodes.set_colors("degree", cmap="viridis")

Farben und Größen können kombiniert werden, sodass sowohl Größe als auch Farbe von Knoten korreliert: 

(
    ig.nodes
    .set_colors("degree", cmap="viridis")
    .set_sizes("degree", out_range=(5,50))
)
Für durch das Netz definierte Parameter sind in sequentiellen Mappings folgende Werte erlaubt:

  • "indegree"
  • "outdegree"
  • "degree"
  • "centrality"
  • "betweenness"
  • "closeness"

Darüber hinaus können auch manuell gesetzte Werte verwendet werden: 

G = nx.Graph() # (1)
G.add_node("a", rating=3) # (2)
G.add_node("b", rating=7)
G.add_node("c")
ig = dsstools.ImageGenerator(graph) # (3)

ig.nodes.set_sizes(
    sequential("rating", out_range=(12, 36), fallback=5) # (4)
)

ig.nodes.set_colors(
    sequential("rating", fallback="orange", colormap="viridis") # (5)
)

  1. Erstellung eines einfachen Graphens.
  2. Hier werden Knoten mit Daten erstellt: Der Knoten a hat für das Attribut rating den Wert 3. Auch wird ein Knoten ohne das Attribut rating erstellt (c).
  3. Erstellung eines ImageGenerators.
  4. Hier wird ein Mapping-Objekt mit einem Attributschlüssel rating und einer out_range initialisiert, welches die im Netzwerk vorhandenen Werte zu einer Größe zuweist. Darüber hinaus wird mit fallback ein Standardwert für alle Knoten festgelegt, die nicht über das Attribut verfügen (gilt bspw. für den Knoten c). Alles zusammen wird den Knotengrößen mit ig.nodes.set_sizes() zugewiesen.
  5. Hier wird ein Mapping-Objekt für die Farbe erstellt. Die Vorgehensweise zur darüberliegenden Zeile.

Erweiterte Mappings

Erweiterte Mappings bauen auf bestehenden Mappings auf, um komplexere Mappings zu erstellen. Zwei Möglichkeiten für erweitertete Mappings gibt es:

  • filter: Erstellt ein Mapping entsprechend einer Filterbedingung. Die Filterbedingung wird für jedes Grafenelement evaluiert. Die Werte aus dem zugrundeliegenden base-Mapping werden übernommen, wenn der Ausdruck der Bedingung False zurückgibt. Die Werte von new_mapping werden hingegen genutzt, wenn die Bedingung True ist.
  • from_node: Übernimmt die Werte des Mappings von Knoten (oder Labels) für das Mapping von Kanten. Entweder kann das Mapping des Start- oder Endknotens zugrunde gelegt werden oder die Bedingung, dass Start- und Endknoten gleich müssen.

Filter-Werte

Bedingung
G = nx.Graph() # (1)
G.add_node("a")
G.add_node("b")
ig = dsstools.ImageGenerator(graph) # (2)

base = fixed("blue") # (3)
new_mapping = fixed("orange") # (4)
attribute = "degree" # (5)
condition = lambda x:x > 0.5 # (6)
filtered = filtering(base, new_mapping, attribute, condition) # (7)


ig.nodes.set_colors(filtering) # (8)
  1. Erstellung eines einfachen Graphens.
  2. Erstellung eines ImageGenerators.
  3. Hier wird ein Objekt mit einem fixen Wert von "blue" initialisiert und der Variable base zugewiesen.
  4. Hier wird ein Objekt mit fixen Wert von "orange" initialisiert und der Variable new_mapping zugewiesen.
  5. Hier wird das Attribut, das kontrolliert wird, definiert und der Variable attribute zugewiesen.
  6. Hier wird die Bedingung definiert und der Variable condition zugewiesen.
  7. Hier wird ein Mapping-Objekt, welches die Zuweisung von Wert zu Farbe auf Basis von der Bedingung erhält.
  8. Hier wird das Objekt filtering den Knoten des Graphen als Farbe zugewiesen. Alle Knoten mit einem Degree hoher als 0.5 orange gezeichnet und alle mit einem Degree niedriger als 0.5 den originalen Wert von blau gezeichnet.

base und new_mapping kann jeder Art von Mapping sein.

Perzentile
G = nx.Graph() # (1)
G.add_node("a")
G.add_node("b")
ig = dsstools.ImageGenerator(graph) # (2)

base = fixed("blue") # (3)
new_mapping = fixed("orange") # (4)
attribute = "degree" # (5)

percentile = percentile(base, new_mapping, attribute, perc_range=(0,50)) # (6)


ig.nodes.set_colors(percentile) # (7)
  1. Erstellung eines einfachen Graphens.
  2. Erstellung eines ImageGenerators.
  3. Hier wird ein Objekt mit einem fixen Wert von "blue" initialisiert und der Variable base zugewiesen.
  4. Hier wird ein Objekt mit fixen Wert von "orange" initialisiert und der Variable new_mapping zugewiesen.
  5. Hier wird das Attribut, das kontrolliert wird, definiert und der Variable attribute zugewiesen.
  6. Hier wird ein Mapping-Objekt, welches die Zuweisung von Wert zu Farbe auf Basis von der Bedingung erhält. Darüber hinaus wird mit perc_range das percentile range definiert
  7. Hier wird das Objekt percentile den Knoten des Graphen als Farbe zugewiesen. Alle Knoten mit einem Degree mit der Percentile außerhalb der Percentile range orange gezeichnet und alle Attribute mit einem Wert innerhalb der Percentile Range den originalen Wert von blau gezeichnet.

base und new_mapping kann jeder Art von Mapping sein.

From Node

Es gibt drei Möglichkeiten für das source Paramater von from_node Mapping, welche als String übergeben werden:

  • "incoming": Übernimmt den Wert des Startknotens zum Kanten.
  • "outgoing": Übernimmt den Wert des Endknotens zum Kanten.
  • "matching": Übernimmt den Wert von den Start- und Endknoten zum Kanten, falls sie gleich sind. Ansonsten wird der fallback Wert übernommen. Der Parameter fallback ist nur für das Keyword matching nötig.

Angehängt ist ein Beispiel für "matching": 

G = nx.Graph() # (1)
G.add_node("a")
G.add_node("b")
G.add_edge(a,b)
ig = dsstools.ImageGenerator(graph) # (2)

ig.nodes.set_colors("degree", cmap="viridis") # (3)

from_node = from_node(ig.nodes.colors, "matching", fallback= "red") # (4)

ig.edges.set_colors(from_node) # (5)

  1. Erstellung eines einfachen Graphens.
  2. Erstellung eines ImageGenerators.
  3. Hier wird ein Mapping-Objekt für die Farben der Knoten auf Basis von der "degree" erstellt.
  4. Hier wird ein Mapping-Objekt für die Farben von Kanten initialisiert und der Variable from_node zugewiesen.
  5. Hier wird das Objekt from_node den Knoten des Graphen als Farbe zugewiesen. Alle Kanten, deren Start- und Endknoten den gleichen Wert haben, erhalten diesen, ansonsten erhalten sie den fallback Wert.