Zurück zum Katalog
Scanpy Single-Cell Analysis
v1.11 — 2026 Edition. Ein umfassender Leitfaden zur Einzelzell-Analyse mit Scanpy (v1.11 - 2026). Lerne, wie man skalierbare Einzelzell-Genexpressionsdaten vorverarbeitet, visualisiert, clustert und Trajektorien ableitet.
Aktuelle Wiedergabe
Click play to start
0:00
0:00
1
Die Scanpy-Identität und AnnData
Entdecke die grundlegenden Ideen hinter Scanpy und warum es für skalierbare Einzelzell-Analysen entwickelt wurde. Wir untersuchen das AnnData-Objekt, die zentrale Datenstruktur, die Matrizen, Annotationen und Embeddings perfekt aufeinander abstimmt. Du lernst das mentale Modell kennen, das nötig ist, um dich im Scanpy-Ökosystem zurechtzufinden.
2
Qualitätskontroll-Metriken
Wir untersuchen, wie man mit Scanpy eine anfängliche Qualitätskontrolle von Einzelzell-Daten durchführt. Durch die Isolierung spezifischer Genpopulationen wie mitochondrialer RNA können wir gestresste oder sterbende Zellen identifizieren. Du lernst, wie man diese entscheidenden QC-Metriken berechnet und interpretiert.
3
Filterung und Normalisierung
Diese Episode behandelt die kritischen Schritte der Filterung und Normalisierung von Einzelzell-Expressionsmatrizen. Wir erklären, wie man Daten von geringer Qualität verwirft und eine Skalierung der Count Depth mit einer log1p-Transformation anwendet. Du lernst, wie man Zellen mit unterschiedlichen Sequenziertiefen direkt vergleichbar macht.
4
Doubletten-Erkennung mit Scrublet
Wir tauchen in die Doubletten-Erkennung ein, einen entscheidenden Schritt, um technische Artefakte in der mikrofluidischen Einzelzell-Sequenzierung aufzuspüren. Wir schlüsseln auf, wie Scrublet künstliche Doubletten simuliert, um verdächtige Zellen zu markieren. Du lernst, wie du diese künstlichen Kombinationen in deinem Datensatz identifizierst und entfernst.
5
Feature Selection und hochvariable Gene
Wir untersuchen das Konzept der Feature Selection und warum es notwendig ist, hochvariable Gene zu identifizieren. Indem wir das Rauschen von Housekeeping-Genen verwerfen, konzentrieren wir die Analyse auf biologische Treiber. Du lernst, wie du Scanpy nutzt, um die informativsten Gene für nachfolgende Schritte zu isolieren.
6
Cell-Cycle Scoring und Regression
Wir untersuchen, wie man mit Störfaktoren umgeht, indem man Zellzyklusphasen bewertet und durch Regression entfernt. Wir besprechen, wie man S- und G2M-Scores berechnet und Regression nutzt, um ihren Einfluss zu beseitigen. Du lernst, wie du verhinderst, dass aktive Zellteilung deine Clustering-Topologie ruiniert.
7
Dimensionalitätsreduktion mit PCA
Diese Episode erklärt die Principal Component Analysis im Kontext von Einzelzell-Daten. Wir besprechen, wie PCA den Datensatz entrauscht und warum die Auswahl der richtigen Anzahl von Komponenten wichtig ist. Du lernst, wie du Tausende von Genen auf eine handhabbare Basis für fortgeschrittene Algorithmen reduzierst.
8
Der Nearest Neighbor Graph und UMAP
Wir schlüsseln den absoluten Kern der modernen Einzelzell-Topologie auf: den Nearest Neighbor Graph. Anschließend erklären wir, wie UMAP dieses komplexe Netz in einen lesbaren 2D-Plot übersetzt. Du lernst, warum der Neighbor Graph die Voraussetzung für fast jedes fortgeschrittene Tool in Scanpy ist.
9
Clustering mit Leiden
Wir untersuchen, wie man mit dem Leiden-Clustering-Algorithmus diskrete Zellpopulationen findet. Durch die Optimierung der Modularität auf dem Neighborhood Graph isoliert Leiden stark vernetzte Communities. Du lernst, wie du den Resolution-Parameter anpasst, um stabile, biologisch sinnvolle Gruppen zu finden.
10
Entdeckung von Marker-Genen
Wir tauchen in die Entdeckung von Marker-Genen und differenzielle Expressionstests ein. Wir erklären, wie statistische Tests die einzigartigen transkriptomischen Signaturen deiner Cluster identifizieren. Du lernst, wie du von anonymen, nummerierten Clustern zu sicher benannten biologischen Zelltypen übergehst.
11
Datenintegration mit Ingest
Diese Episode behandelt die Datenintegration mit dem Ingest-Tool. Wir erklären, wie man neue Datensätze auf den PCA- und UMAP-Raum eines vorab annotierten Referenz-Atlas projiziert. Du lernst eine schnelle, invariante Methode kennen, um Labels über verschiedene Experimente hinweg zuzuordnen.
12
Visualisierung von Expressionsmustern
Wir untersuchen fortgeschrittene Visualisierungstechniken zur Auswertung der Genexpression über Cluster hinweg. Wir konzentrieren uns auf Dot Plots und Matrix Plots und erklären im Detail, wie sie sowohl Expressionsintensität als auch Sparsity kodieren. Du lernst, wie du deine Zelltyp-Annotationen auf einen Blick visuell validieren kannst.
13
Erkundung von Manifolds mit Diffusion Maps
Wir stellen Diffusion Maps vor, eine leistungsstarke Embedding-Technik für kontinuierliche biologische Daten. Wir stellen sie UMAP gegenüber und erklären, warum Diffusion besser für die Analyse der zellulären Differenzierung geeignet ist. Du lernst, wie man kontinuierliche Übergänge und Entwicklungsprozesse visualisiert.
14
Abstrahierte Graphen mit PAGA
Diese Episode behandelt Partition-based Graph Abstraction, kurz PAGA. Wir besprechen, wie man die tatsächliche Konnektivität zwischen Clustern misst, um die globale Topologie zu erhalten. Du lernst, wie du PAGA nutzt, um die wahren Abstammungsverhältnisse aufzudecken, die in deinen Daten verborgen sind.
15
Trajectory Inference mit DPT
Wir untersuchen Trajectory Inference mithilfe von Diffusion Pseudotime (DPT). Wir erklären, wie man eine Wurzelzelle bestimmt und geodätische Distanzen über den zellulären Graphen berechnet. Du lernst, wie man Zellen entlang einer kontinuierlichen Entwicklungszeitachse anordnet.
16
Experimentelles Scale-Up mit Dask
In unserer letzten Episode betrachten wir die experimentelle Grenze von Scanpy: das Skalieren mit Dask. Wir erklären, wie man Datensätze, die den Arbeitsspeicher deines Rechners übersteigen, mithilfe von Lazy Evaluation und Out-of-Core-Verarbeitung handhabt. Danke, dass du uns auf diesem Deep Dive in Scanpy begleitet hast!
Episoden
1
Die Scanpy-Identität und AnnData
4m 17sEntdecke die grundlegenden Ideen hinter Scanpy und warum es für skalierbare Einzelzell-Analysen entwickelt wurde. Wir untersuchen das AnnData-Objekt, die zentrale Datenstruktur, die Matrizen, Annotationen und Embeddings perfekt aufeinander abstimmt. Du lernst das mentale Modell kennen, das nötig ist, um dich im Scanpy-Ökosystem zurechtzufinden.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 1 von 16. Single-Cell Datasets sind innerhalb weniger Jahre von Tausenden auf Millionen von Zellen explodiert. Versuch mal, diese Datenmenge in ältere, speicherintensive Toolkits zu laden, und dein Rechner wird in die Knie gehen. Genau dieses Problem löst Scanpy.
Scanpy ist ein skalierbares Toolkit, das gebaut wurde, um massive Single-Cell Gene Expression Datasets in Python zu analysieren. Es geht effizient mit dem Speicher um, indem es sich auf eine hochspezifische, grundlegende Datenstruktur stützt. Diese Struktur heißt Annotated Data, oder AnnData.
Leute, die von Standard-Tabellendaten kommen, nehmen oft an, AnnData sei einfach nur ein angepasster pandas Dataframe. Ist es aber nicht. Ein einzelner Dataframe ist für die Single-Cell-Biologie viel zu flach. Bei einem Single-Cell-Experiment hast du eine riesige Matrix mit Expression Counts, aber du hast auch komplexe Metadaten über die Zellen und komplett separate Metadaten über die Gene. AnnData ist ein multidimensionaler Container, der die Core-Matrix und alle zugehörigen Metadaten eng in einem synchronisierten Objekt zusammenbindet.
Stell dir ein Szenario vor, in dem du ein Dataset mit einer Million Zellen lädst. Im Zentrum deines AnnData-Objekts sitzt die Core-Data-Matrix, auf die du über das dot X Attribut zugreifst. Das ist eine zweidimensionale Matrix, die deine eigentlichen numerischen Werte enthält, typischerweise Gene Expression Counts. Die Zeilen repräsentieren immer Observations, also deine einzelnen Zellen, und die Spalten repräsentieren immer Variables, also deine Gene. Bei einem Dataset mit einer Million Zellen wird dot X fast immer als Sparse Matrix gespeichert, um RAM zu sparen.
Hier ist die entscheidende Erkenntnis. Die Matrix in dot X speichert keine eigenen Zeilen- oder Spaltennamen. Sie verlässt sich komplett auf zwei dedizierte Metadaten-Dataframes, um diesen Kontext zu liefern.
Das erste sind die Observation-Metadaten, auf die du über das dot obs Attribut zugreifst. Das ist ein Standard-pandas-Dataframe, der direkt auf die Zeilen deiner dot X Matrix gemappt ist. Er enthält alles, was du über die Zellen weißt. Für dein Dataset mit einer Million Zellen wird dot obs exakt eine Million Zeilen haben. Hier leben deine Cell Barcodes, Batch Labels, Quality Control Metrics und Clustering Assignments.
Das zweite sind die Variable-Metadaten, auf die du über das dot var Attribut zugreifst. Das ist ein weiterer Dataframe, der direkt auf die Spalten deiner dot X Matrix gemappt ist. Er enthält alles, was du über die Gene oder Features weißt, die du gemessen hast. Hier speicherst du Gene Symbols, Chromosome Locations und statistische Metriken wie Highly Variable Gene Flags.
Weil dot obs und dot var strikt an den Dimensionen von dot X ausgerichtet sind, kannst du das AnnData-Objekt sicher slicen. Wenn du tote Zellen aus dot obs herausfilterst, droppt das AnnData-Objekt automatisch die entsprechenden Zeilen aus der dot X Matrix. Das Dimensional Alignment bricht nie.
Es gibt noch einen weiteren entscheidenden Layer in der AnnData-Struktur. Wenn du deine Single-Cell-Daten verarbeitest, generierst du multidimensionale Repräsentationen deiner Zellen, wie Principal Components oder UMAP-Koordinaten. Diese Outputs passen nicht sauber in eine einzelne Spalte von dot obs. Stattdessen kommen sie in ein separates Dictionary namens dot obsm, was für Observation Matrices steht. Die einzige Regel ist, dass jede Matrix, die du in dot obsm ablegst, exakt dieselbe Anzahl an Zeilen haben muss wie dot X.
Dadurch, dass die Core-Matrix, die Cell-Metadaten und die Gene-Metadaten in einer sich selbst aktualisierenden Struktur fest miteinander verbunden bleiben, garantiert AnnData, dass deine Daten vom ersten Filtering-Step bis zur finalen Visualisierung perfekt synchronisiert bleiben.
Wenn du diese Episoden hilfreich findest, kannst du die Show unterstützen, indem du auf Patreon nach DevStoriesEU suchst. Wie immer, danke fürs Zuhören. Wir sehen uns in der nächsten Episode.
2
Qualitätskontroll-Metriken
3m 37sWir untersuchen, wie man mit Scanpy eine anfängliche Qualitätskontrolle von Einzelzell-Daten durchführt. Durch die Isolierung spezifischer Genpopulationen wie mitochondrialer RNA können wir gestresste oder sterbende Zellen identifizieren. Du lernst, wie man diese entscheidenden QC-Metriken berechnet und interpretiert.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 2 von 16. Der schnellste Weg, eine Single-Cell Analysis zu ruinieren, ist, unwissentlich absterbende oder leere Zellen im Dataset zu belassen. Du denkst vielleicht, du entdeckst eine neue Subpopulation, aber eigentlich clusterst du nur Zelltrümmer. Das Aufspüren dieser beschädigten Zellen hängt komplett von Quality Control Metrics ab.
Lass uns gleich mal etwas klarstellen. Oft verwechseln Leute das Berechnen von Quality Metrics mit dem Herausfiltern von schlechten Daten. Das ist nicht dasselbe. Die Scanpy-Funktion calculate qc metrics entfernt keine einzige Zelle und kein einziges Gen aus deinem Dataset. Sie ist ein reines Annotation Tool. Sie berechnet Statistiken und hängt sie als neue Columns an dein Observation Dataframe, das die Zellen trackt, und an dein Variable Dataframe, das die Gene trackt. Das eigentliche Entfernen der schlechten Zellen passiert in einem separaten Schritt.
Warum brauchen wir diese spezifischen Metrics? Stell dir eine Knochenmarkprobe vor. Bei der Extraktion kann physischer Stress empfindliche Zellen aufreißen. Wenn die Zellmembran reißt, tritt die zytoplasmatische RNA aus und wird weggespült. Mitochondrien haben jedoch ihre eigenen Membranen, sodass die mitochondriale RNA in der kaputten Zellhülle gefangen bleibt. Wenn du dieses Droplet sequenzierst, bekommst du eine hohe Konzentration an mitochondrialen Genen und sonst fast nichts. Das ist eine tote Zelle.
Um diese kaputten Zellen zu identifizieren, musst du spezifische Gen-Populationen tracken. In menschlichen Datasets beginnen mitochondriale Gene normalerweise mit dem Prefix MT-Bindestrich. Ribosomale Gene fangen vielleicht mit RPS oder RPL an. Bevor du Metrics für diese Populationen berechnen kannst, musst du sie in deinem Dataset labeln. Das machst du, indem du eine neue Boolean Column in deinem var Dataframe erstellst. Zum Beispiel erstellst du eine Column namens mt, die auf True evaluiert, wenn der Gen-Name mit MT-Bindestrich beginnt, und ansonsten auf False.
Sobald du diese Gene geflaggt hast, führst du die calculate qc metrics Funktion aus. Standardmäßig berechnet diese Funktion Standard-Baseline-Statistiken, wie die Gesamtzahl der RNA Counts pro Zelle und die Anzahl der exprimierten Gene pro Zelle. Aber du kannst ihr auch sagen, dass sie sich die spezifischen Gen-Populationen ansehen soll, die du gerade definiert hast. Dafür übergibst du den Namen deiner Boolean Column, wie mt, an das qc vars Argument.
Die Funktion berechnet dann den Anteil der Counts, der von dieser spezifischen Gen-Gruppe stammt. Sie fügt deinem obs Dataframe neue Columns hinzu. Eine Column zeigt die gesamten Counts der mitochondrialen Gene für jede Zelle. Eine andere, wichtigere Column zeigt den prozentualen Anteil der gesamten Counts, der von mitochondrialen Genen kommt. Wenn eine Zelle zeigt, dass dreißig Prozent ihrer RNA mitochondrial sind, weißt du, dass es sich wahrscheinlich um eine aufgerissene, absterbende Zelle aus dem Extraktionsprozess handelt.
Hier ist die wichtigste Erkenntnis. Die calculate qc metrics Funktion verwandelt rohe, nicht interpretierbare Count Matrices in biologische Signale über die Zellgesundheit. Sie trifft keine Entscheidungen für dich, aber durch das Taggen spezifischer Gen-Populationen liefert sie dir die exakten numerischen Beweise, die du brauchst, um echte Biologie von Extraction Noise zu trennen.
Danke, dass du ein paar Minuten mit mir verbracht hast. Bis zum nächsten Mal, mach's gut.
3
Filterung und Normalisierung
3m 55sDiese Episode behandelt die kritischen Schritte der Filterung und Normalisierung von Einzelzell-Expressionsmatrizen. Wir erklären, wie man Daten von geringer Qualität verwirft und eine Skalierung der Count Depth mit einer log1p-Transformation anwendet. Du lernst, wie man Zellen mit unterschiedlichen Sequenziertiefen direkt vergleichbar macht.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 3 von 16. Du schaust dir zwei Zellen in deinem Dataset an. Eine scheint doppelt so viel RNA zu exprimieren wie die andere. Aber das ist kein biologischer Unterschied – ein Droplet wurde von der Maschine einfach doppelt so tief sequenziert. Wenn du sie direkt vergleichst, wird deine gesamte Downstream Analysis durch technische Artefakte verfälscht. Filtering und Normalization sind die Tools, die diese Diskrepanz beheben.
Bevor du die Sequencing Depth anpassen kannst, musst du den Müll entfernen. Rohe Single-Cell-Daten sind voll von toten Zellen, leeren Droplets und zufälligem Noise. Du bereinigst das entlang zweier verschiedener Achsen: den Zellen und den Genen. Manchmal verwechselt man diese beiden Schritte, aber sie machen komplett unterschiedliche Dinge. Du kümmerst dich zuerst um die Zellen mit der filter cells Funktion. Du sagst Scanpy, dass es jede Zelle verwerfen soll, die weniger als eine Mindestanzahl an Genen exprimiert. Wenn ein Droplet nur zweihundert detektierte Gene enthält, obwohl eine gesunde Zelle zweitausend haben sollte, ist dieses Droplet wahrscheinlich leer oder enthält eine kaputte, sterbende Zelle. Du dropst es komplett.
Als Nächstes filterst du die Gene in deinem gesamten Dataset. Mit der filter genes Funktion entfernst du Gene, die in zu wenigen Zellen exprimiert werden. Wenn ein bestimmtes Gen nur in ein oder zwei von zehntausend Zellen detektiert wird, bietet es später keinen statistischen Mehrwert für das Gruppieren oder Klassifizieren von Zelltypen. Es ist einfach nur computational Noise. Du dropst dieses Gen komplett.
Sobald die Low-Quality-Zellen und uninformativen Gene weg sind, hast du immer noch das Problem mit der Sequencing Depth. An diesem Punkt normalisierst du die Total Counts. Das Ziel ist es, jede Zelle so zu skalieren, dass sie alle scheinbar die gleiche Gesamtzahl an Read Counts haben. Stell dir ein Szenario vor, in dem Zelle A fünftausend Total Counts hat und Zelle B zwanzigtausend. Du wählst einen gemeinsamen Size Factor, typischerweise zehntausend. Scanpy wendet auf jede Zelle einzeln einen Scaling Factor an. Es verdoppelt die Counts in Zelle A und halbiert die Counts in Zelle B. Jetzt summieren sich beide Zellen auf zehntausend Total Counts. Wenn du dir ein bestimmtes Gen in beiden Zellen ansiehst, vergleichst du ihre wahre relative Expression, völlig unabhängig davon, wie stark die Sequencing-Maschine sie gesampelt hat.
Die Totals gleichzumachen, ist nur die halbe Mathematik. Biologische Expression-Daten sind massiv skewed. Eine Handvoll Gene wird enorme Count-Zahlen haben, während die meisten nur sehr wenige haben. Wenn du diese skewed Daten später in Variance Calculations oder Dimensionality Reduction Algorithmen fütterst, werden diese wenigen massiven Gene die Mathematik dominieren und subtile biologische Signale übertönen. Du fixt das mit einer log plus one Transformation. Du rufst die log one p Funktion in Scanpy auf, die einen natürlichen Logarithmus auf all deine Normalized Counts anwendet. Der plus one Teil der Funktion ist extrem wichtig, weil deine Data Matrix größtenteils aus Nullen besteht, die Gene repräsentieren, die in einer bestimmten Zelle nicht exprimiert werden. Der Logarithmus von null ist undefiniert, aber der Logarithmus von null plus eins ist null. Dieser einfache Schritt komprimiert die extrem hohen Werte, während die Nullen genau da bleiben, wo sie sind, was zu einer viel balancierteren Verteilung führt.
Hier ist die wichtigste Erkenntnis. Filtering und Normalization verändern nicht die zugrundeliegende Biologie deines Samples. Sie entfernen die mechanischen Biases der Sequencing-Hardware, damit die eigentliche Biologie zum Vorschein kommen kann. Danke fürs Zuhören, happy coding zusammen!
4
Doubletten-Erkennung mit Scrublet
3m 58sWir tauchen in die Doubletten-Erkennung ein, einen entscheidenden Schritt, um technische Artefakte in der mikrofluidischen Einzelzell-Sequenzierung aufzuspüren. Wir schlüsseln auf, wie Scrublet künstliche Doubletten simuliert, um verdächtige Zellen zu markieren. Du lernst, wie du diese künstlichen Kombinationen in deinem Datensatz identifizierst und entfernst.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 4 von 16. Manchmal werden zwei völlig unterschiedliche Zellen im selben mikrofluidischen Droplet eingeschlossen. Dadurch entsteht eine Art Frankenstein-Transkriptom-Signatur, die wie ein völlig neuer biologischer Zustand aussieht. Das ist keine Entdeckung. Es ist ein Fehler, und wenn du ihn nicht frühzeitig erkennst, wird er deine Analyse kontaminieren. Genau dieses Problem soll die Doublet Detection mit Scrublet lösen.
Wenn du ein Single-Cell-Experiment mit Droplet Microfluidics durchführst, drückst du eine Zellsuspension durch einen Kanal, mit dem Ziel: eine Zelle pro Droplet. Statistisch gesehen ist dieser Prozess nicht perfekt. Gelegentlich teilen sich zwei Zellen ein einziges Droplet. Stell dir ein Szenario vor, in dem ein Monozyt und eine T-Zelle gemeinsam eingeschlossen werden. Das Sequenziergerät liest ihre kombinierte RNA als eine einzige Entität und gibt ein Profil aus, das Gene beider Zelltypen vermischt. Oft hält man diese gemischten Profile fälschlicherweise für echte biologische Übergangszustände, wie eine Zelle mitten in der Differenzierung. Wir müssen hier völlig klar sein: Doublets sind rein technische Artefakte. Sie existieren nicht im Gewebe und müssen entfernt werden.
In Scanpy machst du das mit der Scrublet-Funktion im Preprocessing-Modul. Scrublet basiert auf einer sehr effektiven Prämisse, um diese Fake-Zellen zu finden. Wenn du Doublets erkennen willst, musst du wissen, wie ein Doublet in deinem spezifischen Dataset aussieht. Da der Algorithmus nicht weiß, welche deiner beobachteten Zellen Fehler sind, erzeugt er seine eigenen.
Zuerst nimmt Scrublet die Expression Matrix deiner beobachteten Zellen. Dann wählt es zufällig Paare dieser echten Zellen aus und addiert ihre Gene Expression Profiles rechnerisch zusammen. Diese kombinierten Profile sind deine simulierten Doublets. Nun mappt Scrublet sowohl deine tatsächlich beobachteten Zellen als auch diese neu simulierten Doublets in denselben High-Dimensional Space. Es baut einen Nearest-Neighbor Classifier, um die Beziehungen zwischen ihnen zu analysieren.
Das ist der entscheidende Punkt. Scrublet bewertet die unmittelbare Nachbarschaft jeder echten Zelle in deinem Dataset. Wenn eine beobachtete Zelle hauptsächlich von simulierten Doublets umgeben ist, sieht diese echte Zelle mathematisch identisch mit einem künstlichen Mashup aus. Scrublet weist ihr einen hohen Doublet Score zu. Sitzt eine beobachtete Zelle hingegen in einem Cluster mit anderen echten Zellen und nur sehr wenigen simulierten Doublets, erhält sie einen niedrigen Score. Es ist dann höchstwahrscheinlich eine echte Single Cell.
Die Funktion hört nicht bei der Vergabe eines kontinuierlichen Scores auf. Sie wertet die Verteilung aller Doublet Scores in deinem Dataset aus, um automatisch einen Cutoff Threshold zu berechnen. Sie sucht nach einer Trennung zwischen dem großen Peak normaler Zellen und dem kleineren Tail vermuteter Doublets. Basierend auf diesem Threshold taggt Scrublet jede Zelle in deinem Dataset mit einem Boolean Value: true, wenn es ein Predicted Doublet ist, und false, wenn es ein Singlet ist. Diese Ergebnisse werden direkt in deinem Data Object gespeichert, sodass du die falschen Zellen herausfiltern kannst, bevor du zur Downstream Analysis übergehst.
Die grundlegende Stärke von Scrublet ist, dass es sich nicht auf externe Reference Databases verlässt, um technische Fehler zu finden. Es lernt die genauen Failure Modes deines spezifischen Experiments, indem es genau die Zellen kombiniert, die du sequenziert hast.
Das war es für diese Folge. Danke fürs Zuhören, und keep building!
5
Feature Selection und hochvariable Gene
3m 40sWir untersuchen das Konzept der Feature Selection und warum es notwendig ist, hochvariable Gene zu identifizieren. Indem wir das Rauschen von Housekeeping-Genen verwerfen, konzentrieren wir die Analyse auf biologische Treiber. Du lernst, wie du Scanpy nutzt, um die informativsten Gene für nachfolgende Schritte zu isolieren.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 5 von 16. Von den rund 30.000 Genen im menschlichen Genom sind die meisten nur für die grundlegende Zellfunktion zuständig. Wenn du versuchst, alle gleichzeitig zu analysieren, überdeckt die schiere Menge an Basisaktivität die eigentliche Biologie, nach der du suchst. Um das echte Signal zu finden, brauchst du Feature Selection und Highly Variable Genes.
Zuerst eine kurze Unterscheidung. Du hast bereits eine einfache Filter-Funktion verwendet, um Gene zu verwerfen, die in deinem Dataset kaum nachweisbar sind. Dieser Schritt bereinigt technisches Rauschen und Empty Droplets. Die Auswahl von Highly Variable Genes macht etwas völlig anderes. Sie geht davon aus, dass die verbleibenden Gene echt sind, fragt aber, welche von ihnen tatsächlich informativ sind.
Stell es dir so vor: Zehntausende von Genen zu durchsuchen, um diejenigen zu finden, die Unterschiede zwischen Zelltypen antreiben, bedeutet, die langweiligen Housekeeping Genes auszusortieren. Ein Housekeeping Gene ist in fast jeder Zelle auf etwa demselben Level aktiv. Seine Expression ist stabil, was es unbrauchbar macht, um eine T-Zelle von einer B-Zelle zu unterscheiden. Wir wollen Gene, die in einigen Zellen stark exprimiert werden und in anderen völlig stumm sind. Das sind die Highly Variable Genes. Normalerweise willst du dein Dataset auf etwa zweitausend dieser Key Driver reduzieren.
In Scanpy machst du das mit der highly_variable_genes Funktion. Aber du kannst Gene nicht einfach nach ihrer Raw Variance ranken. In Sequenzierungsdaten skaliert die Variance mit der Mean Expression. Wenn ein Gen durch die Bank stark exprimiert wird, ist seine Raw Variance natürlich hoch, selbst wenn es biologisch nicht interessant ist. Der Algorithmus muss die Variance von der Mean Expression entkoppeln.
Das macht er, indem er die Gene basierend auf ihren Average Expression Levels in Bins einteilt. Dann berechnet er eine Normalized Dispersion innerhalb jedes Bins. Das sagt dir, wie stark ein Gen variiert, und zwar nur im Vergleich zu anderen Genen, die auf ähnlichen Baseline-Leveln exprimiert werden. Scanpy bietet verschiedene statistische Methoden für diese Berechnung, die Flavors genannt werden.
Der traditionelle Seurat Flavor erwartet, dass deine Daten zuerst log-normalized werden. Er berechnet die Dispersion, packt die Daten in Bins und standardisiert die Werte. Es gibt auch einen neueren Seurat v3 Flavor, der explizit rohe, unlogged Count-Daten erfordert, um die Variance richtig zu modellieren. Alternativ nutzt der CellRanger Flavor einen etwas anderen Ansatz, um die Normalized Dispersion basierend auf den Counts zu berechnen. Der Flavor, den du wählst, bestimmt einfach die spezifische statistische Verteilung, die genutzt wird, um diese Beziehung zwischen Mean und Variance zu modellieren.
Wenn du diese Funktion ausführst, löscht sie nicht den Rest deiner Daten. Stattdessen fügt sie deinem Variable Annotations Array ein paar neue Spalten hinzu. Die wichtigste ist eine Boolean-Spalte, die einfach highly_variable heißt. Sie markiert die Top zweitausend Gene mit true und den Rest mit false. Zukünftige Schritte in deiner Pipeline werden automatisch nach diesem Flag suchen und nur diese ausgewählten Gene für die Downstream Analysis verwenden.
Hier ist die entscheidende Erkenntnis. Feature Selection ist nicht nur ein Rechentrick, damit dein Code schneller läuft. Es ist der bewusste Prozess, biologisches White Noise zu entfernen, damit die wahren zellulären Identitäten Raum bekommen, um sichtbar zu werden.
Danke, dass du dabei warst. Ich hoffe, du hast etwas Neues mitgenommen.
6
Cell-Cycle Scoring und Regression
4m 02sWir untersuchen, wie man mit Störfaktoren umgeht, indem man Zellzyklusphasen bewertet und durch Regression entfernt. Wir besprechen, wie man S- und G2M-Scores berechnet und Regression nutzt, um ihren Einfluss zu beseitigen. Du lernst, wie du verhinderst, dass aktive Zellteilung deine Clustering-Topologie ruiniert.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 6 von 16. Dein Clustering-Algorithmus hat gerade identische T-Zellen in zwei unterschiedliche Gruppen aufgeteilt. Sie sind exakt derselbe Zelltyp, aber der Algorithmus hat sie getrennt, einfach weil sich eine Gruppe gerade aktiv teilt, während die andere ruht. Um das zu beheben, nutzen wir Cell-Cycle Scoring und Regression.
Zellzyklus-Heterogenität ist eine massive Quelle für Varianz in Single-Cell-Daten. Wenn man das nicht kontrolliert, überlagern die stark exprimierten Gene, die die Mitose antreiben, die subtilen Gen-Signaturen, die die eigentlichen Zelltypen definieren. Am Ende hast du Cluster, die durch einen temporären Zustand definiert sind, statt durch ihre wahre biologische Identität. Um das zu lösen, bietet Scanpy eine eigene Funktion für das Scoring von Genen basierend auf dem Zellzyklus.
Du übergibst dieser Funktion dein Single-Cell-Dataset zusammen mit zwei spezifischen Listen bekannter Marker-Gene. Eine Liste enthält Gene, die während der S-Phase, also der Synthesephase des Zellzyklus, aktiv sind. Die andere Liste enthält Gene, die während der G2M-Phase, der Mitosephase, aktiv sind. Die Scoring-Funktion wertet jede einzelne Zelle aus und berechnet zwei kontinuierliche Metriken: einen S-Score und einen G2M-Score. Sie macht das, indem sie schaut, wie stark diese spezifischen Phasen-Gene im Vergleich zum Background-Expression-Level der Zelle exprimiert werden. Basierend auf diesen beiden Scores weist die Funktion auch jeder Zelle in deinen Metadata ein kategoriales Phase-Label zu. Sie labelt sie als S, G2M oder G1, falls keiner der beiden Scores besonders hoch ist.
Jetzt, wo du diesen Effekt quantifiziert hast, musst du seinen Einfluss aus dem Dataset entfernen. Hier kommt die regress out-Funktion ins Spiel. Du sagst regress out, dass es sich die S-Score- und G2M-Score-Spalten ansehen soll, die gerade zu deinen Cell-Metadata hinzugefügt wurden. Der Algorithmus baut dann ein lineares Modell für die Expression jedes einzelnen Gens über alle Zellen hinweg, wobei diese beiden Zellzyklus-Scores als Predictor-Variablen genutzt werden. Er berechnet das Residual, also genau den Anteil der Gen-Expression, der nicht durch die Position der Zelle im Zellzyklus erklärt werden kann. Dieser Residual-Wert wird zum neuen, korrigierten Expression-Level in deinem Dataset.
Hier ist die entscheidende Erkenntnis. Leute verwechseln Regression oft mit Batch Correction. Es sind verwandte Konzepte, aber grundlegend unterschiedliche Tools. Batch-Correction-Methoden sind dafür gemacht, diskrete, kategoriale Gruppen anzugleichen, wie zum Beispiel Samples, die an verschiedenen Tagen gesammelt oder auf verschiedenen Maschinen sequenziert wurden. Regress out ist speziell für kontinuierliche Confounding-Variablen gedacht. Du nutzt es für kontinuierliche numerische Gradienten wie diese Zellzyklus-Scores, Total Counts pro Zelle oder den Prozentsatz an mitochondrialen Genen. Es modelliert eine mathematische Steigung und flacht sie ab.
Sobald du diesen Regression-Step ausführst, wird der starke biologische Bias der Zellteilung mathematisch aus der Expression-Matrix entfernt. Wenn du deinen Clustering-Algorithmus erneut auf diese korrigierten Daten anwendest, schnappen diese sich teilenden und ruhenden T-Zellen wieder zu einem einzigen, zusammenhängenden Cluster zusammen. Der Algorithmus wird nicht länger vom Noise der DNA-Replikation abgelenkt. Das Regressing out von Zellzyklus-Scores stellt sicher, dass deine Downstream-Analysis Zellen strikt danach clustert, was sie sind, und nicht danach, was sie im Moment der Sequenzierung zufällig gerade tun.
Das war's für diese Folge. Danke fürs Zuhören und keep building!
7
Dimensionalitätsreduktion mit PCA
3m 42sDiese Episode erklärt die Principal Component Analysis im Kontext von Einzelzell-Daten. Wir besprechen, wie PCA den Datensatz entrauscht und warum die Auswahl der richtigen Anzahl von Komponenten wichtig ist. Du lernst, wie du Tausende von Genen auf eine handhabbare Basis für fortgeschrittene Algorithmen reduzierst.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 7 von 16. Das menschliche Gehirn kann sich zweitausend Dimensionen nicht vorstellen. Schlimmer noch: Komplexe Clustering-Algorithmen werden davon rechnerisch lahmgelegt, ausgebremst durch eine Mischung aus echtem biologischen Signal und zufälligem technischen Noise. Du brauchst einen Weg, um die Kernstruktur deiner Daten vor der Analyse zu extrahieren. Dimensionality Reduction mit Principal Component Analysis ist die Lösung dafür.
Bevor wir in die Mechanik einsteigen, müssen wir ein häufiges Missverständnis ausräumen. Viele denken, PCA sei einfach nur ein Scatter Plot, der PC1 gegen PC2 plottet, gedacht als finale Visualisierung für das menschliche Auge. Ist es aber nicht. Du kannst zwar die ersten beiden Components plotten, aber PCA ist im Grunde ein mathematisches Fundament. Sie komprimiert eine sparse, noisy Matrix in ein dense Format, um sie an Downstream-Tools wie Neighbor Graphs weiterzugeben.
Denk mal an deinen Ausgangspunkt. Du hast gerade etwa zweitausend hochvariable Gene isoliert. Jedes Gen repräsentiert eine unabhängige Dimension in deinem Dataset. Du führst die scanpy tools pca Funktion aus, um die Principal Components zu berechnen. Diese Funktion evaluiert dein gesamtes Dataset und dampft diese zweitausend Gen-Dimensionen auf ein viel kleineres Set an synthetischen Dimensionen ein, typischerweise so um die fünfzig.
Diese synthetischen Dimensionen sind danach geordnet, wie viel Varianz sie erklären. Die erste Principal Component repräsentiert die absolut stärkste Variationsachse in deinen Zellen. Die zweite die nächststärkste, und so weiter. Hier ist die entscheidende Erkenntnis. Die erste Handvoll Components erfasst die echten, strukturierten biologischen Unterschiede. Je weiter du in der Liste der Components nach unten gehst, desto weniger Biologie und desto mehr zufälligen technischen Noise erfassen sie. Indem du das hintere Ende dieser Components abschneidest, machst du im Grunde ein Denoising deiner Datenmatrix.
Um diese Reduction zu evaluieren, musst du entscheiden, wie viele Components du behalten willst. Dafür nutzt du die scanpy plot pca variance ratio Funktion. Dieser Command generiert ein Line Chart, das den Anteil der Gesamtvarianz zeigt, der von jeder einzelnen Component erklärt wird. Du scannst diese Linie und suchst nach dem Elbow Point, also dem Punkt, an dem der steile Abfall plötzlich in einen langen Tail abflacht.
Wenn die Kurve bei Component 15 abflacht, nimmst du vielleicht an, dass du nur 15 Components brauchst. In Single-Cell-Workflows überschätzen wir die Anzahl der Principal Components jedoch ganz bewusst. Du siehst vielleicht den Elbow bei 15, sagst deinen Downstream-Funktionen aber trotzdem, dass sie 50 verwenden sollen. Downstream-Clustering-Algorithmen sind extrem robust. Sie können den leichten technischen Noise in den Components 16 bis 50 problemlos ignorieren. Was sie nicht können, ist ein biologisches Signal wiederherzustellen, das du zu früh weggeworfen hast. Wenn Component 22 die Varianz-Signatur für einen sehr seltenen Zelltyp enthält, bedeutet das Weglassen, dass dieser Zelltyp komplett aus deiner Analyse verschwindet.
Du berechnest die Components, checkst die Variance Ratio, um die Datenstruktur zu bestätigen, und machst weiter. Das wichtigste Takeaway ist, dass PCA kein Bild zum Anschauen ist, sondern ein gezielter mathematischer Filter, der rohe dimensionale Tiefe opfert, um Noise zu entfernen und die wahren biologischen Achsen deiner Daten freizulegen.
Ich hoffe, das war nützlich. Danke fürs Zuhören und genieß den Rest deines Tages.
8
Der Nearest Neighbor Graph und UMAP
3m 45sWir schlüsseln den absoluten Kern der modernen Einzelzell-Topologie auf: den Nearest Neighbor Graph. Anschließend erklären wir, wie UMAP dieses komplexe Netz in einen lesbaren 2D-Plot übersetzt. Du lernst, warum der Neighbor Graph die Voraussetzung für fast jedes fortgeschrittene Tool in Scanpy ist.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 8 von 16. Das Geheimnis moderner Single-Cell Analysis ist nicht einfach nur, Punkte auf einem Grid zu plotten. Es geht darum, genau zu verstehen, welche Zellen in einem riesigen, hochdimensionalen Raum Neighbors sind. Wenn du diese zugrundeliegende Struktur falsch verstehst, wird dich jede nachfolgende Visualisierung in die Irre führen. Der Mechanismus, um diese Struktur zu erfassen, ist der Nearest Neighbor Graph, und heute schauen wir uns an, wie wir ihn bauen und mit UMAP projizieren.
In dieser Phase einer typischen Pipeline hast du bereits eine Principal Component Analysis durchgeführt. Du hast Tausende von Genen auf vielleicht vierzig oder fünfzig Principal Components eingedampft. Aber fünfzig Dimensionen sind immer noch unmöglich zu visualisieren, und sie sagen uns nicht explizit, welche Zellen zur selben lokalen Community gehören. Wir müssen ein Web aus Connections aufbauen. In Scanpy machst du das mit der Funktion sc dot pp dot neighbors. Dieser Schritt berechnet den Neighborhood Graph deiner Zellen.
Distanzen zwischen Zehntausenden von Zellen über dreißigtausend Raw Genes hinweg zu berechnen, ist rechnerisch brutal und extrem anfällig für Noise. Indem du die Neighbors stattdessen auf den Principal Components berechnest, ist die Mathematik schnell und das technische Noise ist bereits entfernt. Für jede einzelne Zelle schaut sich der Algorithmus ihre Koordinaten in diesen Principal Components an und findet ihre nächsten Peers. By default verbindet er eine Zelle mit ihren fünfzehn Nearest Neighbors. Der Output ist ein mathematisches Netzwerk, in dem Zellen Nodes sind und die Edges dazwischen eine hohe Ähnlichkeit repräsentieren. Dieser Neighborhood Graph wird zur grundlegenden Datenstruktur für Downstream Tasks.
Sobald du dieses Web hast, willst du es dir natürlich auch ansehen. Hier kommt UMAP ins Spiel, aufgerufen über sc dot tl dot umap. Hier ist die wichtigste Erkenntnis: Ein sehr häufiges Missverständnis ist, dass UMAP Distanzen direkt aus deinen Raw Gene Expression Data berechnet. Das tut es nicht. UMAP ist komplett blind für deine Gene. Es ist einfach nur eine Layout Engine. Seine einzige Aufgabe ist es, diesen vorausberechneten Nearest Neighbor Graph zu nehmen und ihn in einen zweidimensionalen Raum abzuflachen.
UMAP funktioniert, indem es ein Layout optimiert, das zum Graph passt. Es zieht verbundene Neighbors nah zusammen, während es unverbundene Zellen auseinanderdrückt. Weil es sich komplett auf die lokalen Connections verlässt, die im vorherigen Schritt definiert wurden, ist es extrem gut darin, die lokale Struktur zu erhalten. Wenn eine Gruppe von Zellen im hochdimensionalen Graph eng verbunden war, wird sie eine klar abgegrenzte, kompakte Insel auf deinem 2D-UMAP-Plot bilden. Aber sei dir bewusst, dass der leere Raum zwischen den separaten Inseln auf einem UMAP-Plot sehr wenig bedeutet. UMAP opfert die globale räumliche Genauigkeit, um sicherzustellen, dass lokale Neighbors zusammenkleben.
Diese Separation of Concerns ist extrem wichtig. Die Form, die du auf einem UMAP siehst, wird komplett von dem Neighbor Graph diktiert, der direkt davor gebaut wurde. Wenn du ändern willst, wie sensibel dein Layout für seltene Zelltypen ist, tunst du nicht UMAP. Du gehst zurück und passt die Anzahl der Neighbors in der Graph Construction selbst an.
Wenn du diese Folgen hilfreich findest und die Show unterstützen möchtest, kannst du auf Patreon nach DevStoriesEU suchen. Das war's für diese Folge. Danke fürs Zuhören und keep building!
9
Clustering mit Leiden
4m 33sWir untersuchen, wie man mit dem Leiden-Clustering-Algorithmus diskrete Zellpopulationen findet. Durch die Optimierung der Modularität auf dem Neighborhood Graph isoliert Leiden stark vernetzte Communities. Du lernst, wie du den Resolution-Parameter anpasst, um stabile, biologisch sinnvolle Gruppen zu finden.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 9 von 16. Traditionelle Clustering-Algorithmen gehen davon aus, dass deine Daten in perfekt runden Blobs um einen Mittelpunkt herum organisiert sind. Doch reale biologische Daten sind chaotisch, miteinander vernetzt und bilden komplexe, kontinuierliche Formen. Wenn du versuchst, diese komplexen Strukturen in einfache Kugeln zu pressen, zerlegst du am Ende einzelne Zelltypen in künstliche Fragmente. Clustering mit Leiden löst das, indem es sich anschaut, wie Zellen miteinander verbunden sind, anstatt nur darauf zu achten, wo sie in einem abstrakten Raum liegen.
Leute denken bei Clustering oft standardmäßig an K-Means, wo du einen Mittelpunkt definierst und alles in der Nähe über normale physische Distanzen gruppierst. Leiden funktioniert nicht so. Es ist ein graphenbasierter Clustering-Algorithmus. Er ignoriert euklidische Distanzen zu einem Centroid völlig. Stattdessen verlässt er sich komplett auf die Dichte der Edges in dem Neighbor Graph, den du früher in deiner Analyse gebaut hast.
Stell dir den Neighbor Graph wie ein riesiges soziales Netzwerk vor. Die Zellen sind Individuen, und die Edges zwischen ihnen sind Freundschaften. Leiden führt eine sogenannte Community Detection durch. Er sucht nach Gruppen von Zellen, die eine sehr hohe Anzahl an Verbindungen innerhalb ihrer spezifischen Gruppe haben, aber nur sehr wenige Verbindungen zum restlichen Netzwerk.
Um das zu erreichen, optimiert der Algorithmus eine Metrik namens Modularity. Modularity misst die Dichte der Links innerhalb von Communities im Vergleich zu den Links, die du erwarten würdest, wenn das Netzwerk komplett zufällig wäre. Der Algorithmus fängt damit an, jede einzelne Zelle ihrer eigenen, individuellen Community zuzuweisen. Dann merged er diese Communities iterativ, schiebt Nodes hin und her und checkt ständig, ob die neue Gruppierung den gesamten Modularity-Score erhöht. Leiden ist speziell dafür designt, diese Partitionen sorgfältig zu verfeinern. Das garantiert, dass die finalen Communities intern dicht vernetzt sind und nicht unter unzusammenhängenden Fragmenten leiden – was ein bekanntes Problem im älteren Louvain-Algorithmus war.
In Scanpy führst du das mit der Tool-Funktion Leiden aus. Du übergibst ihr dein Main Data Object, und sie operiert direkt auf dem existierenden Neighbor Graph. Der Output ist eine neue Categorical Column, die deinen Daten hinzugefügt wird und eine Cluster-Nummer für jede einzelne Zelle enthält.
Hier ist der entscheidende Punkt. Die wichtigste Kontrolle, die du über diesen gesamten Prozess hast, ist der Resolution-Parameter. Dieser Parameter funktioniert wie ein Regler, der vorgibt, wie aggressiv der Algorithmus Gruppen aufsplittet. Standardmäßig nutzt Scanpy eine Resolution von eins. Wenn du den Resolution-Wert erhöhst, bekommst du mehr Cluster. Der Algorithmus wird extrem sensibel und bricht den Graphen in kleinere, hochspezifische Subpopulationen auf. Wenn du den Resolution-Wert verringerst, bekommst du weniger Cluster. Der Algorithmus wird toleranter und gruppiert größere Teile des Graphen zusammen.
Angenommen, du führst Leiden aus und schaust dir die resultierende Map an. Vielleicht fällt dir auf, dass ein einzelner bekannter biologischer Zelltyp in fünf winzige, überfragmentierte Subpopulationen aufgesplittet wurde. Der Algorithmus hat zwar leichte Unterschiede gefunden, aber biologisch gesehen gehören diese fünf Gruppen als ein einziger, distinkter Zellzustand zusammen. Um das zu fixen, führst du die Leiden-Funktion einfach nochmal aus, aber dieses Mal übergibst du explizit eine niedrigere Zahl an das Resolution-Argument. Indem du die Resolution senkst, weist du den Algorithmus an, seine Kriterien zu lockern. Diese fünf winzigen Fragmente mergen dann wieder zu einem einzigen, soliden, biologisch sinnvollen Cluster zusammen.
Die exakte Resolution, die du brauchst, ist nie eine feste mathematische Wahrheit; sie ist ein verstellbarer Regler, den du so lange drehst, bis die statistischen Communities im Graphen die biologische Realität deines Gewebes exakt widerspiegeln.
Danke fürs Zuhören. Ich hoffe, du hast etwas Neues gelernt.
10
Entdeckung von Marker-Genen
3m 55sWir tauchen in die Entdeckung von Marker-Genen und differenzielle Expressionstests ein. Wir erklären, wie statistische Tests die einzigartigen transkriptomischen Signaturen deiner Cluster identifizieren. Du lernst, wie du von anonymen, nummerierten Clustern zu sicher benannten biologischen Zelltypen übergehst.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 10 von 16. Du hast in deinem Dataset einen engen, klar abgegrenzten Zell-Cluster isoliert. Aber woher weißt du, ob es eine T-Zelle, eine B-Zelle oder ein völlig unbekannter Zustand ist? Die Mathematik hat sie gruppiert, aber die Biologie muss dir sagen, was sie sind. Dieser Übersetzungsschritt verlässt sich komplett auf Marker Gene Discovery.
Bevor wir uns die Tools ansehen, müssen wir eine klare Grenze zwischen Clustering und Annotation ziehen. Clustering-Algorithmen gruppieren Zellen einfach basierend auf statistischer Ähnlichkeit über Tausende von Dimensionen hinweg und weisen ihnen ein willkürliches Label zu, wie Cluster 0 oder Cluster 1. Diese Zahl hat biologisch gesehen keine Bedeutung. Marker Gene Discovery ist der Prozess, bei dem du die spezifischen Gene findest, die diese statistische Gruppierung antreiben. Dadurch kannst du diesen Clustern echte biologische Namen zuweisen.
In Scanpy findest du diese treibenden Gene mit einer Funktion namens rank genes groups. Diese Funktion führt eine Differential Expression Analysis durch. Sie nimmt ein kategoriales Grouping, meistens deine berechneten Cluster, und vergleicht die Genexpression der Zellen innerhalb eines Clusters mit den Zellen aller anderen Cluster zusammen. Das Ziel ist es, Gene zu finden, die in deinem Target-Cluster stark exprimiert werden, aber überall sonst größtenteils stumm sind. Standardmäßig vergleicht sie jeden Cluster mit der Vereinigung der restlichen Zellen, aber du kannst sie auch so konfigurieren, dass ein Cluster mit einer bestimmten Referenzgruppe verglichen wird, wenn du nach subtilen Unterschieden zwischen zwei eng verwandten Zelltypen suchst.
Um zu entscheiden, ob ein Gen wirklich ein Marker ist, führt Scanpy einen statistischen Test durch, um den Unterschied in der Expression zu scoren. Du kannst einen Standard-t-Test wählen, aber der Wilcoxon Rank-Sum Test wird sehr empfohlen und ist die Standardwahl für Single-Cell-Daten. Single-Cell-Genexpression folgt keiner normalen Glockenkurve; sie ist stark variabel, extrem schief und voller Nullwerte, wo ein Gen einfach nicht detektiert wurde. Der Wilcoxon-Test setzt keine Normalverteilung voraus. Anstatt sich rohe Mittelwerte anzusehen, rankt er die Expressionswerte über alle Zellen hinweg und vergleicht die Ranks zwischen deinem Target-Cluster und dem Rest des Datasets. Das macht ihn viel robuster gegenüber extremen Ausreißern.
Schauen wir uns ein konkretes Szenario an. Du hast ein Dataset mit mehreren Clustern und möchtest Cluster 3 untersuchen. Du rufst die Funktion rank genes groups auf, sagst ihr, dass sie deine bestehenden Cluster-Labels verwenden soll, und setzt die Methode auf Wilcoxon. Scanpy berechnet die Zahlen und rankt jedes einzelne Gen basierend darauf, wie eindeutig es Cluster 3 definiert. Dann schaust du dir die Top-Ergebnisse an. Du siehst, dass die am höchsten gerankten Gene CD8A und GZMK sind. Wenn du dich mit Immunologie auskennst, erkennst du sofort, dass das klassische Marker für zytotoxische T-Zellen sind. Weil diese spezifischen Gene hier im Vergleich zum restlichen Dataset eindeutig hochreguliert sind, kannst du Cluster 3 mit Sicherheit als CD8-positive T-Zelle labeln.
Der Output dieser Funktion wird im Hintergrund in deinem AnnData-Objekt unter dem uns-Attribut gespeichert. Scanpy speichert Arrays mit Gen-Namen, statistischen Scores, p-Values und Log-Fold-Changes für jeden einzelnen Cluster gleichzeitig. Du kannst diese Arrays extrahieren, um Dataframes zu bauen, sie in einer CSV-Datei zu speichern oder direkt an Downstream Annotation Tools weiterzugeben.
Hier ist die wichtigste Erkenntnis. Differential Expression verwandelt willkürliche mathematische Formen in verwertbare biologische Identitäten. Ohne Marker-Gene hast du nur eine Karte aus Zahlen; mit ihnen hast du ein kartiertes biologisches System.
Das war's für diese Folge. Danke fürs Zuhören und keep building!
11
Datenintegration mit Ingest
4m 25sDiese Episode behandelt die Datenintegration mit dem Ingest-Tool. Wir erklären, wie man neue Datensätze auf den PCA- und UMAP-Raum eines vorab annotierten Referenz-Atlas projiziert. Du lernst eine schnelle, invariante Methode kennen, um Labels über verschiedene Experimente hinweg zuzuordnen.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 11 von 16. Du hast ein perfekt annotiertes Reference Dataset und eine brandneue Patientenprobe, die du analysieren musst. Normalerweise bedeutet die Kombination der beiden, eine Batch Correction durchzuführen, deine Principal Components neu zu berechnen und darauf zu warten, dass ein riesiges gemeinsames UMAP von Grund auf neu gerendert wird. Data Integration mit Ingest bietet eine schnellere, nicht-destruktive Alternative.
Leute verwechseln Ingest oft mit einer Standard Batch Correction. Traditionelle Batch Correction Tools nehmen mehrere Datasets und berechnen ein komplett neues gemeinsames Modell. Sie verändern die zugrundeliegende Repräsentation deiner Reference Data, um ein Alignment zu erzwingen. Ingest macht das Gegenteil. Es ist eine asymmetrische Projektion. Dein Reference Dataset fungiert als absolute Ground Truth. Das Spatial Model ist fest verankert, und die neuen Daten werden einfach hindurchgeschoben, ohne das ursprüngliche Modell überhaupt zu verändern.
Nimm zum Beispiel einen wunderschön annotierten Reference Atlas für periphere mononukleäre Blutzellen. Jeder Cluster ist verifiziert und gelabelt. Du hast gerade eine unannotierte, chaotische Patientenprobe erhalten. Du willst diese Atlas-Labels auf deine neue Probe anwenden, und du willst die neuen Zellen in exakt demselben Coordinate Space plotten wie die Referenz.
Damit das funktioniert, müssen die Variablen in deinen beiden Datasets übereinstimmen. Das bedeutet, dass beide Datasets exakt dieselben Gene teilen müssen. In der Praxis filterst du dein neues Query Dataset so, dass seine Gene mit den Highly Variable Genes übereinstimmen, die bereits in deinem Reference Atlas identifiziert wurden.
Dein Reference Dataset muss vollständig processed sein, bevor du beginnst. Es braucht eine existierende Principal Component Analysis, einen berechneten Neighborhood Graph und eine UMAP Representation. Es enthält auch die Categorical Labels, die du transferieren willst, gespeichert in seinen Observation Metadata.
Die Ausführung ist ein einziger Command. Du rufst die Ingest Function auf und übergibst ihr dein neues Query Dataset, dein annotiertes Reference Dataset und die spezifische Observation Column, die du mappen willst, wie zum Beispiel das Cell Type Label.
Hier ist die Key Insight. Wenn du die Function triggerst, nimmt Ingest die Expression Profiles deiner neuen Zellen und projiziert sie mathematisch in den existierenden Principal Component Space des Reference Atlas. Es überspringt die Berechnung einer neuen globalen Principal Component Analysis komplett.
Sobald die Query Cells in diesem gemeinsamen Spatial Layout landen, sucht der Algorithmus nach Nearest Neighbors. Er mappt die Query Cells direkt auf den bereits existierenden Neighbor Graph des Reference Dataset. Die schwere Rechenarbeit, einen Graph zu bauen, wurde bereits vom Reference Model erledigt.
Weil die neuen Zellen nun etablierte Neighbors in den Reference Data haben, finden zwei finale Transfers statt. Erstens werden die UMAP Coordinates von den Reference Neighbors den neuen Zellen zugewiesen. Zweitens werden die Metadata Labels, wie deine Cell Types, basierend auf Majority Voting von diesen nächsten Reference Neighbors rüberkopiert.
Das Ergebnis ist ein Query Dataset, das das exakte UMAP Layout und die Cell Type Annotations deines Atlas in sich trägt. Du kannst die zuvor unannotierte Patientenprobe direkt über deine Reference Visualization legen, und die übereinstimmenden biologischen Populationen fallen sauber in die etablierten visuellen Clusters.
Indem neue Zellen auf ein existierendes Modell projiziert werden, verlagert Ingest deinen Workflow vom ständigen Neuaufbau fragiler Global Spaces hin zur Konstruktion eines einzigen robusten Reference Atlas, durch den alle zukünftigen Experimente nahtlos fließen.
Das war's für diese Folge. Danke fürs Zuhören, und keep building!
12
Visualisierung von Expressionsmustern
3m 53sWir untersuchen fortgeschrittene Visualisierungstechniken zur Auswertung der Genexpression über Cluster hinweg. Wir konzentrieren uns auf Dot Plots und Matrix Plots und erklären im Detail, wie sie sowohl Expressionsintensität als auch Sparsity kodieren. Du lernst, wie du deine Zelltyp-Annotationen auf einen Blick visuell validieren kannst.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 12 von 16. Ein Standard-Feature-Plot ist super, um zu zeigen, wo ein spezifisches Gen aktiv ist, stößt aber komplett an seine Grenzen, wenn du zwanzig verschiedene Gene über zehn verschiedene Cluster hinweg gleichzeitig vergleichen musst. Um das zu lösen, schauen wir uns die Visualisierung von Expression Patterns an. Wenn du Marker-Gene checkst, ist der erste Instinkt oft, zu einer Heatmap zu greifen. Du reihst all deine Zellen auf, reihst deine Gene auf und suchst nach Farbblöcken. Aber Single-Cell-RNA-Sequencing-Daten sind bekanntermaßen extrem sparse. Die meisten Zellen haben null Counts für die meisten Gene. In einer Standard-Single-Cell-Heatmap erzeugt diese Sparsity visuelles Rauschen. Am Ende starrst du auf ein Meer von Hintergrundfarbe und versuchst zu erraten, ob ein Gen tatsächlich ein spezifischer Marker für ein Cluster ist, oder ob es überall sonst einfach nur ein random Dropout ist. Hier kommt der Dot Plot ins Spiel. Anstatt einzelne Zellen zu plotten, aggregiert ein Dot Plot sie. Du packst deine Zellgruppen, wie zum Beispiel deine Leiden-Cluster, auf die eine Achse und die Gene, die dich interessieren, auf die andere. An jedem Schnittpunkt bekommst du einen Kreis. Hier ist der entscheidende Punkt: Ein Dot Plot encodiert zwei völlig unterschiedliche Infos in diesem einen Kreis. Erstens repräsentiert die Farbe des Dots das Mean Expression Level des Gens in diesen Zellen. Dunklere oder intensivere Farben bedeuten eine höhere Expression. Zweitens repräsentiert die Größe des Dots die Fraction der Zellen in diesem Cluster, die das Gen überhaupt exprimieren. Ein großer Dot bedeutet, dass fast jede Zelle im Cluster zumindest etwas RNA für dieses Gen hat. Ein winziger Dot bedeutet, dass nur wenige Zellen es exprimieren. Dieses duale Encoding ist unglaublich mächtig für sparse Daten. Es trennt, wie viel von einem Gen vorhanden ist, davon, wie weit es verbreitet ist. Sagen wir mal, du schaust dir fünfzehn Kandidaten für Marker-Gene über fünf Leiden-Cluster hinweg an. Du übergibst deine Daten, deine Gen-Liste und deine Cluster-Labels an die Dot-Plot-Funktion. Du kannst sofort sehen, ob deine erwarteten Monozyten-Marker in Cluster eins sowohl stark als auch weit verbreitet exprimiert werden, während sie in den anderen vier Clustern komplett fehlen. Du musst nicht mehr mühsam einzelne Zellreihen entziffern. Die großen, dunklen Dots in der Reihe von Cluster eins geben dir sofortige Validation. Manchmal brauchst du die Frequency-Information, die dir die Dot-Größe liefert, gar nicht. Du willst einfach nur ein sauberes Grid, das die durchschnittliche Expression zeigt. Dafür bietet Scanpy die Matrix-Plot-Funktion. Stell dir einen Matrix Plot wie eine gruppierte Heatmap vor. Er aggregiert deine Zellen immer noch nach Cluster, aber er füllt das gesamte Grid-Quadrat mit einer Farbe, die den Mean Expression Value repräsentiert. Es gibt keine wechselnden Dot-Größen. Es ist ein schnellerer, dichterer Weg, um breite Expression Patterns zu verifizieren, wenn du eine riesige Liste von Genen hast und die Fraction der exprimierenden Zellen für dich weniger wichtig ist. Beide Tools nehmen dein Data Object, eine Liste deiner Target-Gene und die Metadaten-Kategorie, nach der du gruppieren willst. Sie werden schnell ausgeführt und skalieren wunderbar auf Dutzende von Genen. Wenn du mit Single-Cell-Sparsity umgehst, ist die Trennung der Expression Intensity von der Expression Frequency der zuverlässigste Weg, um zu bestätigen, dass ein Marker-Gen tatsächlich ein Cluster definiert. Das war's für diese Folge. Danke fürs Zuhören und keep building!
13
Erkundung von Manifolds mit Diffusion Maps
4m 24sWir stellen Diffusion Maps vor, eine leistungsstarke Embedding-Technik für kontinuierliche biologische Daten. Wir stellen sie UMAP gegenüber und erklären, warum Diffusion besser für die Analyse der zellulären Differenzierung geeignet ist. Du lernst, wie man kontinuierliche Übergänge und Entwicklungsprozesse visualisiert.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 13 von 16. UMAP ist fantastisch, um verschiedene Zelltypen zu trennen, aber es kann kontinuierliche biologische Prozesse brutal auseinanderreißen. Wenn du die Zellentwicklung untersuchst, willst du keine unzusammenhängenden Zellinseln; du musst das fließende Kontinuum der Zustandsänderungen sehen. Das Erkunden von Manifolds mit Diffusion Maps löst genau dieses Problem.
In Scanpy berechnest du das mit dem Tool diffmap. User nutzen oft standardmäßig UMAP für jede Dimensionality Reduction. Mach dir klar, dass UMAP eine Embedding-Technik ist, die darauf optimiert ist, eindeutige Cluster zu finden und lokale Neighborhoods zu erhalten. Diffusion Maps sind da grundlegend anders. Sie erhalten die kontinuierliche mathematische Wahrscheinlichkeit von Übergängen zwischen Zuständen. Das macht sie zur idealen Wahl für die Analyse kontinuierlicher Prozesse wie der Zelldifferenzierung.
Der diffmap Algorithmus behandelt dein Data Manifold als kontinuierliches Netzwerk. Er verlässt sich komplett auf den Nearest Neighbor Graph deiner Zellen. Sobald dieser Graph steht, simuliert der Algorithmus einen Random Walk über die Verbindungen. Stell dir das wie die Modellierung eines Diffusionsprozesses vor, ähnlich wie sich Wärme in einem physischen Material ausbreitet. Der Algorithmus bewertet, wie leicht ein Signal durch die dichten Bereiche deiner Daten wandern kann. Er berechnet die Wahrscheinlichkeit, über eine bestimmte Anzahl von Steps von einem Zellzustand in einen anderen zu wechseln. Zellen, die eine hohe Übergangswahrscheinlichkeit teilen, werden im finalen, niedrigdimensionalen Raum näher beieinander platziert.
Stell dir vor, du verfolgst eine hämatopoetische Stammzelle, die zu einem Erythrozyten differenziert. Wenn du diese Daten mit einem Embedding projizierst, das eine diskrete Trennung bevorzugt, werden die intermediären Vorläuferzellen oft in künstliche, separate Cluster gezwungen. Die zugrundeliegende Mathematik zerbricht die biologische Timeline. Wenn du stattdessen diffmap ausführst, berechnet der Algorithmus die Übergangswahrscheinlichkeiten entlang des gesamten Entwicklungspfads. Das Ergebnis ist eine fließende, kontinuierliche Trajectory. Die Stammzelle sitzt an einem Ende, der reife Erythrozyt am anderen. Jeder Zwischenzustand wird entlang eines zusammenhängenden Pfades geplottet, der streng auf der Wahrscheinlichkeit des Zustandsübergangs basiert. Du schaust dir keine isolierten Snapshots von distinkten Zelltypen an. Du betrachtest ein fließendes biologisches Event.
Das in Scanpy anzuwenden, folgt einer strikten Reihenfolge. Zuerst musst du den Neighborhood Graph in deinem Objekt berechnen. Die Diffusion Map kann ohne diese vorberechneten Neighbor-Verbindungen nicht laufen. Als Nächstes rufst du das diffmap Tool auf und übergibst ihm dein AnnData Objekt. Du kannst optional die Anzahl der Components angeben, die du berechnen willst, was die Dimensionen des Outputs festlegt. Scanpy berechnet die Diffusion Map und speichert die neuen Koordinaten im multidimensional observation Attribut deines Objekts, unter dem Key X diffmap.
Das Tool speichert außerdem die Eigenwerte im unstructured data Attribut. Diese Werte verraten dir, wie viel Varianz jede Diffusion Component erfasst. Ein starker Abfall dieser Eigenwerte deutet darauf hin, dass du die wichtigsten biologischen Übergänge erfasst hast und die nachfolgenden Components wahrscheinlich Noise sind. In einem typischen Differentiation-Dataset deckt sich die erste nicht-triviale Diffusion Component direkt mit der primären Entwicklungszeitachse.
Hier ist die entscheidende Erkenntnis. In einer Diffusion Map ist die physische Distanz zwischen zwei Zellen auf dem Plot nicht nur ein generisches Maß für die transkriptomische Ähnlichkeit. Diese Distanz repräsentiert explizit die mathematische Wahrscheinlichkeit, dass ein biologischer Übergang zwischen diesen beiden spezifischen Zuständen stattfindet.
Das war's für diese Folge. Bis zum nächsten Mal!
14
Abstrahierte Graphen mit PAGA
3m 39sDiese Episode behandelt Partition-based Graph Abstraction, kurz PAGA. Wir besprechen, wie man die tatsächliche Konnektivität zwischen Clustern misst, um die globale Topologie zu erhalten. Du lernst, wie du PAGA nutzt, um die wahren Abstammungsverhältnisse aufzudecken, die in deinen Daten verborgen sind.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 14 von 16. Nur weil zwei Zellcluster auf einem UMAP Plot nebeneinander liegen, bedeutet das nicht, dass sie biologisch verwandt sind. Visuelle Nähe in zwei Dimensionen ist oft eine mathematische Illusion, und wenn du dich darauf verlässt, um Developmental Trajectories zu zeichnen, verbindest du möglicherweise Punkte, die sich im hochdimensionalen Raum gar nicht berühren. Um tatsächliche, statistisch fundierte Verbindungen abzubilden, brauchst du Abstracted Graphs mit PAGA.
PAGA steht für Partition-based Graph Abstraction. Wir müssen gleich mit einem häufigen Missverständnis aufräumen: PAGA ist kein Dimensionality Reduction Embedding wie t-SNE oder UMAP. Es berechnet keine Koordinaten für einzelne Zellen, um einen Scatter Plot zu zeichnen. Stattdessen erzeugt PAGA einen vereinfachten, grobkörnigen Graphen. Die Nodes in diesem Graphen sind ganze Cluster oder Partitionen von Zellen. Die Edges, die diese Nodes verbinden, repräsentieren die statistische Confidence, dass diese Cluster eine gemeinsame, kontinuierliche Grenze haben.
Wenn du die PAGA-Funktion auf deine annotierten Daten aufrufst, übergibst du ihr ein bestimmtes Set an Group Labels, normalerweise deine Leiden- oder Louvain-Cluster. Der Algorithmus evaluiert dann die Grenzen zwischen diesen Gruppen, indem er tief in den zugrunde liegenden Single-Cell Neighborhood Graph eintaucht. Er schaut sich die einzelnen Zellen in Cluster A an und zählt, wie viele ihrer direkten Nachbarn zu Cluster B gehören. Durch das Zusammenzählen all dieser Cross-Cluster-Verbindungen und den Vergleich mit einem Random Model generiert PAGA eine quantifizierbare Connectivity Matrix. Ein hoher Wert bedeutet, dass die Cluster eng miteinander verflochten sind, was auf einen biologischen Übergang hindeutet. Ein niedriger Wert bedeutet, dass es sich um separate Inseln handelt.
Stell dir ein konkretes Szenario vor. Du verfolgst die Entwicklung von Immunzellen und musst nachweisen, dass ein bestimmter Progenitor-Cluster direkt zu einem Effektor-T-Zell-Cluster führt. Auf einem Standard Visual Plot könnte der Layout-Algorithmus einen völlig unabhängigen Cluster direkt zwischen die beiden werfen, wodurch ihre Beziehung indirekt aussieht. Wenn du dir die PAGA Connectivity Matrix ansiehst, umgehst du diese visuelle Verzerrung. Du schaust direkt auf das mathematische Edge Weight zwischen deinen Progenitor- und Effektor-Gruppen. PAGA erlaubt es dir, einen minimalen Connectivity Threshold festzulegen. Wenn du diesen Threshold anwendest, filterst du fehlerhafte Low-Confidence-Verbindungen heraus. Wenn die starke Edge zwischen deinen beiden Zielclustern diesen Cut übersteht, hast du einen statistisch robusten Link etabliert.
Und das ist der Teil, auf den es ankommt. PAGA sitzt nicht einfach nur neben deinen Embeddings; es kann sie reparieren. Weil PAGA die globale Topologie so zuverlässig bewahrt, kannst du den Abstracted Graph nutzen, um ein UMAP Embedding zu initialisieren. Anstatt UMAP mit einem zufälligen räumlichen Layout starten zu lassen, sagst du ihm, dass es die einzelnen Zellen basierend auf dem grobkörnigen PAGA Graph positionieren soll. Das verankert deine finale zweidimensionale Visualisierung in der echten hochdimensionalen Realität und stellt sicher, dass weit entfernte biologische Zustände nicht künstlich zusammengedrängt werden.
Visualisierungen werden komplexe Daten immer verzerren, um sie auf einen flachen Bildschirm zu pressen, aber die Abstraktion eines Neighborhood Graph verlässt sich komplett auf mathematische Nähe. Vertrau dem Graphen mehr als dem Bild.
Das war's für diese Folge. Danke fürs Zuhören und keep building!
15
Trajectory Inference mit DPT
4m 13sWir untersuchen Trajectory Inference mithilfe von Diffusion Pseudotime (DPT). Wir erklären, wie man eine Wurzelzelle bestimmt und geodätische Distanzen über den zellulären Graphen berechnet. Du lernst, wie man Zellen entlang einer kontinuierlichen Entwicklungszeitachse anordnet.
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 15 von 16. Single-Cell Sequencing zerstört genau die Zelle, die du untersuchen willst. Du bekommst einen statischen Snapshot ihrer Genexpression, was bedeutet, dass du kein Video davon aufnehmen kannst, wie eine Stammzelle in einen reifen Zustand differenziert. Um diese Entwicklungsreise zu sehen, musst du mathematisch eine Timeline ableiten, indem du transkriptomische Distanzen berechnest. Genau das machen wir mit Trajectory Inference und DPT.
DPT steht für Diffusion Pseudotime. Bevor wir uns ansehen, wie der Algorithmus arbeitet, müssen wir klären, was dieser Name eigentlich bedeutet. Pseudotime ist keine echte chronologische Zeit. Sie misst keine Stunden, Tage oder das biologische Alter einer Zelle. Sie ist streng genommen nur eine Metrik für die transkriptomische Distanz. Sie misst, wie viele inkrementelle Expression Changes eine Zelle relativ zu einem bestimmten Startpunkt durchlaufen hat.
Um das in Scanpy auszuführen, nutzt du die Funktion namens sc dot tl dot dpt. Diese Funktion arbeitet auf dem existierenden Neighborhood Graph deines Datasets, der Zellen basierend auf ihrer Ähnlichkeit verbindet. Ein Graph allein hat jedoch keine inhärente Richtung. Um ihm eine Richtung zu geben, musst du einen Startpunkt definieren. Das machst du, indem du eine Root Cell setzt.
Stell dir ein Szenario vor, in dem du die Blutentwicklung untersuchst. Du untersuchst deine Cluster und identifizierst die naiven hämatopoetischen Stammzellen. Du wählst einen bestimmten Cell Index aus dieser Gruppe und weist ihn als Root in deiner Dataset-Struktur zu. Das dient als Ursprungspunkt, oder Time Zero, für die gesamte Berechnung.
Sobald die Root festgelegt ist, führst du die DPT-Funktion aus. Hier ist die entscheidende Erkenntnis. Der Algorithmus misst keine gerade, lineare Distanz zwischen der Root und einer anderen Zelle. Biologische Entwicklung ist keine gerade Linie, sie folgt komplexen, verzweigten Pfaden. Um das zu erfassen, berechnet DPT geodätische Distanzen entlang deines Neighborhood Graphs. Er bewertet die Struktur der Daten, indem er Random Walks von der Root aus simuliert. Er springt von Zelle zu Zelle über die dichten Edges des Graphen und findet so die wahrscheinlichsten Pfade der transkriptomischen Veränderung.
Das Ergebnis dieser Berechnung ist ein neues Array von Werten, das zu deinen Cell Annotations hinzugefügt wird. Jede einzelne Zelle in deinem Dataset erhält einen Pseudotime Score. Die Root Cell liegt bei null. Wenn die geodätische Distanz zur Root zunimmt, steigt der Score. In unserem Blutentwicklungs-Szenario könnte eine intermediäre Progenitor Cell einen Score von null Komma vier bekommen, während eine vollständig ausgereifte Zelle am terminalen Ende eines Branches einen Score nahe eins erhält.
Du hast damit effektiv einen statischen Cluster von Punkten in eine kontinuierliche Entwicklungsreihenfolge gemappt und sie vom geringsten zum höchsten Differenzierungsgrad sortiert. Du kannst diese numerische Achse nun nutzen, um individuelle Gene Dynamics zu tracken, und genau plotten, wann ein bestimmter Transkriptionsfaktor entlang des Entwicklungspfades aktiviert wird.
Die Zuverlässigkeit deiner Trajectory Inference hängt komplett von deinem Startpunkt ab. Das bedeutet, dass eine falsch gewählte Root eine perfekt berechnete, aber biologisch bedeutungslose Timeline ergibt.
Wenn du diese Episoden hilfreich findest und die Show unterstützen willst, kannst du auf Patreon nach DevStoriesEU suchen. Das war's für diese Folge. Danke fürs Zuhören und keep building!
16
Experimentelles Scale-Up mit Dask
3m 46sIn unserer letzten Episode betrachten wir die experimentelle Grenze von Scanpy: das Skalieren mit Dask. Wir erklären, wie man Datensätze, die den Arbeitsspeicher deines Rechners übersteigen, mithilfe von Lazy Evaluation und Out-of-Core-Verarbeitung handhabt. Danke, dass du uns auf diesem Deep Dive in Scanpy begleitet hast!
Hallo, hier ist Alex von DEV STORIES DOT EU. Scanpy Single-Cell Analysis, Folge 16 von 16. Was passiert, wenn dein Single-Cell-Dataset fünf Millionen Zellen erreicht und deinen Computer-Memory komplett auslastet? Du kannst es weder filtern noch normalisieren, und dein Kernel stürzt einfach ab. Die Lösung für dieses harte Memory-Limit ist Experimental Scale-Up mit Dask.
Viele hören Dask und denken sofort an Parallel Processing in einem Distributed Cluster, um Code zu beschleunigen. Dask kann das zwar auch, aber seine größte Superkraft in Scanpy ist derzeit das Out-of-Core Memory Management durch Lazy Evaluation. Es geht nicht nur darum, Dinge schneller zu machen. Es geht darum, Dinge zu tun, die vorher auf einem einzelnen Rechner unmöglich waren.
Standard-Scanpy-Workflows basieren auf In-Memory-Arrays. Das erfordert, dass dein gesamtes Dataset im aktiven RAM liegt. Wenn du das Dask-Backend nutzt, ersetzt Scanpy diese Standard-Arrays in deinem AnnData-Objekt durch Dask-Arrays. Ein Dask-Array ist im Wesentlichen eine Sammlung vieler kleinerer Arrays, die man Chunks nennt. Anstatt die gesamte Matrix auf einmal in den Memory zu laden, lässt Dask den Großteil der Daten sicher auf der Disk.
Wenn du eine Scanpy-Preprocessing-Function mit Dask-Backend ausführst, berechnet sie das Ergebnis nicht sofort. Hier kommt die Lazy Evaluation ins Spiel. Anstatt Zahlen zu crunchen, baut Dask ein Rezept. Es erstellt einen Task Graph, der genau beschreibt, welche mathematischen Operationen auf jedem einzelnen Chunk der Daten ausgeführt werden müssen.
Stell dir ein Szenario vor, in dem du ein riesiges Dataset mit zwei Millionen Zellen auf der Disk hast und Quality Control Metrics berechnen musst. Wenn du das mit einem Standard-Array versuchst, friert dein System ein, weil es versucht, alles in den RAM zu ziehen. Wenn dein AnnData-Objekt aber ein Dask-Array enthält, rufst du einfach die Standard-Scanpy-Quality-Control-Function auf. Die Function liefert fast sofort ein Ergebnis. Dein Memory-Verbrauch schnellt nicht in die Höhe, weil noch gar keine Zahlen verarbeitet wurden. Scanpy hat sich deine Absicht lediglich gemerkt.
Wenn du schließlich bereit bist, diese Metrics zu plotten oder die Summary Statistics zu speichern, sagst du Dask explizit, dass es das Ergebnis berechnen soll. Das ist der entscheidende Teil. Genau in diesem Moment zieht Dask den ersten Chunk an Daten von deiner Festplatte, berechnet die Metrics für genau diesen Chunk, speichert das kleine Ergebnis und wirft den Raw-Data-Chunk sofort wieder aus dem Memory. Dann geht es zum nächsten Chunk über. Dein aktiver Memory Footprint bleibt winzig. Er wird ausschließlich durch die Größe eines einzelnen Chunks bestimmt, nicht durch die Millionen von Zellen im gesamten Dataset.
Aktuell wird dieses Dask-Backend in Scanpy als experimentell eingestuft. Noch nicht jede Function im Ökosystem unterstützt es. Zentrale Preprocessing-Schritte wie Normalization, Scaling und Highly Variable Gene Selection sind jedoch voll dafür gerüstet, massive Out-of-Core Operations zu bewältigen.
Wenn du von Eager Processing im Memory zu Lazy Processing auf der Disk wechselst, wird die Größe deines Datasets nicht mehr durch deinen Hardware-RAM limitiert, sondern nur noch durch deine Geduld.
Damit sind wir am Ende unserer Single-Cell-Serie angekommen. Ich empfehle dir dringend, die offizielle Scanpy-Documentation zu erkunden und diese Data Graphs hands-on selbst zu bauen. Wenn du Ideen hast, welche Technologien wir in unserer nächsten Serie behandeln sollten, besuche devstories dot eu und lass es uns wissen. Danke fürs Zuhören und Happy Coding zusammen!