longevity-db/human-muscle-aging-atlas-snRNAseq

Human Skeletal Muscle Aging Atlas (sn/scRNA-seq) Dataset

1. Data Overview

This dataset provides single-nucleus and single-cell RNA sequencing (sn/scRNA-seq) data specifically focusing on the human skeletal muscle across different age groups. It serves as a rich resource for investigating cell-type specific gene expression changes and cellular composition shifts that occur during the aging process in a critical human tissue.

The original data was sourced from the Human Skeletal Muscle Aging Atlas project, which aims to provide a comprehensive cellular and molecular map of skeletal muscle aging. This processed version has been transformed into standardized .h5ad and .parquet formats, enhancing its usability for machine learning, bioinformatics pipelines, and enabling high-resolution insights into the molecular hallmarks of muscle aging.

Relevance to Aging and Longevity Research

Skeletal muscle undergoes significant functional and structural decline with age, a process known as sarcopenia, which contributes to frailty, loss of independence, and reduced quality of life in older adults. Understanding the cellular and molecular basis of muscle aging is crucial for developing interventions to promote healthy aging and extend healthspan.

This dataset offers an unprecedented opportunity to:

• Identify age-specific molecular signatures within various skeletal muscle cell types (e.g., muscle stem cells, fibroblasts, immune cells, endothelial cells).
• Uncover how cellular processes like muscle regeneration, metabolism, inflammation, and cellular senescence change with age at the single-cell level.
• Discover biomarkers or therapeutic targets for age-associated muscle decline (sarcopenia) and related conditions.
• Investigate the contribution of different cell types to the overall aging process of skeletal muscle and their interplay.
• Analyze shifts in cellular composition within the muscle tissue with advancing age.

This dataset is therefore a powerful resource for advancing our understanding of the intricate molecular mechanisms of aging within a vital human tissue, with direct implications for longevity and healthspan research.

2. Source

The original data for this processed dataset originates from the Human Skeletal Muscle Aging Atlas, a comprehensive single-cell/nucleus RNA sequencing study of human skeletal muscle.

Organism: Homo sapiens (Human)
Tissue: Skeletal Muscle
Cell Types: Various (e.g., muscle stem cells, fibroblasts, immune cells, endothelial cells, myofibers)
Technology: 10x Genomics scRNA-seq and snRNA-seq
Condition: Healthy individuals across different age groups (Young, Old)
Number of Cells: ~183,161 (based on SKM_human_pp_cells2nuclei_2023-06-22.h5ad, may vary by specific file)
Original AnnData File Used (Example): SKM_human_pp_cells2nuclei_2023-06-22.h5ad (downloaded from Human Skeletal Muscle Aging Atlas portal)

Primary Data Source Link: https://www.muscleageingcellatlas.org/human-pp/

Please refer to the original project website and associated publications for full details on experimental design, data collection, and initial processing.

3. Transformations

The data has undergone the following transformations, designed to prepare it for machine learning and in-depth bioinformatics analysis:

1. AnnData Loading: The original .h5ad file was loaded into an AnnData object, a standard format for single-cell data in Python. Sparse matrices were converted to dense for broader compatibility.
2. Expression Data Extraction and Conversion: The adata.X matrix (gene expression counts/values for each cell) was extracted and saved as expression.parquet. This serves as the primary input for gene-level analyses.
3. Feature/Gene Metadata Extraction and Conversion: The adata.var DataFrame (containing metadata about each gene/feature) was extracted and saved as gene_metadata.parquet.
4. Observation/Cell Metadata Extraction and Conversion: The adata.obs DataFrame (containing comprehensive metadata about each cell, such as cell type annotations, donor age, sex, and sample information) was extracted and saved as cell_metadata.parquet. Categorical columns were converted to string for better Parquet compatibility.
5. Highly Variable Gene (HVG) Identification and Subsetting:
   • The script first checks if HVGs are already marked in adata.var.
   • If not, scanpy.pp.highly_variable_genes is used to identify genes that show significant variation across cells, which are often the most biologically interesting.
   • For dimensionality reduction (PCA and UMAP), the AnnData object is subsetted to only these highly variable genes (adata_for_dr), significantly reducing memory usage and computational time while preserving biological signal.
6. Principal Component Analysis (PCA):
   • The script checks for existing X_pca embeddings in adata.obsm; if found and sufficient, they are used directly.
   • Otherwise, PCA is performed on the (optionally scaled) highly variable gene expression data to reduce dimensionality.
   • The resulting PCA embeddings are saved as pca_embeddings.parquet.
   • The explained variance ratio for each component is saved as pca_explained_variance.parquet.
7. UMAP (Uniform Manifold Approximation and Projection):
   • The script checks for existing X_umap embeddings in adata.obsm; if found, they are used directly.
   • Otherwise, UMAP is performed, typically on the PCA embeddings (or HVG expression data if PCA was skipped), to generate a low-dimensional (e.g., 2D or 3D) non-linear representation of the data.
   • The UMAP embeddings are saved as umap_embeddings.parquet.
8. Basic Gene Statistics:
   • Calculates and saves mean_expression and n_cells_expressed for each gene to gene_statistics.parquet, providing basic insights into gene prevalence.
9. Cell Type Proportion Analysis:
   • Calculates the overall proportions of different cell types (cell_type_proportions_overall.parquet).
   • Calculates cell type proportions grouped by a key metadata column (e.g., 'Age', 'donor_id') if available, saving to cell_type_proportions_by_{grouping_column}.parquet. This is vital for studying age-related cellular compositional changes.
10. Sample/Donor Metadata Aggregation:
    • Aggregates key metadata (e.g., Age, Sex) at the donor or sample level into donor_metadata.parquet, useful for population-level analyses.

4. Contents

• expression.parquet: Contains the full gene expression matrix (Cells x Genes). Each row represents a cell (observation), and each column represents a gene (feature).
• gene_metadata.parquet: Contains metadata about each gene, such as gene symbols, Ensembl IDs, and a 'highly_variable' flag.
• cell_metadata.parquet: Contains comprehensive metadata for each cell, including (but not limited to) inferred cell types, donor ID, age, sex, and experimental batch information. This is crucial for labeling and grouping cells in ML tasks.
• pca_embeddings.parquet: Contains the data after linear dimensionality reduction using PCA. Each row corresponds to a cell, and columns represent the principal components (e.g., PC1, PC2, ...). Ideal as features for ML models and for linear visualizations.
• pca_explained_variance.parquet: A table showing the proportion of variance explained by each principal component. Useful for determining the optimal number of components to retain.
• umap_embeddings.parquet: Contains the data after non-linear dimensionality reduction using UMAP. Each row corresponds to a cell, and columns represent the UMAP coordinates (e.g., UMAP1, UMAP2). Excellent for visualization of cell clusters and relationships.
• highly_variable_gene_metadata.parquet: Metadata specifically for genes identified as highly variable across cells. Useful for feature selection in ML models. (Only generated if HVGs are found/computed).
• gene_statistics.parquet: Basic statistics per gene, such as mean expression and the number of cells a gene is expressed in.
• cell_type_proportions_overall.parquet: A table showing the overall proportion of each cell type across the entire dataset.
• cell_type_proportions_by_{grouping_column}.parquet: (e.g., cell_type_proportions_by_Age.parquet) Tables showing cell type proportions broken down by a key grouping variable like donor age or donor ID. Crucial for studying age-related cellular shifts.
• donor_metadata.parquet: Aggregated metadata at the donor/sample level, containing unique donor IDs and associated information like age and sex.

5. Usage

This dataset is ideal for a variety of research and machine learning tasks in the context of muscle aging and longevity:

Single-Cell Analysis

Exploring cellular heterogeneity, identifying novel cell states, and characterizing gene expression patterns within the aging skeletal muscle.

Aging & Longevity Research

• Investigating age-related changes in gene expression, cellular processes (e.g., inflammation, senescence, regeneration), and cellular composition within muscle.
• Identifying molecular signatures that define "healthy" vs. "unhealthy" muscle aging.
• Discovering biomarkers or therapeutic targets for sarcopenia and other age-related muscle pathologies.

Machine Learning

• Clustering: Applying clustering algorithms (e.g., K-Means, Louvain) on pca_embeddings.parquet or umap_embeddings.parquet to identify distinct cell populations or sub-populations.
• Classification: Building models to classify cell types, age groups (e.g., young vs. old), or disease states (if available) using pca_embeddings.parquet or umap_embeddings.parquet as features and cell_metadata.parquet for labels.
• Regression: Predicting the biological age of a cell or donor based on gene expression or cell type composition.
• Dimensionality Reduction & Visualization: Using the PCA and UMAP embeddings for generating 2D or 3D plots to visualize complex cell relationships and age-related trends.
• Feature Selection: Identifying key genes or principal components relevant to muscle aging processes.

Direct Download and Loading from Hugging Face Hub

This dataset is hosted on the Hugging Face Hub, allowing for easy programmatic download and loading of its component files.

import pandas as pd
from huggingface_hub import hf_hub_download
import os

# Define the Hugging Face repository ID and the local directory for downloads
HF_REPO_ID = "longevity-db/human-muscle-aging-atlas-snRNAseq" # THIS IS YOUR REPO ID
LOCAL_DATA_DIR = "downloaded_human_muscle_data"

os.makedirs(LOCAL_DATA_DIR, exist_ok=True)
print(f"Created local download directory: {LOCAL_DATA_DIR}")

# List of Parquet files to download (matching what your processing script outputs)
parquet_files = [
    "expression.parquet",
    "gene_metadata.parquet",
    "cell_metadata.parquet",
    "pca_embeddings.parquet",
    "pca_explained_variance.parquet",
    "umap_embeddings.parquet",
    "highly_variable_gene_metadata.parquet",
    "gene_statistics.parquet",
    "cell_type_proportions_overall.parquet",
    "donor_metadata.parquet"
    # Note: If 'cell_type_proportions_by_{grouping_column}.parquet' was generated,
    # its name will depend on the grouping column found. You might need to add it separately.
]

# Download each file
downloaded_paths = {}
for file_name in parquet_files:
    try:
        path = hf_hub_download(repo_id=HF_REPO_ID, filename=file_name, local_dir=LOCAL_DATA_DIR)
        downloaded_paths[file_name] = path
        print(f"Downloaded {file_name} to: {path}")
    except Exception as e:
        print(f"Warning: Could not download {file_name}. It might not be in the repository or its name differs. Error: {e}")

# Load core Parquet files into Pandas DataFrames
df_expression = pd.read_parquet(downloaded_paths["expression.parquet"])
df_pca_embeddings = pd.read_parquet(downloaded_paths["pca_embeddings.parquet"])
df_umap_embeddings = pd.read_parquet(downloaded_paths["umap_embeddings.parquet"])
df_cell_metadata = pd.read_parquet(downloaded_paths["cell_metadata.parquet"])
df_gene_metadata = pd.read_parquet(downloaded_paths["gene_metadata.parquet"])
df_pca_explained_variance = pd.read_parquet(downloaded_paths["pca_explained_variance.parquet"])
df_hvg_metadata = pd.read_parquet(downloaded_paths["highly_variable_gene_metadata.parquet"])
df_gene_stats = pd.read_parquet(downloaded_paths["gene_statistics.parquet"])
df_cell_type_proportions_overall = pd.read_parquet(downloaded_paths["cell_type_proportions_overall.parquet"])
try: # Donor metadata might be skipped if no column found, so use try-except
    df_donor_metadata = pd.read_parquet(downloaded_paths["donor_metadata.parquet"])
except KeyError:
    df_donor_metadata = None


print("\n--- Data Loaded from Hugging Face Hub ---")
print("Expression data shape:", df_expression.shape)
print("PCA embeddings shape:", df_pca_embeddings.shape)
print("UMAP embeddings shape:", df_umap_embeddings.shape)
print("Cell metadata shape:", df_cell_metadata.shape)
print("Gene metadata shape:", df_gene_metadata.shape)
print("PCA explained variance shape:", df_pca_explained_variance.shape)
print("HVG metadata shape:", df_hvg_metadata.shape)
print("Gene statistics shape:", df_gene_stats.shape)
print("Overall cell type proportions shape:", df_cell_type_proportions_overall.shape)
if df_donor_metadata is not None:
    print("Donor metadata shape:", df_donor_metadata.shape)


# Example: Prepare data for an age prediction model
# IMPORTANT: You need to inspect `df_cell_metadata.columns` to find the actual age and cell type columns.
print("\nAvailable columns in cell_metadata.parquet (df_cell_metadata.columns):")
print(df_cell_metadata.columns.tolist())

# --- USER ACTION REQUIRED ---
# Replace 'your_age_column_name' and 'your_cell_type_column_name'
# with the actual column names found in your df_cell_metadata.columns output.
# Common names might be 'age', 'Age_Group', 'Age_in_weeks', 'cell_type_annotation', 'CellType' etc.
age_column_name = 'Age' # <<<--- UPDATE THIS with the actual age column name found in your data (e.g., 'Age', 'age_group', 'Age_in_months')
cell_type_column_name = 'cell_type' # <<<--- UPDATE THIS with the actual cell type column name (e.g., 'cell_type_annotation', 'CellType')
# --- END USER ACTION REQUIRED ---


# Example: Using age for a prediction task
if age_column_name in df_cell_metadata.columns:
    X_features_age_prediction = df_pca_embeddings # Or df_umap_embeddings, or df_expression (if manageable)
    y_labels_age_prediction = df_cell_metadata[age_column_name]
    print(f"\nPrepared X (features) for age prediction with shape {X_features_age_prediction.shape} and y (labels) with shape {y_labels_age_prediction.shape}")
else:
    print(f"\nWarning: Column '{age_column_name}' not found in cell metadata for age prediction example. Please check your data.")

# Example: Using cell type for a classification task
if cell_type_column_name in df_cell_metadata.columns:
    X_features_cell_type = df_pca_embeddings # Or df_umap_embeddings, or df_expression
    y_labels_cell_type = df_cell_metadata[cell_type_column_name]
    print(f"Prepared X (features) for cell type classification with shape {X_features_cell_type.shape} and y (labels) with shape {y_labels_cell_type.shape}")
else:
    print(f"Warning: Column '{cell_type_column_name}' not found in cell metadata for cell type classification example. Please check your data.")

# This data can then be split into train/test sets and used to train various ML models.

Creating a Model Card

The structured Parquet files in this dataset are perfectly suited for generating comprehensive Hugging Face Model Cards for models trained using this data. The various components provide crucial information for different sections of a model card:

• Data Overview: Information directly from this README (sections 1 and 2), describing the dataset's origin, scope, and relevance.
• Usage Examples: The provided Python code for loading the data demonstrates how a model might consume expression.parquet or pca_embeddings.parquet (as input features) and cell_metadata.parquet (for labels like 'age' or 'cell_type').
• Limitations and Bias: cell_metadata.parquet can be analyzed to understand the demographics (e.g., age distribution, sex, genotype if available) of the original human donors, helping to identify potential biases or limitations in the dataset's representativeness.
• Dataset Transformations: Details from the "Data Cleaning and Processing" section of this README, explaining how the data was preprocessed before model training.
• Metrics and Evaluation Data: If a model is trained, pca_embeddings.parquet and cell_metadata.parquet can be used as inputs for evaluation metrics, and their distributions can be visualized as part of the model card's evaluation section.
• Environmental Impact: Details on the computational resources (e.g., CPU/GPU hours) used for data processing or model training, which can be part of a model card.

---

6. Citation

Please ensure you cite the original source of the Human Skeletal Muscle Aging Atlas data. Refer to the project's official website for the most up-to-date citation information for the atlas and its associated publications:

Human Skeletal Muscle Aging Atlas Official Website: https://www.muscleageingcellatlas.org/human-pp/

7. Contributions

This dataset was processed and prepared by:

• Venkatachalam
• Pooja
• Albert

Curated on June 15, 2025.

Hugging Face Repository: https://huggingface.co/datasets/longevity-db/human-muscle-aging-atlas-snRNAseq