Tahoe-100M vs. SEA-AD: Drugs Against Alzheimer's
Neurodegeneration sample notebook on Scigantic.
Score every Tahoe-100M drug against what Alzheimer's does to astrocytes in SEA-AD, then find out what really drives the ranking.
Figure: A slice of human middle temporal gyrus from SEA-AD, about 68,000 cells measured by MERFISH and drawn where they sit: neurons coloured by cortical layer from teal at the surface to violet in the deepest layer, white matter in slate below, and astrocytes scattered through every layer in amber
The notebook
7 code cells, shown with the output each one printed.
Start here. Click the grey cell below and press Shift+Enter. It reads what Alzheimer's disease does to one brain cell type, from the SEA-AD atlas, in about ten seconds. Then try CELL_TYPE = "Microglia-PVM" and run it again.
CELL_TYPE = "Astrocyte" # any SEA-AD subclass: Astrocyte, Microglia-PVM, Oligodendrocyte, OPC, Sst, Vip, L2/3 IT ...
import ctypes, functools, gc, os, re, time, urllib.parse, urllib.request, warnings
import numpy as np
import pandas as pd
import anndata as ad
import matplotlib.pyplot as plt
warnings.filterwarnings("ignore")
%config InlineBackend.figure_formats = ["jpeg"]
%config InlineBackend.print_figure_kwargs = {"pil_kwargs": {"quality": 62}}
plt.rcParams.update({"figure.dpi": 80, "axes.spines.top": False, "axes.spines.right": False})
pd.set_option("compute.use_numexpr", False) # numexpr crashed the kernel on some cluster nodes
BLUE, ORANGE, GREY = "#1d4ed8", "#c2410c", "#a3a3a3"
NEBULA = "MTG/RNAseq/Supplementary Information/Nebula Results"
def free_memory():
"""Hand freed memory back to the OS; the Tahoe read below needs it on a 5 GB machine."""
gc.collect()
try: ctypes.CDLL("libc.so.6").malloc_trim(0)
except OSError: pass
def seaad_file(rel):
"""A file from the public SEA-AD bucket, downloaded once and cached."""
for base in ("/mnt/archives/sea-ad-single-cell-profiling", "/mnt/archive", os.path.expanduser("~/archive")):
if os.path.exists(os.path.join(base, rel)):
return os.path.join(base, rel)
local = os.path.expanduser(f"~/.cache/seaad/{rel}")
if not os.path.exists(local):
os.makedirs(os.path.dirname(local), exist_ok=True)
url = "https://sea-ad-single-cell-profiling.s3.us-west-2.amazonaws.com/" + urllib.parse.quote(rel)
urllib.request.urlretrieve(url, local + ".part"); os.replace(local + ".part", local)
return local
@functools.lru_cache(maxsize=None)
def layer_frame(name):
a = ad.read_h5ad(seaad_file(f"{NEBULA}/{name}"))
return pd.DataFrame(a.layers[next(iter(a.layers))] if a.layers else a.X, index=a.obs_names, columns=a.var_names), a.var
def ad_signature(cell_type=CELL_TYPE):
"""Genes that change with Alzheimer's in a cell type: significant (p < 0.05) in at least half
of its supertypes, always in the same direction, detected in at least 10% of its nuclei,
and not a lncRNA. Returns each gene's median effect across supertypes."""
E, meta = layer_frame("effect_sizes.h5ad"); P, _ = layer_frame("pvalues.h5ad"); F, _ = layer_frame("fraction_expressed.h5ad")
cols = meta.index[meta.Subclass == cell_type]
e, hit = E[cols], P[cols] < 0.05
n, agree = hit.sum(1), np.sign(e).where(hit, 0).sum(1)
s = e[(n >= max(2, len(cols) / 2)) & (agree.abs() == n) & (F[cols].median(1) >= 0.10)].median(1)
lnc = re.compile(r"^(A[CLP]\d{6}\.\d+|LINC\d+|.*-AS\d*|.*-DT|MIR\d.*|SNHG\d+|LOC\d+)$")
return s[[not lnc.match(g) for g in s.index]].sort_values()
t = time.time()
signature = ad_signature()
print(f"{len(signature):,} genes change in {CELL_TYPE} with Alzheimer's ({(signature > 0).sum()} up, {(signature < 0).sum()} down), {time.time() - t:.0f} s")
print("most raised: ", ", ".join(f"{g} {v:+.2f}" for g, v in signature.tail(8)[::-1].items()))
print("most lowered:", ", ".join(f"{g} {v:+.2f}" for g, v in signature.head(8).items()))
Tahoe-100M vs. SEA-AD: Drugs Against Alzheimer's
Do any of Tahoe's drugs push brain cells the opposite way to Alzheimer's? This notebook joins two public atlases to find out.
| SEA-AD | Tahoe-100M | |
| What it is | brain tissue from 84 people, from healthy to severe Alzheimer's | 50 cancer cell lines, each treated with 379 drugs |
| What we use | how much each gene changes per cell type as the disease progresses | how much each gene changes under each drug |
| Where it lives | public bucket, four files (about 380 MB) downloaded on first run | mounted at /mnt/archive |
The recipe is the Connectivity Map's: take the genes Alzheimer's raises and lowers, then look for drugs that do the reverse. Tahoe has no neurons, but it has three lines from glial brain tumours (H4, SW 1088 and A-172), the closest thing it has to an astrocyte. So we compare those three lines with SEA-AD's astrocytes.
1. Meet SEA-AD
The Seattle Alzheimer's Disease Brain Cell Atlas sequenced brain cells from 84 donors. Each has a Braak stage, which counts how far tau tangles have spread (0 to VI). Below, on the left, is the cohort. On the right is each donor's astrocyte signature score: the average of the genes Alzheimer's raises minus the genes it lowers. It climbs with Braak stage.
astro = ad_signature("Astrocyte")
pb = ad.read_h5ad(seaad_file("Multiregion_2026/pseudobulk_objects/SEAAD_Astrocyte_HIP_MEC_LEC_ITG_MTG_FI_STG_DFC_AnG_V1C_RNAseq_final-nuclei_pseudobulked.2026-06-22.h5ad"), backed="r")
mtg = np.flatnonzero((pb.obs["Brain Region"] == "MTG").to_numpy())
obs = pb.obs.iloc[mtg]
per_donor = pd.DataFrame(pb.X[mtg, :], columns=pb.var_names).groupby(obs["Donor ID"].to_numpy()).sum()
pb.file.close()
cpm = np.log1p(per_donor.div(per_donor.sum(1), axis=0) * 1e6)
donors = obs.drop_duplicates("Donor ID").set_index("Donor ID").loc[cpm.index]
del per_donor, pb; free_memory()
genes = [g for g in astro.index if g in cpm.columns]
z = (cpm[genes] - cpm[genes].mean()) / cpm[genes].std().replace(0, np.nan)
donors["score"] = z[[g for g in genes if astro[g] > 0]].mean(1) - z[[g for g in genes if astro[g] < 0]].mean(1)
stages = ["Braak 0", "Braak II", "Braak III", "Braak IV", "Braak V", "Braak VI"]
labels = [s.replace("Braak ", "") for s in stages]
tab = pd.crosstab(donors["Braak"], donors["Cognitive Status"]).reindex(stages).fillna(0)
fig, (a1, a2) = plt.subplots(1, 2, figsize=(10, 3.6))
a1.bar(labels, tab["No dementia"], color=BLUE, label="no dementia")
a1.bar(labels, tab["Dementia"], bottom=tab["No dementia"], color=ORANGE, label="dementia", edgecolor="white", lw=2)
a1.set_xlabel("Braak stage"); a1.set_ylabel("donors"); a1.legend(frameon=False, fontsize=8)
a1.set_title(f"SEA-AD's {len(donors)} donors", fontsize=10)
rng = np.random.default_rng(1)
for k, st in enumerate(stages):
v = donors.loc[donors.Braak == st, "score"].dropna()
a2.scatter(k + rng.uniform(-0.18, 0.18, len(v)), v, s=14, c=GREY, lw=0)
if len(v): a2.plot([k - 0.28, k + 0.28], [v.median()] * 2, c=BLUE, lw=2.5)
a2.set_xticks(range(len(stages)), labels); a2.set_xlabel("Braak stage")
a2.set_title("Astrocyte signature score per donor (bar: median)", fontsize=10)
plt.tight_layout(); plt.show()
stage_num = donors.Braak.map({s: i for i, s in enumerate(stages)})
print(f"{len(astro):,} genes in the astrocyte signature; score vs Braak stage, Spearman {donors.score.corr(stage_num, method='spearman'):+.2f}")
Output:
1,119 genes in the astrocyte signature; score vs Braak stage, Spearman +0.46
2. Meet Tahoe-100M
Tahoe Therapeutics grew 50 cancer cell lines together in each well, treated them with 379 drugs, and sequenced 100 million single cells. Most lines come from bowel, lung and pancreas tumours.
ROOT = os.environ.get("SCIGANTIC_MOUNT_PATH", "/mnt/archive")
LINE_FILES = {"A549": [0, 20], "COLO 205": [20, 41], "HT-29": [41, 61], "SW480": [61, 82], "HS-578T": [82, 102], "LoVo": [102, 123], "SW1417": [123, 143], "RKO": [143, 164], "SHP-77": [164, 184], "SW 900": [184, 205], "MIA PaCa-2": [205, 225], "HCT15": [225, 246], "CFPAC-1": [246, 267], "AsPC-1": [267, 287], "Hs 766T": [287, 308], "PANC-1": [308, 328], "BT-474": [328, 349], "SW48": [349, 369], "HOP62": [369, 390], "J82": [390, 410], "LS 180": [410, 431], "HepG2/C3A": [431, 451], "RPMI-7951": [451, 472], "Panc 03.27": [472, 492], "HEC-1-A": [492, 513], "C-33 A": [513, 533], "NCI-H1573": [533, 554], "SK-MEL-2": [554, 574], "NCI-H460": [574, 595], "NCI-H661": [595, 615], "NCI-H596": [615, 636], "A-427": [636, 656], "CHP-212": [656, 677], "H4": [677, 697], "A498": [697, 718], "SW 1088": [718, 738], "SNU-423": [738, 759], "SW 1271": [759, 779], "C32": [779, 800], "KATO III": [800, 820], "SNU-1": [820, 841], "AN3 CA": [841, 861], "NCI-H2347": [861, 882], "A-172": [882, 902], "hTERT-HPNE": [902, 923], "NCI-H23": [923, 944], "NCI-H1792": [944, 964], "NCI-H2122": [964, 984], "NCI-H2030": [984, 1005], "LOX-IMVI": [1005, 1025]}
LINES = ["H4", "SW 1088", "A-172"]
line_meta = pd.read_parquet(os.path.join(ROOT, "metadata/cell_line_metadata.parquet")).drop_duplicates("cell_name").set_index("cell_name")
drugs = pd.read_parquet(os.path.join(ROOT, "metadata/drug_metadata.parquet")).drop_duplicates("drug").set_index("drug")
organ = line_meta.loc[list(LINE_FILES), "Organ"].value_counts().sort_values()
moa = drugs["moa-fine"].fillna("unclear").value_counts()
moa = pd.concat([moa.head(11), pd.Series({"other": moa.iloc[11:].sum()})]).sort_values()
fig, (a1, a2) = plt.subplots(1, 2, figsize=(10, 4.2))
a1.barh(organ.index, organ.values, color=[BLUE if o in ("CNS/Brain", "Peripheral Nervous System") else GREY for o in organ.index])
a1.set_xlabel("cell lines"); a1.set_title("The 50 cell lines, by tissue (blue: nervous system)", fontsize=10)
a2.barh(moa.index, moa.values, color=GREY)
a2.set_xlabel("drugs"); a2.set_title(f"The {len(drugs)} drugs, by mode of action", fontsize=10)
for a in (a1, a2): a.tick_params(axis="y", labelsize=8)
plt.tight_layout(); plt.show()
Here are 12,000 cells from one of Tahoe's files, laid out by how similar their expression is. Each island is a cell line, because lines differ from each other far more than any drug changes them. The three glial lines are in colour.
import io, pyarrow as pa, pyarrow.parquet as pq, scipy.sparse as sp, scanpy as sc
with open(os.path.join(ROOT, "data/train-00000-of-03388.parquet"), "rb") as fh: # read whole files on this mount, see section 3
cells = pq.read_table(io.BytesIO(fh.read()), columns=["genes", "expressions", "cell_line_id"])
cells = cells.take(np.sort(np.random.default_rng(0).choice(cells.num_rows, 12000, replace=False)))
# Build a sparse matrix straight from Arrow's flat arrays (per-cell Python lists would take GBs).
g_col, x_col = cells["genes"].combine_chunks(), cells["expressions"].combine_chunks()
col, val = g_col.flatten().to_numpy(), x_col.flatten().to_numpy()
row = np.repeat(np.arange(cells.num_rows), g_col.value_lengths().to_numpy())
ok = (val > 0) & (col >= 0)
X = sp.csr_matrix((val[ok].astype(np.float32), (row[ok], col[ok])))
by_id = line_meta.reset_index().drop_duplicates("Cell_ID_Cellosaur").set_index("Cell_ID_Cellosaur").cell_name
umap = sc.AnnData(X, obs=pd.DataFrame({"line": pd.Series(cells["cell_line_id"].to_numpy(zero_copy_only=False)).map(by_id).to_numpy()}))
del cells, g_col, x_col, col, val, row, ok, X
sc.pp.normalize_total(umap, target_sum=1e4); sc.pp.log1p(umap)
sc.pp.highly_variable_genes(umap, n_top_genes=2000, subset=True)
sc.pp.pca(umap, n_comps=30); sc.pp.neighbors(umap, transformer="sklearn"); sc.tl.umap(umap, random_state=0)
xy, line = umap.obsm["X_umap"], umap.obs.line.to_numpy()
fig, ax = plt.subplots(figsize=(7.5, 6))
ax.scatter(*xy[~np.isin(line, LINES)].T, s=2, c="#d4d4d4", lw=0, rasterized=True)
for name, colour in zip(LINES, [BLUE, "#0d9488", ORANGE]):
ax.scatter(*xy[line == name].T, s=5, c=colour, lw=0, label=f"{name} ({(line == name).sum()} cells)")
ax.legend(frameon=False, fontsize=8, markerscale=3); ax.axis("off")
ax.set_title(f"{len(umap):,} Tahoe cells from {pd.Series(line).nunique()} cell lines", fontsize=10)
plt.tight_layout(); plt.show()
del umap, xy; pa.default_memory_pool().release_unused(); free_memory()
3. Reading the three glial lines
Tahoe's drug results (one DESeq2 table per drug, cell line and dose) fill 1,026 files. They are sorted by cell line, so we open only the 63 files that hold our three lines and keep the 5 uM dose and the signature genes.
Two details matter. On this mount each file has to be read whole, because jumping around inside it returns corrupted bytes. And we keep only drug and line pairs with at least 100 treated cells, since smaller ones give noisy results. That drops most of SW 1088's drugs, as it grows slowly.
import pyarrow.compute as pc
DE_DIR, DOSE, MIN_CELLS = os.path.join(ROOT, "metadata/pseudobulk_differential_expression"), 5.0, 100
COLS = ["gene_name", "baseMean", "log2FoldChange", "stat", "drug", "Cell_Name_Vevo", "plate", "n_cells_trt", "concentration"]
def read_de(lines, dose, genes):
files = sorted({i for l in lines for i in range(LINE_FILES[l][0], LINE_FILES[l][1] + 1)})
want_genes, parts = pa.array(sorted(genes)), []
for i in files:
with open(os.path.join(DE_DIR, f"train-{i:05d}-of-01026.parquet"), "rb") as fh:
pf = pq.ParquetFile(pa.BufferReader(fh.read()))
# Each row group holds one line, drug and dose; its footer statistics say which, so we skip the rest unread.
md, names = pf.metadata, pf.schema_arrow.names
def wanted(rg):
l, c = md.row_group(rg).column(names.index("Cell_Name_Vevo")).statistics, md.row_group(rg).column(names.index("concentration")).statistics
return not (l.min == l.max and l.min not in lines) and not (c.min == c.max and abs(c.min - dose) > 1e-6)
groups = [rg for rg in range(md.num_row_groups) if wanted(rg)]
for k in range(0, len(groups), 100):
tb = pf.read_row_groups(groups[k:k + 100], columns=COLS, use_threads=False)
keep = pc.and_(pc.and_(pc.is_in(tb["Cell_Name_Vevo"], pa.array(lines)), pc.less(pc.abs(pc.subtract(tb["concentration"], dose)), 1e-6)),
pc.is_in(tb["gene_name"], want_genes))
parts.append(tb.filter(keep).drop(["concentration"]))
pf = tb = None; free_memory()
return pa.concat_tables(parts).to_pandas()
t = time.time()
de = read_de(LINES, DOSE, set(astro.index))
pairs = de.drop_duplicates(["Cell_Name_Vevo", "drug", "plate"])
best = pairs[pairs.n_cells_trt >= MIN_CELLS].sort_values("n_cells_trt").drop_duplicates(["Cell_Name_Vevo", "drug"], keep="last")
de = de.merge(best[["Cell_Name_Vevo", "drug", "plate"]]); free_memory() # one plate per drug and line
print(f"{len(de):,} rows in {time.time() - t:.0f} s")
print(pd.DataFrame({"drugs tested": pairs.groupby("Cell_Name_Vevo").drug.nunique(),
f"with >= {MIN_CELLS} treated cells": de.groupby("Cell_Name_Vevo").drug.nunique()}).to_string())
Output:
1,006,848 rows in 68 s
drugs tested with >= 100 treated cells
Cell_Name_Vevo
A-172 379 379
H4 379 372
SW 1088 379 161
4. Scoring every drug
A drug's score is the rank correlation, across the signature genes, between what the drug does in a line and what Alzheimer's does in astrocytes, averaged over the lines. Negative means reversal: the drug lowers what the disease raises and raises what it lowers.
To see how big a score gets by chance, we repeat the scoring 200 times with the gene labels shuffled (grey band in the plot).
expr = de[de.Cell_Name_Vevo.isin(["H4", "A-172"])].groupby(["gene_name", "Cell_Name_Vevo"]).baseMean.median().unstack().min(1)
STAT = de.pivot_table(index=["Cell_Name_Vevo", "drug"], columns="gene_name", values="stat")
def score(sig, drop=()):
g = [x for x in sig.index if x in STAT.columns and expr.get(x, 0) >= 5 and x not in drop] # genes expressed in the lines
X = STAT[g].fillna(0).rank(axis=1).to_numpy(); X = (X - X.mean(1, keepdims=True)) / X.std(1, keepdims=True)
a = sig[g].rank().to_numpy(); a = (a - a.mean()) / a.std()
def per_drug(v):
s = pd.Series((X * v).mean(1), index=STAT.index).unstack(0)
return s[s.notna().sum(1) >= 2] # scored in at least two lines
out = per_drug(a)
rng = np.random.default_rng(0)
null = np.concatenate([per_drug(rng.permutation(a)).mean(1).to_numpy() for _ in range(200)])
return out.assign(score=out.mean(1)).join(drugs[["moa-fine", "human-approved"]]), len(g), null
S, n_genes, null = score(astro)
lo, hi = np.percentile(null, [0.5, 99.5])
print(f"{len(S)} drugs scored on {n_genes} genes; scores run {S.score.min():+.2f} to {S.score.max():+.2f}, chance {lo:+.2f} to {hi:+.2f}")
print(f"H4 and A-172 rank the drugs alike: Spearman {S['H4'].corr(S['A-172'], method='spearman'):.2f}")
print("\nstrongest reversal:")
print(S.nsmallest(10, "score")[["score", "moa-fine", "human-approved"]].to_string(float_format=lambda v: f"{v:+.2f}", max_colwidth=28))
cox = S[S["moa-fine"] == "Cyclooxygenase inhibitor"].score.sort_values()
print("\ncyclooxygenase inhibitors, the NSAID class:", ", ".join(f"{re.sub(r' *[(].*[)]', '', d)} {v:+.2f}" for d, v in cox.items()))
top_rev, top_mim = S.nsmallest(4, "score").index, S.nlargest(4, "score").index
fig, ax = plt.subplots(figsize=(7.5, 6))
ax.axhspan(lo, hi, color="#f1f5f9", zorder=0); ax.axvspan(lo, hi, color="#f1f5f9", zorder=0)
ax.scatter(S["A-172"], S["H4"], s=12, c=GREY, lw=0)
for idx, c, dx, ha in [(top_rev, BLUE, 14, "left"), (top_mim, ORANGE, -14, "right")]:
ax.scatter(S.loc[idx, "A-172"], S.loc[idx, "H4"], s=36, c=c, edgecolor="white", lw=1.5)
for k, d in enumerate(idx):
ax.annotate(re.sub(r"\s*\(.*\)", "", d), (S.loc[d, "A-172"], S.loc[d, "H4"]), fontsize=8, ha=ha,
xytext=(dx, (-18 + 11 * k) * np.sign(dx)), textcoords="offset points", arrowprops={"arrowstyle": "-", "color": "#737373", "lw": 0.5})
ax.axhline(0, color="k", lw=0.5); ax.axvline(0, color="k", lw=0.5)
ax.set_xlabel("score in A-172"); ax.set_ylabel("score in H4")
ax.set_title(f"{len(S)} drugs against the Alzheimer's astrocyte signature\nblue: strongest reversal; orange: strongest push towards the disease", fontsize=10)
plt.tight_layout(); plt.show()
Output:
372 drugs scored on 913 genes; scores run -0.29 to +0.29, chance -0.07 to +0.07
H4 and A-172 rank the drugs alike: Spearman 0.81
strongest reversal:
score moa-fine human-approved
drug
Oxaprozin -0.29 Cyclooxygenase inhibitor yes
Vandetanib -0.27 Multi-TK inhibitor yes
Pralsetinib -0.27 Other TK inhibitor yes
Loperamide (hydrochloride) -0.26 unclear yes
Abemaciclib -0.26 CDK inhibitor yes
Voriconazole -0.25 unclear yes
Atazanavir (sulfate) -0.25 unclear yes
Digitoxin -0.25 unclear no
Darolutamide -0.25 Androgen receptor antago... yes
...
5. What drives the ranking
The scores sit far outside the chance band and the lines agree, so the comparison measures something real. But what? Ribosomal protein genes are a clue: Alzheimer's lowers almost all of them in astrocytes, and drugs move them strongly because ribosome output tracks growth.
LFC = de.groupby(["drug", "gene_name"]).log2FoldChange.mean().unstack()
ribo = [g for g in astro.index if (g.startswith(("RPS", "RPL")) or g in ("FAU", "UBA52")) and g in LFC.columns]
S["ribosome"] = LFC.loc[S.index, ribo].median(1)
r = S.score.corr(S.ribosome, method="spearman")
S2, n2, _ = score(astro, drop=set(ribo))
print(f"{len(ribo)} ribosomal genes in the signature, {(astro[ribo] < 0).sum()} lowered in Alzheimer's")
print(f"a drug's score against its ribosomal change: Spearman {r:+.2f}")
print(f"scored without them ({n2} genes): ranking correlates with the original at {S.score.corr(S2.score, method='spearman'):.2f}; "
f"top reversal {', '.join(re.sub(r' *[(].*[)]', '', d) for d in S2.score.nsmallest(5).index)}")
fig, ax = plt.subplots(figsize=(7.5, 5))
ax.scatter(S.ribosome, S.score, s=12, c=GREY, lw=0)
for idx, c in [(top_rev, BLUE), (top_mim, ORANGE)]:
ax.scatter(S.loc[idx, "ribosome"], S.loc[idx, "score"], s=36, c=c, edgecolor="white", lw=1.5)
ax.axhline(0, color="k", lw=0.5); ax.axvline(0, color="k", lw=0.5)
ax.set_xlabel(f"median change in {len(ribo)} ribosomal protein genes (log2)"); ax.set_ylabel("score (negative = reversal)")
ax.set_title(f"Drugs that raise ribosomal genes score as reversal (Spearman {r:+.2f})", fontsize=10)
plt.tight_layout(); plt.show()
Output:
53 ribosomal genes in the signature, 52 lowered in Alzheimer's a drug's score against its ribosomal change: Spearman -0.89 scored without them (860 genes): ranking correlates with the original at 0.92; top reversal Oxaprozin, Loperamide, Vandetanib, Voriconazole, Phenylephrine
What this shows
- The comparison works. Scores run about four times past the chance band, and separate glial lines rank the drugs the same way.
- Most of the ranking is one growth axis. A drug's effect on ribosomal genes predicts its score almost perfectly. The ranking barely changes without those genes, because they are the most visible part of a wider biosynthesis program that falls in Alzheimer's astrocytes. A high score is not evidence that a drug treats anything.
- The top hit is a cautionary tale. Oxaprozin, an NSAID, comes first, while other NSAIDs are spread across the range. A prevention trial of naproxen and celecoxib (ADAPT) found no benefit; here celecoxib scores mildly negative and naproxen positive.
- Tumour lines are not astrocytes. They grow in a dish without neurons, amyloid or tau.
Next steps
- Early disease. Early disease is where an intervention has the most to save. SEA-AD also publishes early- and late-phase results (effect_sizes_early.h5ad, pvalues_early.h5ad). In our tests the early signature reproduced better across lines (0.71 against 0.39).
- Chromatin. SEA-AD has single-nucleus ATAC for the same donors (MTG/ATACseq/), which is closer to what an epigenome model sees.
- Other cell types and doses. Change CELL_TYPE in the first cell, or LINES and DOSE above.
Run it yourself
This sample opens as a hosted JupyterLab notebook with its datasets already mounted, so nothing has to be downloaded first. The notebook arrives with its outputs already rendered, and an AI assistant in the notebook can explain each step or change the analysis. Open the sample or browse the full catalog.