LaminDB

Aperçu

LaminDB est un framework de données open-source conçu pour la biologie, permettant de rendre les données interrogeables, traçables, reproductibles et FAIR (Trouvables, Accessibles, Interopérables, Réutilisables). Il fournit une plateforme unifiée qui combine l'architecture lakehouse, le suivi de lignée, les feature stores, les ontologies biologiques, les capacités LIMS (Laboratory Information Management System) et ELN (Electronic Lab Notebook) par le biais d'une unique API Python.

Proposition de valeur principale :

• Interrogeabilité : Rechercher et filtrer les datasets par métadonnées, features et termes d'ontologie
• Traçabilité : Suivi automatique de lignée des données brutes à travers l'analyse jusqu'aux résultats
• Reproductibilité : Contrôle de version pour les données, le code et l'environnement
• Conformité FAIR : Annotations standardisées utilisant des ontologies biologiques

Quand utiliser cette skill

Utilisez cette skill quand :

• Gérer des datasets biologiques : scRNA-seq, bulk RNA-seq, transcriptomique spatiale, cytométrie en flux, données multi-modales, données EHR
• Suivre les workflows computationnels : Notebooks, scripts, exécution de pipelines (Nextflow, Snakemake, Redun)
• Curer et valider les données : Validation de schéma, standardisation, annotation basée sur ontologies
• Travailler avec des ontologies biologiques : Gènes, protéines, types cellulaires, tissus, maladies, voies métaboliques (via Bionty)
• Construire des lakehouses de données : Interface de requête unifiée sur plusieurs datasets
• Assurer la reproductibilité : Versioning automatique, suivi de lignée, capture d'environnement
• Intégrer des pipelines ML : Connexion avec Weights & Biases, MLflow, HuggingFace, scVI-tools
• Déployer l'infrastructure de données : Configurer des systèmes de gestion des données locaux ou cloud
• Collaborer sur des datasets : Partager des données curées et annotées avec métadonnées standardisées

Capacités fondamentales

LaminDB fournit six domaines de capacités interconnectés, chacun documenté en détail dans le dossier références.

1. Concepts fondamentaux et lignée des données

Entités fondamentales :

• Artifacts : Datasets versionnés (DataFrame, AnnData, Parquet, Zarr, etc.)
• Records : Entités expérimentales (échantillons, perturbations, instruments)
• Runs & Transforms : Suivi de lignée computationnel (quel code a produit quelles données)
• Features : Champs de métadonnées typés pour annotation et requêtes

Workflows clés :

• Créer et versionner des artifacts à partir de fichiers ou d'objets Python
• Suivre l'exécution de notebooks/scripts avec ln.track() et ln.finish()
• Annoter les artifacts avec des features typées
• Visualiser les graphes de lignée des données avec artifact.view_lineage()
• Requêtes par provenance (trouver tous les outputs d'un code/inputs spécifiques)

Référence : references/core-concepts.md - Lisez ceci pour des informations détaillées sur les artifacts, records, runs, transforms, features, versioning et suivi de lignée.

2. Gestion et requêtes des données

Capacités de requête :

• Exploration et recherche de registres avec auto-complétion
• Récupération d'un seul enregistrement avec get(), one(), one_or_none()
• Filtrage avec opérateurs de comparaison (__gt, __lte, __contains, __startswith)
• Requêtes basées sur les features (requête par métadonnées annotées)
• Traversée entre registres avec syntaxe double tiret-bas
• Recherche en texte intégral sur les registres
• Requêtes logiques avancées avec objets Q (AND, OR, NOT)
• Streaming de larges datasets sans les charger en mémoire

Workflows clés :

• Parcourir les artifacts avec filtres et tri
• Requête par features, date de création, créateur, taille, etc.
• Streamer les gros fichiers par chunks ou avec slicing de tableau
• Organiser les données avec clés hiérarchiques
• Grouper les artifacts en collections

Référence : references/data-management.md - Lisez ceci pour des patterns de requête complets, des exemples de filtrage, des stratégies de streaming et les bonnes pratiques d'organisation des données.

3. Annotation et validation

Processus de curation :

1. Validation : Confirmer que les datasets correspondent aux schémas souhaités
2. Standardisation : Corriger les typos, mapper les synonymes aux termes canoniques
3. Annotation : Lier les datasets aux entités de métadonnées pour l'interrogeabilité

Types de schémas :

• Schémas flexibles : Valider uniquement les colonnes connues, autoriser des métadonnées additionnelles
• Schémas minimums obligatoires : Spécifier les colonnes essentielles, permettre des suppléments
• Schémas stricts : Contrôle complet sur la structure et les valeurs

Types de données supportés :

• DataFrames (Parquet, CSV)
• AnnData (génomique single-cell)
• MuData (multi-modal)
• SpatialData (transcriptomique spatiale)
• TileDB-SOMA (tableaux scalables)

Workflows clés :

• Définir des features et schémas pour la validation de données
• Utiliser DataFrameCurator ou AnnDataCurator pour la validation
• Standardiser les valeurs avec .cat.standardize()
• Mapper à des ontologies avec .cat.add_ontology()
• Sauvegarder les artifacts curés avec lien de schéma
• Requête des datasets validés par features

Référence : references/annotation-validation.md - Lisez ceci pour des workflows de curation détaillés, des patterns de conception de schéma, la gestion des erreurs de validation et les bonnes pratiques.

4. Ontologies biologiques

Ontologies disponibles (via Bionty) :

• Gènes (Ensembl), Protéines (UniProt)
• Types cellulaires (CL), Lignées cellulaires (CLO)
• Tissus (Uberon), Maladies (Mondo, DOID)
• Phénotypes (HPO), Voies métaboliques (GO)
• Facteurs expérimentaux (EFO), Stades développementaux
• Organismes (NCBItaxon), Médicaments (DrugBank)

Workflows clés :

• Importer les ontologies publiques avec bt.CellType.import_source()
• Rechercher les ontologies par correspondance de mot-clé ou exacte
• Standardiser les termes en utilisant le mapping de synonymes
• Explorer les relations hiérarchiques (parents, enfants, ancêtres)
• Valider les données contre les termes d'ontologie
• Annoter les datasets avec les enregistrements d'ontologie
• Créer des termes et hiérarchies personnalisés
• Gérer les contextes multi-organismes (humain, souris, etc.)

Référence : references/ontologies.md - Lisez ceci pour des opérations d'ontologie complets, des stratégies de standardisation, la navigation de hiérarchie et les workflows d'annotation.

5. Intégrations

Gestionnaires de workflow :

• Nextflow : Suivre les processus et outputs du pipeline
• Snakemake : Intégrer dans les règles Snakemake
• Redun : Combiner avec le suivi de tâche Redun

Plateformes MLOps :

• Weights & Biases : Lier les expériences aux artifacts de données
• MLflow : Suivre les modèles et expériences
• HuggingFace : Suivre le fine-tuning de modèles
• scVI-tools : Workflows d'analyse single-cell

Systèmes de stockage :

• Système de fichiers local, AWS S3, Google Cloud Storage
• Compatible S3 (MinIO, Cloudflare R2)
• Endpoints HTTP/HTTPS (lecture seule)
• Datasets HuggingFace

Magasins de tableaux :

• TileDB-SOMA (avec support cellxgene)
• DuckDB pour requêtes SQL sur fichiers Parquet

Visualisation :

• Vitessce pour visualisation interactive spatial/single-cell

Contrôle de version :

• Intégration Git pour suivi du code source

Référence : references/integrations.md - Lisez ceci pour des patterns d'intégration, des exemples de code et le dépannage pour les systèmes tiers.

6. Configuration et déploiement

Installation :

• Basique : uv pip install lamindb
• Avec extras : uv pip install 'lamindb[gcp,zarr,fcs]'
• Modules : bionty, wetlab, clinical

Types d'instances :

• SQLite local (développement)
• Stockage cloud + SQLite (petites équipes)
• Stockage cloud + PostgreSQL (production)

Options de stockage :

• Système de fichiers local
• AWS S3 avec régions et permissions configurables
• Google Cloud Storage
• Endpoints compatibles S3 (MinIO, Cloudflare R2)

Configuration :

• Gestion du cache pour fichiers cloud
• Configurations de systèmes multi-utilisateurs
• Synchronisation de dépôt Git
• Variables d'environnement

Patterns de déploiement :

• Migration développement local → production cloud
• Déploiements multi-régions
• Stockage partagé avec instances personnelles

Référence : references/setup-deployment.md - Lisez ceci pour une installation détaillée, configuration, configuration du stockage, gestion des bases de données, bonnes pratiques de sécurité et dépannage.

Workflows de cas d'usage courants

Cas d'usage 1 : Analyse single-cell RNA-seq avec validation d'ontologie

import lamindb as ln
import bionty as bt
import anndata as ad

# Commencer le suivi
ln.track(params={"analysis": "scRNA-seq QC and annotation"})

# Importer l'ontologie de types cellulaires
bt.CellType.import_source()

# Charger les données
adata = ad.read_h5ad("raw_counts.h5ad")

# Valider et standardiser les types cellulaires
adata.obs["cell_type"] = bt.CellType.standardize(adata.obs["cell_type"])

# Curer avec schéma
curator = ln.curators.AnnDataCurator(adata, schema)
curator.validate()
artifact = curator.save_artifact(key="scrna/validated.h5ad")

# Lier les annotations d'ontologie
cell_types = bt.CellType.from_values(adata.obs.cell_type)
artifact.feature_sets.add_ontology(cell_types)

ln.finish()

Cas d'usage 2 : Construction d'un lakehouse de données interrogeable

import lamindb as ln

# Enregistrer plusieurs expériences
for i, file in enumerate(data_files):
    artifact = ln.Artifact.from_anndata(
        ad.read_h5ad(file),
        key=f"scrna/batch_{i}.h5ad",
        description=f"scRNA-seq batch {i}"
    ).save()

    # Annoter avec des features
    artifact.features.add_values({
        "batch": i,
        "tissue": tissues[i],
        "condition": conditions[i]
    })

# Requête sur toutes les expériences
immune_datasets = ln.Artifact.filter(
    key__startswith="scrna/",
    tissue="PBMC",
    condition="treated"
).to_dataframe()

# Charger des datasets spécifiques
for artifact in immune_datasets:
    adata = artifact.load()
    # Analyser

Cas d'usage 3 : Pipeline ML avec intégration W&B

import lamindb as ln
import wandb

# Initialiser les deux systèmes
wandb.init(project="drug-response", name="exp-42")
ln.track(params={"model": "random_forest", "n_estimators": 100})

# Charger les données d'entraînement de LaminDB
train_artifact = ln.Artifact.get(key="datasets/train.parquet")
train_data = train_artifact.load()

# Entraîner le modèle
model = train_model(train_data)

# Logger dans W&B
wandb.log({"accuracy": 0.95})

# Sauvegarder le modèle dans LaminDB avec lien W&B
import joblib
joblib.dump(model, "model.pkl")
model_artifact = ln.Artifact("model.pkl", key="models/exp-42.pkl").save()
model_artifact.features.add_values({"wandb_run_id": wandb.run.id})

ln.finish()
wandb.finish()

Cas d'usage 4 : Intégration de pipeline Nextflow

# Dans le script de processus Nextflow
import lamindb as ln

ln.track()

# Charger l'artifact d'entrée
input_artifact = ln.Artifact.get(key="raw/batch_${batch_id}.fastq.gz")
input_path = input_artifact.cache()

# Traiter (alignement, quantification, etc.)
# ... Logique du processus Nextflow ...

# Sauvegarder la sortie
output_artifact = ln.Artifact(
    "counts.csv",
    key="processed/batch_${batch_id}_counts.csv"
).save()

ln.finish()

Liste de vérification de prise en main

Pour commencer à utiliser LaminDB efficacement :

1. Installation & Configuration (references/setup-deployment.md)

   • Installer LaminDB et les extras requis
   • S'authentifier avec lamin login
   • Initialiser l'instance avec lamin init --storage ...

2. Apprendre les concepts fondamentaux (references/core-concepts.md)

   • Comprendre Artifacts, Records, Runs, Transforms
   • Pratiquer la création et la récupération d'artifacts
   • Implémenter ln.track() et ln.finish() dans les workflows

3. Maîtriser les requêtes (references/data-management.md)

   • Pratiquer le filtrage et la recherche dans les registres
   • Apprendre les requêtes basées sur les features
   • Expérimenter le streaming de gros fichiers

4. Configurer la validation (references/annotation-validation.md)

   • Définir les features pertinentes pour le domaine de recherche
   • Créer des schémas pour les types de données
   • Pratiquer les workflows de curation

5. Intégrer les ontologies (references/ontologies.md)

   • Importer les ontologies biologiques pertinentes (gènes, types cellulaires, etc.)
   • Valider les annotations existantes
   • Standardiser les métadonnées avec les termes d'ontologie

6. Connecter les outils (references/integrations.md)

   • Intégrer avec les gestionnaires de workflow existants
   • Lier les plateformes ML pour le suivi d'expériences
   • Configurer le stockage et le calcul cloud

Principes clés

Suivez ces principes en travaillant avec LaminDB :

1. Suivre tout : Utiliser ln.track() au début de chaque analyse pour la capture automatique de lignée

2. Valider tôt : Définir les schémas et valider les données avant une analyse approfondie

3. Utiliser les ontologies : Tirer parti des ontologies biologiques publiques pour les annotations standardisées

4. Organiser avec des clés : Structurer les clés d'artifacts de manière hiérarchique (ex. project/experiment/batch/file.h5ad)

5. Requête les métadonnées d'abord : Filtrer et rechercher avant de charger les gros fichiers

6. Versionner, pas dupliquer : Utiliser le versioning intégré au lieu de créer de nouvelles clés pour les modifications

7. Annoter avec des features : Définir des features typées pour les métadonnées interrogeables

8. Documenter en détail : Ajouter des descriptions aux artifacts, schémas et transforms

9. Tirer parti de la lignée : Utiliser view_lineage() pour comprendre la provenance des données

10. Commencer local, échelle cloud : Développer localement avec SQLite, déployer en cloud avec PostgreSQL

Fichiers de référence

Cette skill inclut une documentation de référence complète organisée par capacité :

• references/core-concepts.md - Artifacts, records, runs, transforms, features, versioning, lignée
• references/data-management.md - Requêtes, filtrage, recherche, streaming, organisation des données
• references/annotation-validation.md - Conception de schéma, workflows de curation, stratégies de validation
• references/ontologies.md - Gestion d'ontologie biologique, standardisation, hiérarchies
• references/integrations.md - Gestionnaires de workflow, plateformes MLOps, systèmes de stockage, outils
• references/setup-deployment.md - Installation, configuration, déploiement, dépannage

Lisez le(s) fichier(s) de référence pertinent(s) en fonction de la capacité LaminDB spécifique nécessaire pour la tâche à accomplir.

Ressources supplémentaires

• Documentation officielle : https://docs.lamin.ai
• Référence API : https://docs.lamin.ai/api
• Dépôt GitHub : https://github.com/laminlabs/lamindb
• Tutoriel : https://docs.lamin.ai/tutorial
• FAQ : https://docs.lamin.ai/faq