Artificial Intelligence (AI)

Circular Data Visualization in Python for Beginners

Written by smirow

Einführung

Künstliche Intelligenz revolutioniert verschiedene Bereiche wie Vernetzung, multidimensionales Data Mining, Genomik und Sensordatenanalyse und erhöht dadurch die Nachfrage nach fortschrittlichen Datenvisualisierungstools. R, bekannt für seine robusten Visualisierungsfähigkeiten, insbesondere in Kreisdiagrammen, hat in dieser Hinsicht eine wichtige Rolle gespielt. Pythons Visualisierungsbibliotheken wie Matplotlib und Seaborn sind zwar leistungsstark, verfügen jedoch nicht über spezifische Funktionen für die zirkuläre Datenvisualisierung. Die Entwickler waren sich dieser Lücke bewusst und entwickelten pycirclize, inspiriert von R. circlize Und RCircosBietet Python-Benutzern ein spezielles Tool für komplexe kreisförmige Visualisierungen.

Diese Bibliothek erweitert das Datenanalyse-Toolkit von Python und ermöglicht es Benutzern, komplexe Beziehungen und Muster besser zu verstehen und ihre Ergebnisse klarer und wirkungsvoller darzustellen. Die Motivation dahinter pycirclize ist wahrscheinlich auf den wachsenden Trend des Übergangs von R zu Python zurückzuführen, der in anderen Bibliotheken zu beobachten ist.

Anwendungen der zirkulären Datenvisualisierung

Python-Benutzer haben jetzt Zugriff auf die zirkuläre Visualisierung, ein Bereich, der historisch von R dominiert wurde pycirclize. Diese neue Bibliothek erweitert die Python-Visualisierungslandschaft und ermöglicht die Erstellung komplexer Diagramme, die bisher schwierig waren. pycirclize bietet einen neuen und aufschlussreichen Ansatz zur Datenvisualisierung und -analyse, sei es zum Verständnis mehrdimensionaler Datensätze, zur Analyse der Nuancen des Netzwerkverkehrs oder zur Entschlüsselung genomischer Sequenzen.

Die zirkuläre Visualisierung erweist sich für Large Language Model (LLM)-Vektordatenbanken als vorteilhaft, da sie die Darstellung hochdimensionaler Vektorräume in einem verständlicheren zweidimensionalen Format vereinfacht. Es hilft bei der Darstellung von Beziehungen und Gruppierungen innerhalb von Vektordaten und erleichtert so die visuelle Erkundung von Beziehungen zwischen verschiedenen Vektoren wie Wörtern, Sätzen oder Dokumenten.

Die Nutzung der KI-Generierung zur Analyse und Interpretation komplexer Datensätze, einschließlich solcher, die zirkulär visualisiert werden, ist vielversprechend. KI kann Muster oder Cluster in kreisförmigen Visualisierungen von Vektordatenbanken oder Genomdaten identifizieren und so das Verständnis und die Erkenntnisse aus diesen Bildern bereichern.

Diese Weiterentwicklung erweitert nicht nur die analytischen Fähigkeiten von Python-Enthusiasten, sondern fördert auch eine umfassendere und anpassungsfähigere Visualisierungsumgebung und schließt die Lücke zwischen den etablierten Stärken von Python und R in der Datenvisualisierung.

Anwendungen der zirkulären Datenvisualisierung

Wo können wir komplexe zirkuläre Datenvisualisierung einsetzen?

pycirclize kann, wie circlize in R, verschiedene Datentypen in kreisförmigen Diagrammen anzeigen. Hier sind gängige Datenformate:

  • Genomische Daten: Wird häufig zum Vergleich von Genexpressionen, Mutationen usw. verwendet. zwischen Proben.
  • Netzwerkdaten: Effektiv zur Visualisierung von Beziehungen oder Interaktionen, insbesondere mit Akkorddiagrammen. Die Stanford Large Network Dataset Collection (SNAP) stellt Daten für die Erstellung kreisförmiger Visualisierungen bereit.
  • Vergleichsdaten: Nützlich für den Vergleich von Entitäten über mehrere Metriken hinweg, z. B. Verkaufs- oder Leistungsmetriken.
  • Zeitreihendaten: Kann Muster im Zeitverlauf kreativ darstellen, insbesondere für saisonale Daten.
  • Mehrdimensionale Daten: Kann Daten mit mehreren Messungen in verschiedenen Kategorien darstellen. Kreisförmige Heatmaps können verwendet werden, um Interaktionen zwischen Variablen darzustellen.

Daten für die Visualisierung vorbereiten

Vor der Verwendung von Datenquellen ist es wichtig, eine ordnungsgemäße Datenbereinigung und -strukturierung sicherzustellen. Dies kann Normalisierung, den Umgang mit fehlenden Werten oder das Aggregieren von Datenpunkten umfassen, um Visualisierungen informativ und aussagekräftig zu machen.

#for pip installation 
pip install pycirclize


#Conda Installation
conda install -c conda-forge pycirclize
#import csv

Ähnlich wie das R-Paket verwendet pyCirclize ein kreisförmiges Layout-Design mit Sektoren und Spuren. Jeder Sektor kann einen anderen Datensatz haben und jeder Sektor kann eine unbegrenzte Anzahl von Spuren zur Datenvisualisierung haben.

Sektoren und Spuren in Pycirclize verstehen

Jeder Sektor im „Pycirclize“-Paket stellt eine Unterteilung auf dem Umfang des Kreises dar, während sich die „Sektoren“ in den Daten auf verschiedene Kategorien oder Gruppierungen beziehen. In jedem Sektor, in dem Daten angezeigt werden, gibt es konzentrische Ringe, sogenannte „Spuren“, die die Darstellung zahlreicher Informationsebenen ermöglichen.

Wir verstehen den Sektor und das Gleis und später werden wir die Datenbank verwenden und sehen, wie Sektoren und Gleise verwendet werden können.

from pycirclize import Circos
# Initialize circos sectors
sectors = {"cat A": 15, "Cat B": 15, "Cat C": 12, "Cat D": 20, "Cat E": 10}
circos = Circos(sectors, space=6) #space =6, the space between each sector
for sector in circos.sectors:
   # Plot sector axis & name text
   sector.axis(fc="pink", ls="dashdot", lw=2, ec="green", alpha=0.5, )
   sector.text(f"Sector: {sector.name}={sector.size}", size=12) #size of the text on figure


fig = circos.plotfig()
#import csv
Sektoren und Spuren in Pycirclize verstehen

Titel in der Ciclize-Bibliothek

Die Spuren sind konzentrische Ringe innerhalb des Kreises, die jeweils einen anderen Aspekt oder eine andere Messung der Daten anzeigen. Sektoren bieten eine Aufschlüsselung nach Kategorien, während Tracks Ebenen mit Datendetails bieten, die eine facettenreiche Ansicht des gesamten Datensatzes in einem einzigen, zusammenhängenden kreisförmigen Diagramm ermöglichen.

Spuren definieren

Sie können Spuren innerhalb des Sektorradiusbereichs (0 – 100) frei platzieren.

from pycirclize import Circos


# Initialize circos sectors
sectors = {"cat A": 15, "Cat B": 15, "Cat C": 12, "Cat D": 20, "Cat E": 10}
circos = Circos(sectors, space=5)


for sector in circos.sectors:
   # Plot sector axis & name text
   sector.axis(fc="none", ls="dashed", lw=2, ec="Blue", alpha=0.3)
   sector.text(f"{sector.name}={sector.size}", size=10)
   # Set Track01 (Radius: 80 - 100)
   track1 = sector.add_track((80, 100))
   track1.axis(fc="red", alpha=0.2)
   track1.text(track1.name)
 # as you can see the track radius is kept from 80 to 100 and then 
# next track is kept at 75 so that there is a gap of 5 between the tracks
# we can reduce or increase it, as done in the next tracks
   # Set Track02 (Radius: 50 - 75)
   track2 = sector.add_track((50, 75))
   track2.axis(fc="cyan", alpha=0.2)
   track2.text(track2.name)
   # Set Track03 (Radius: 20 - 45)
   track3 = sector.add_track((20, 48))
   track3.axis(fc="lime", alpha=0.2)
   track3.text(track3.name)
   #Set Track04 (Radius 5 -15)
   track4 = sector.add_track((5, 15))
   track4.axis(fc="yellow", alpha=0.2)
   track4.text(track4.name)
fig = circos.plotfig()
#import csv
Titel in der Ciclize-Bibliothek

Wie Sie sehen, ähneln die Grundeinstellungen denen von matplotlib und seaborn, zum Beispiel: linestyle, fc, Alpha usw. Sie müssen jedoch das Circos-Objekt zum Konfigurieren von Spuren und Sektoren initialisieren.

Kombinieren Sie Sektor und Spur sowie andere Datenvisualisierungsdiagramme

from pycirclize import Circos
import numpy as np
np.random.seed(0)

sectors = {"A": 10, "B": 15, "C": 12, "D": 20, "E": 15} 
circos = Circos(sectors, space=5) #initilaise 
for sector in circos.sectors:
   # Plot sector name
   sector.text(f"Sector {sector.name}", r=106, size=12) 
   # r = 106 place #the text, if we change the value the texts move 
   # Create x positions & randomized y values for data plotting
   x = np.arange(sector.start, sector.end) + 0.5 
   #sector.start 
   #is 0 and ends at the value of sector defined ,for a it is 10, B is 15 
   y = np.random.randint(0, 100, len(x))
   # Plot line
   line_track = sector.add_track((75, 100), r_pad_ratio=0.1)
   line_track.axis(fc="yellow")
   line_track.xticks_by_interval(1)
   line_track.line(x, y)
   # Plot points
   points_track = sector.add_track((45, 70), r_pad_ratio=0.1)
   points_track.axis(fc)
   points_track.scatter(x, y)
   # Plot bar
   bar_track = sector.add_track((15, 40), r_pad_ratio=0.1)
   bar_track.axis()
   bar_track.bar(x, y)

fig = circos.plotfig()
#import csv
Kombinieren Sie Sektor und Spur sowie andere Datenvisualisierungsdiagramme

Plots der Zirkus-Klasse

Achse, Text, Rechteck, Linie

from pycirclize import Circos
import math


sectors = {"A": 10, "B": 20, "C": 15}
circos = Circos(sectors, end=270, space=10) #end angle 
circos.axis(fc="lightgrey", ec="red") #ec is edge color
circos.line(r=80, deg_lim=(0, 270), color="red") #line circular 
circos.line(r=60, deg_lim=(90, 360), color="blue", lw=3, ls="dotted")
circos.text("center") #represent text on the chart 
circos.text("right-middle", r=50, deg=90) # r is radius with degree 
circos.text("bottom", r=100, deg=180)
circos.text("left", r=100, deg=270)
circos.text("left-top", r=100 * math.sqrt(2), deg=315)
circos.rect(r_lim=(30, 50), deg_lim=(90, 360), fc="lime", 
ec="grey", lw=2, hatch="//") # rectangular Fill
circos.rect(r_lim=(30, 100), deg_lim=(0, 90), fc="orange", alpha=0.2)
fig = circos.plotfig()
#import csv
Achse, Text, Rechteck, Linie

Verbindungsdiagramme sind unerlässlich, um Verbindungen oder Verbindungen zwischen verschiedenen Datenpunkten oder Entitäten in kreisförmigen Visualisierungen anzuzeigen, insbesondere solchen, die mit den R-Paketen Circos und Circlize erstellt wurden. Diese sind besonders nützlich in Bereichen wie Genomik, Netzwerken und allen anderen Bereichen, in denen Verbindungen zwischen verschiedenen Segmenten hervorgehoben werden müssen. In der Genomik können sie zur Veranschaulichung von Interaktionen zwischen Genen oder Genombereichen eingesetzt werden. Verbindungsdiagramme sind eine großartige Möglichkeit, die Art, Stärke und Häufigkeit von Beziehungen auszudrücken, indem Punkte in einem kreisförmigen Diagramm visuell verbunden werden. Dies macht die komplexen relationalen Daten, die sie darstellen, leicht verständlich.

Nehmen wir an, wir haben Netzwerkdaten, die so aussehen.

import pandas as pd


net_df = pd.DataFrame({
   "Connection_from": ["A", "A", "A", "B", "B", "C", "C"],
   "val_1": [0, 1, 9, 5, 18, 1, 11.5],
   "val_2": [0, 2, 10, 7, 16, 3, 14],
   "connection_to": ["A", "A", "B", "C", "B", "B", "A"],
   "val_3": [7, 7, 4, 6, 11, 2, 4],
   "val_4": [8, 6, 3, 6, 13, 0, 3]
})


net_df

Der Ausgabedatenrahmen sieht so aus

Links-Diagramm

Es gibt zwei Möglichkeiten, eine Verbindung herzustellen. Lassen Sie uns zunächst statisch verstehen und die Verbindung zwischen der Verbindung von und der Verbindung nach verfolgen.

Hartcodierter Wert

from pycirclize import Circos


sectors = {"A": 10, "B": 20, "C": 15}
name2color = {"A": "red", "B": "blue", "C": "green"}
circos = Circos(sectors, space=5)
for sector in circos.sectors:
   track = sector.add_track((95, 100))
   track.axis(fc=name2color[sector.name])
   track.text(sector.name, color="black", size=12)
   track.xticks_by_interval(1)


# Plot links
circos.link(("A", 0,0), ("A", 7,8))
circos.link(("A", 1, 2), ("A", 7, 6))
circos.link(("A", 9, 10), ("B", 4, 3))
circos.link(("B", 5, 7), ("C", 6, 6))
circos.link(("B", 18, 16), ("B", 11, 13))
circos.link(("C", 1, 3), ("B", 2, 0))
circos.link(("C", 11.5, 14), ("A", 4, 3))


circos.text("Network")


fig = circos.plotfig()

Dynamisch

result = [((row['Connection_from'], row['val_1'], row['val_2']), 
(row['connection_to'], row['val_3'], row['val_4'])) for index, 
row in net_df.iterrows()]
#print(result)


sectors = {"A": 10, "B": 20, "C": 15}
name2color = {"A": "red", "B": "blue", "C": "green"}
circos = Circos(sectors, space=5)


for sector in circos.sectors:
   track = sector.add_track((95, 100))
   track.axis(fc=name2color[sector.name])
   track.text(sector.name, color="black", size=12)
   track.xticks_by_interval(1)


for link in result:
   circos.link(link[0], link[1])


circos.text("Network")


fig = circos.plotfig()

Das Ergebnis ist in beide Richtungen das gleiche:

Dynamisch

Rect und Text

Dies ist ein Beispielplot, der zum Gruppieren von Werten oder zum Anzeigen mehrdimensionaler Daten verwendet werden kann, wobei die rect(class)-Funktionalität von circos verwendet wurde.

from pycirclize import Circos
from pycirclize.utils import ColorCycler
ColorCycler.set_cmap("viridis")


sectors = {"A": 10, "B": 20, "C": 15, "D":10}
circos = Circos(sectors, space=5)
for sector in circos.sectors:
   track1 = sector.add_track((90, 100))
   track1.axis()
   # Plot rect & text (style1)
   for i in range(int(track1.size)):
       start, end = i, i + 1
       track1.rect(start, end, fc=ColorCycler())
       track1.text(str(end), (end + start) / 2)
   # Plot rect & text (style2)
   track2 = sector.add_track((65, 85))
   for i in range(int(track2.size)):
       start, end = i, i + 1
       track2.rect(start, end, fc=ColorCycler(), ec="white", lw=1)
       track2.text(str(end), (end + start) / 2, color="white", orientation="vertical")


  
   # Plot rect & text (style3)
   track3 = sector.add_track((25, 60))
   for i in range(int(track3.size)):
       start, end = i, i + 1
       track3.rect(start, end, fc=ColorCycler(), ec="white", lw=1)
       track3.text(str(end), (end + start) / 2, color="white", orientation="vertical")




circos.text("Gene-324")


fig = circos.plotfig()
Rect und Text

Circos-Feld für Genomik

In der Genomik sind Zirkusplots leistungsstarke Visualisierungswerkzeuge, die es Wissenschaftlern ermöglichen, komplexe Genomdaten in einem Kreisformat darzustellen. Diese Karten sind besonders nützlich, um Verbindungen und Kontraste zwischen verschiedenen Genomen oder zwischen verschiedenen Bereichen desselben Genoms aufzuzeigen. Sie ermöglichen eine detaillierte und komprimierte Darstellung großer Datensätze, indem sie verschiedene genomische Eigenschaften hervorheben, darunter Genexpressionen, strukturelle Veränderungen und Mutationen. Im Gegensatz zu herkömmlichen linearen Genomkarten erleichtert diese Art der Visualisierung das Erkennen von Mustern und Korrelationen.

Hier ist ein Beispiel :

from pycirclize.utils import fetch_genbank_by_accid
from pycirclize.parser import Genbank


# Download `NC_002483` E.coli plasmid genbank
gbk_fetch_data = fetch_genbank_by_accid("NC_002483")
gbk = Genbank(gbk_fetch_data)


print("Genome Length:",gbk.full_genome_length ,
 "\n___________________________________________________________\n")
print("genome sequence :",gbk.genome_seq, 
"\n___________________________________________________________\n")


print("Records :\n")


for i in gbk.records :
 print(i)
Circos-Feld für Genomik

Verfolgen Sie genomische Merkmale



# Initialize Circos instance with genome size
circos = Circos(sectors={gbk.name: gbk.range_size})
circos.text(f"Escherichia coli K-12 plasmid F\n\n{gbk.name}", size=14)
circos.rect(r_lim=(90, 100), fc="lightgrey", ec="none", alpha=0.5)
sector = circos.sectors[0]


# Plot forward strand CDS
f_cds_track = sector.add_track((95, 100))
f_cds_feats = gbk.extract_features("CDS", target_strand=1)
f_cds_track.genomic_features(f_cds_feats, plotstyle="arrow", fc="salmon", lw=0.5)


# Plot reverse strand CDS
r_cds_track = sector.add_track((90, 95))
r_cds_feats = gbk.extract_features("CDS", target_strand=-1)
r_cds_track.genomic_features(r_cds_feats, plotstyle="arrow", fc="skyblue", lw=0.5)


# Plot 'gene' qualifier label if exists
labels, label_pos_list = [], []
for feat in gbk.extract_features("CDS"):
   start = int(str(feat.location.start))
   end = int(str(feat.location.end))
   label_pos = (start + end) / 2
   gene_name = feat.qualifiers.get("gene", [None])[0]
   if gene_name is not None:
       labels.append(gene_name)
       label_pos_list.append(label_pos)
f_cds_track.xticks(label_pos_list, labels, label_size=6, label_orientation="vertical")


# Plot xticks (interval = 10 Kb)
r_cds_track.xticks_by_interval(
   10000, outer=False, label_formatter=lambda v: f"{v/1000:.1f} Kb"
)


fig = circos.plotfig()
Verfolgen Sie genomische Merkmale

Abschluss

Zusammenfassend lässt sich sagen, dass Pycirclize die Visualisierungslandschaft von Python verbessert und eine aufschlussreiche Untersuchung von Daten in verschiedenen Bereichen ermöglicht. Seine Flexibilität und Leistungsfähigkeit machen es zu einem wertvollen Werkzeug für Analysten und Forscher. Küssen pycirclize um neue Dimensionen Ihrer Datenvisualisierungsreise zu erschließen.

Weitere genomische Datenplots finden Sie hier.

About the author

smirow

Leave a Comment