imaging-data-commons

name: imaging-data-commons description: Interroger et télécharger des données d'imagerie médicale cancérologique publiques depuis NCI Imaging Data Commons en utilisant idc-index. À utiliser pour accéder à des ensembles de données de radiologie (CT, IRM, TEP) et de pathologie à grande échelle pour l'entraînement d'IA ou la recherche. Aucune authentification requise. Interroger par métadonnées, visualiser dans le navigateur, vérifier les licences. license: Cette skill est fournie sous la licence MIT. Les données IDC elles-mêmes ont des licences individuelles (principalement CC-BY, certaines CC-NC) qui doivent être respectées lors de l'utilisation des données. tags: [scientific-skills, imaging-data-commons] metadata: version: 1.4.0 skill-author: Andrey Fedorov, @fedorov idc-index: "0.11.10" idc-data-version: "v23" repository: https://github.com/ImagingDataCommons/idc-claude-skill ----|--------------| | index_tables_guide.md | JOINs complexes, découverte de schéma, accès DataFrame | | use_cases.md | Exemples de flux de travail complets (ensembles d'entraînement, téléchargements par lot) | | sql_patterns.md | Motifs SQL rapides pour découverte de filtres, annotations, estimation de taille | | clinical_data_guide.md | Données cliniques/tabulaires, jointures imagerie+clinique, mappage de valeurs | | cloud_storage_guide.md | Accès direct S3/GCS, gestion des versions, mappage UUID | | dicomweb_guide.md | Points de terminaison DICOMweb, intégration PACS | | digital_pathology_guide.md | Microscopie de lames (SM), annotations (ANN), flux de travail pathologiques | | bigquery_guide.md | Métadonnées DICOM complets, éléments privés (requiert GCP) | | cli_guide.md | Outils en ligne de commande (idc download, fichiers manifeste) |

Modèle de données IDC

IDC ajoute deux niveaux de regroupement au-dessus de la hiérarchie DICOM standard (Patient → Étude → Série → Instance) :

• collection_id : Regroupe les patients par maladie, modalité ou objectif de recherche (ex. : tcga_luad, nlst). Un patient appartient à exactement une collection.
• analysis_result_id : Identifie les objets dérivés (segmentations, annotations, caractéristiques radiomiques) sur une ou plusieurs collections d'origine.

Utilisez collection_id pour trouver les données d'imagerie d'origine, qui peuvent inclure des annotations déposées avec les images ; utilisez analysis_result_id pour trouver les annotations générées par IA ou par des experts.

Identifiants clés pour les requêtes : | Identifiant | Portée | À utiliser pour | |------------|--------|---------| | collection_id | Regroupement de dataset | Filtrer par projet/étude | | PatientID | Patient | Regrouper les images par patient | | StudyInstanceUID | Étude DICOM | Regroupement de séries connexes, visualisation | | SeriesInstanceUID | Série DICOM | Regroupement de séries connexes, visualisation |

Tables d'index

Le package idc-index fournit plusieurs tables d'index de métadonnées, accessibles via SQL ou en tant que DataFrames pandas.

Documentation complète des tables d'index : Utilisez https://idc-index.readthedocs.io/en/latest/indices_reference.html pour vérifier rapidement les tables et colonnes disponibles sans exécuter de code.

Important : Utilisez client.indices_overview pour obtenir les descriptions de tables actuelles et les schémas de colonnes. C'est la source autoritaire pour les colonnes disponibles et leurs types — consultez-la toujours lors de l'écriture de SQL ou de l'exploration de la structure des données.

Tables disponibles

Auto = chargée automatiquement lors de l'instanciation de IDCClient() fetch_index() = requiert client.fetch_index("table_name") pour charger

Jointure de tables

Les colonnes clés ne sont pas explicitement étiquetées, voici un sous-ensemble qui peut être utilisé dans les jointures.

Note : Subjects, Updated et Description apparaissent dans plusieurs tables mais ont des significations différentes (comptages vs identifiants, contextes de mise à jour différents).

Pour des exemples de jointure détaillés, des motifs de découverte de schéma, une référence de colonnes clés et un accès DataFrame, voir references/index_tables_guide.md.

Accès aux données cliniques

# Récupérer l'index clinique (télécharge aussi les tables de données cliniques)
client.fetch_index("clinical_index")

# Interroger l'index clinique pour trouver les tables disponibles et leurs colonnes
tables = client.sql_query("SELECT DISTINCT table_name, column_label FROM clinical_index")

# Charger une table clinique spécifique en tant que DataFrame
clinical_df = client.get_clinical_table("table_name")

Voir references/clinical_data_guide.md pour les flux de travail détaillés incluant les motifs de mappage de valeurs et la jointure des données cliniques avec l'imagerie.

Options d'accès aux données

Organisation du stockage cloud

IDC maintient tous les fichiers DICOM dans des buckets de stockage cloud publics en miroir entre AWS S3 et Google Cloud Storage. Les fichiers sont organisés par UUID CRDC (pas par UID DICOM) pour supporter le versioning.

Les fichiers sont stockés comme <crdc_series_uuid>/<crdc_instance_uuid>.dcm. L'accès est gratuit (pas de frais de sortie) via AWS CLI, gsutil ou s5cmd avec accès anonyme. Utilisez la colonne series_aws_url de l'index pour les URL S3 ; GCS utilise la même structure de chemin.

Voir references/cloud_storage_guide.md pour les détails des buckets, les commandes d'accès, le mappage UUID et le versioning.

Accès DICOMweb

Les données IDC sont disponibles via l'interface DICOMweb (implémentation API Google Cloud Healthcare) pour l'intégration avec les systèmes PACS et les outils compatibles DICOMweb.

Voir references/dicomweb_guide.md pour les URL des points de terminaison, exemples de code, opérations supportées et détails d'implémentation.

Installation et configuration

Requis (pour accès basique) :

pip install --upgrade idc-index

Important : Chaque nouvelle version des données IDC déclenchera toujours une nouvelle version de idc-index. Utilisez toujours le flag --upgrade lors de l'installation, sauf si une version plus ancienne est nécessaire pour la reproductibilité.

IMPORTANT : La version des données IDC v23 est actuelle. Vérifiez toujours votre version :

print(client.get_idc_version())  # Devrait retourner "v23"

Si vous voyez une version plus ancienne, mettez à jour avec : pip install --upgrade idc-index

Testé avec : idc-index 0.11.10 (version données IDC v23)

Optionnel (pour l'analyse de données) :

pip install pandas numpy pydicom

Capacités principales

1. Découverte et exploration de données

Découvrez quelles collections d'imagerie et données sont disponibles dans IDC :

from idc_index import IDCClient

client = IDCClient()

# Obtenir les statistiques résumées de l'index principal
query = """
SELECT
  collection_id,
  COUNT(DISTINCT PatientID) as patients,
  COUNT(DISTINCT SeriesInstanceUID) as series,
  SUM(series_size_MB) as size_mb
FROM index
GROUP BY collection_id
ORDER BY patients DESC
"""
collections_summary = client.sql_query(query)

# Pour des métadonnées de collection plus riches, utilisez collections_index
client.fetch_index("collections_index")
collections_info = client.sql_query("""
    SELECT collection_id, CancerTypes, TumorLocations, Species, Subjects, SupportingData
    FROM collections_index
""")

# Pour les résultats d'analyse (annotations, segmentations), utilisez analysis_results_index
client.fetch_index("analysis_results_index")
analysis_info = client.sql_query("""
    SELECT analysis_result_id, analysis_result_title, Subjects, Collections, Modalities
    FROM analysis_results_index
""")

collections_index fournit des métadonnées curées par collection : types de cancer, localisations de tumeur, espèces, comptages de sujets et types de données support — sans besoin d'agréger à partir de l'index principal.

analysis_results_index liste les ensembles de données dérivés (segmentations IA, annotations d'experts, caractéristiques radiomiques) avec leurs collections et modalités sources.

2. Interrogation des métadonnées avec SQL

Interrogez le mini-index IDC en utilisant SQL pour trouver des ensembles de données spécifiques.

D'abord, explorez les valeurs disponibles pour les colonnes de filtre :

from idc_index import IDCClient

client = IDCClient()

# Vérifier quelles valeurs Modality existent
modalities = client.sql_query("""
    SELECT DISTINCT Modality, COUNT(*) as series_count
    FROM index
    GROUP BY Modality
    ORDER BY series_count DESC
""")
print(modalities)

# Vérifier quelles valeurs BodyPartExamined existent pour la modalité IRM
body_parts = client.sql_query("""
    SELECT DISTINCT BodyPartExamined, COUNT(*) as series_count
    FROM index
    WHERE Modality = 'MR' AND BodyPartExamined IS NOT NULL
    GROUP BY BodyPartExamined
    ORDER BY series_count DESC
    LIMIT 20
""")
print(body_parts)

Puis interrogez avec les valeurs de filtre validées :

# Trouver les IRM du sein (utiliser les valeurs réelles de l'exploration ci-dessus)
results = client.sql_query("""
    SELECT
      collection_id,
      PatientID,
      SeriesInstanceUID,
      Modality,
      SeriesDescription,
      license_short_name
    FROM index
    WHERE Modality = 'MR'
      AND BodyPartExamined = 'BREAST'
    LIMIT 20
""")

# Accéder aux résultats en tant que DataFrame pandas
for idx, row in results.iterrows():
    print(f"Patient: {row['PatientID']}, Série: {row['SeriesInstanceUID']}")

Pour filtrer par type de cancer, joindre avec collections_index :

client.fetch_index("collections_index")
results = client.sql_query("""
    SELECT i.collection_id, i.PatientID, i.SeriesInstanceUID, i.Modality
    FROM index i
    JOIN collections_index c ON i.collection_id = c.collection_id
    WHERE c.CancerTypes LIKE '%Breast%'
      AND i.Modality = 'MR'
    LIMIT 20
""")

Champs de métadonnées disponibles (utilisez client.indices_overview pour la liste complète) :

• Identifiants : collection_id, PatientID, StudyInstanceUID, SeriesInstanceUID
• Imagerie : Modality, BodyPartExamined, Manufacturer, ManufacturerModelName
• Clinique : PatientAge, PatientSex, StudyDate
• Descriptions : StudyDescription, SeriesDescription
• Licences : license_short_name

Note : Le type de cancer se trouve dans collections_index.CancerTypes, pas dans la table index principale.

3. Téléchargement de fichiers DICOM

Téléchargez efficacement les données d'imagerie depuis le stockage cloud d'IDC :

Télécharger une collection entière :

from idc_index import IDCClient

client = IDCClient()

# Télécharger une petite collection (RIDER Pilot ~1GB)
client.download_from_selection(
    collection_id="rider_pilot",
    downloadDir="./data/rider"
)

Télécharger des séries spécifiques :

# D'abord, interroger les UID de séries
series_df = client.sql_query("""
    SELECT SeriesInstanceUID
    FROM index
    WHERE Modality = 'CT'
      AND BodyPartExamined = 'CHEST'
      AND collection_id = 'nlst'
    LIMIT 5
""")

# Télécharger uniquement ces séries
client.download_from_selection(
    seriesInstanceUID=list(series_df['SeriesInstanceUID'].values),
    downloadDir="./data/lung_ct"
)

Structure de répertoire personnalisée :

dirTemplate par défaut : %collection_id/%PatientID/%StudyInstanceUID/%Modality_%SeriesInstanceUID

# Hiérarchie simplifiée (omettre le niveau StudyInstanceUID)
client.download_from_selection(
    collection_id="tcga_luad",
    downloadDir="./data",
    dirTemplate="%collection_id/%PatientID/%Modality"
)
# Résultat : ./data/tcga_luad/TCGA-05-4244/CT/

# Structure plate (tous les fichiers dans un répertoire)
client.download_from_selection(
    seriesInstanceUID=list(series_df['SeriesInstanceUID'].values),
    downloadDir="./data/flat",
    dirTemplate=""
)
# Résultat : ./data/flat/*.dcm

Noms des fichiers téléchargés :

Les fichiers DICOM individuels sont nommés en utilisant leur UUID CRDC d'instance : <crdc_instance_uuid>.dcm (par ex. 0d73f84e-70ae-4eeb-96a0-1c613b5d9229.dcm). Ce nommage basé sur UUID :

• Active le suivi de version (les UUID changent quand le contenu du fichier change)
• Correspond à l'organisation du stockage cloud (s3://idc-open-data/<crdc_series_uuid>/<crdc_instance_uuid>.dcm)
• Diffère des UID DICOM (SOPInstanceUID) qui sont conservés dans les métadonnées du fichier

Pour identifier les fichiers, utilisez la colonne crdc_instance_uuid dans les requêtes ou lisez les métadonnées DICOM (SOPInstanceUID) des fichiers.

Téléchargement en ligne de commande

La commande idc download fournit l'accès en ligne de commande à la fonctionnalité de téléchargement sans écrire de code Python. Disponible après installation de idc-index.

Détecte automatiquement le type d'entrée : chemin du fichier manifeste, ou identifiants (collection_id, PatientID, StudyInstanceUID, SeriesInstanceUID, crdc_series_uuid).

# Télécharger une collection entière
idc download rider_pilot --download-dir ./data

# Télécharger une série spécifique par UID
idc download "1.3.6.1.4.1.9328.50.1.69736" --download-dir ./data

# Télécharger plusieurs éléments (séparés par des virgules)
idc download "tcga_luad,tcga_lusc" --download-dir ./data

# Télécharger à partir d'un fichier manifeste (détection automatique)
idc download manifest.txt --download-dir ./data

Options :

Fichiers manifeste :

Les fichiers manifeste contiennent des URL S3 (une par ligne) et peuvent être :

• Exportés depuis le portail IDC après sélection de cohorte
• Partagés par des collaborateurs pour un accès reproductible aux données
• Générés programmatiquement à partir de résultats de requête

Format (une URL S3 par ligne) :

s3://idc-open-data/cb09464a-c5cc-4428-9339-d7fa87cfe837/*
s3://idc-open-data/88f3990d-bdef-49cd-9b2b-4787767240f2/*

Exemple : Générer un manifeste à partir d'une requête Python :

from idc_index import IDCClient

client = IDCClient()

# Interroger les URL de séries
results = client.sql_query("""
    SELECT series_aws_url
    FROM index
    WHERE collection_id = 'rider_pilot' AND Modality = 'CT'
""")

# Enregistrer en tant que fichier manifeste
with open('ct_manifest.txt', 'w') as f:
    for url in results['series_aws_url']:
        f.write(url + '\n')

Puis télécharger :

idc download ct_manifest.txt --download-dir ./ct_data

4. Visualiser les images IDC

Voir les données DICOM dans le navigateur sans télécharger :

from idc_index import IDCClient
import webbrowser

client = IDCClient()

# D'abord interroger pour obtenir les UID valides
results = client.sql_query("""
    SELECT SeriesInstanceUID, StudyInstanceUID
    FROM index
    WHERE collection_id = 'rider_pilot' AND Modality = 'CT'
    LIMIT 1
""")

# Voir une seule série
viewer_url = client.get_viewer_URL(seriesInstanceUID=results.iloc[0]['SeriesInstanceUID'])
webbrowser.open(viewer_url)

# Voir toutes les séries d'une étude (utile pour les examens multi-séries comme les protocoles IRM)
viewer_url = client.get_viewer_URL(studyInstanceUID=results.iloc[0]['StudyInstanceUID'])
webbrowser.open(viewer_url)

La méthode sélectionne automatiquement OHIF v3 pour la radiologie ou SLIM pour la microscopie de lames. La visualisation par étude est utile quand une étude DICOM contient plusieurs séries (ex. : séquences T1, T2, DWI d'une seule session IRM).

5. Comprendre et vérifier les licences

Vérifiez les licences des données avant utilisation (critique pour les applications commerciales) :

from idc_index import IDCClient

client = IDCClient()

# Vérifier les licences de toutes les collections
query = """
SELECT DISTINCT
  collection_id,
  license_short_name,
  COUNT(DISTINCT SeriesInstanceUID) as series_count
FROM index
GROUP BY collection_id, license_short_name
ORDER BY collection_id
"""

licenses = client.sql_query(query)
print(licenses)

Types de licences dans IDC :

• CC BY 4.0 / CC BY 3.0 (~97% des données) - Permet l'usage commercial avec attribution
• CC BY-NC 4.0 / CC BY-NC 3.0 (~3% des données) - Uniquement usage non-commercial
• Licences personnalisées (rare) - Certaines collections ont des termes spécifiques (ex. : Conditions d'utilisation NLM)

Important : Vérifiez toujours la licence avant d'utiliser les données IDC dans des publications ou applications commerciales. Chaque fichier DICOM est marqué avec sa licence spécifique dans les métadonnées.

Génération de citations pour l'attribution

La colonne source_DOI contient les DOI liés à des publications décrivant comment les données ont été générées. Pour satisfaire les exigences d'attribution, utilisez citations_from_selection() pour générer des citations correctement formatées :

from idc_index import IDCClient

client = IDCClient()

# Obtenir les citations d'une collection (format APA par défaut)
citations = client.citations_from_selection(collection_id="rider_pilot")
for citation in citations:
    print(citation)

# Obtenir les citations pour des séries spécifiques
results = client.sql_query("""
    SELECT SeriesInstanceUID FROM index
    WHERE collection_id = 'tcga_luad' LIMIT 5
""")
citations = client.citations_from_selection(
    seriesInstanceUID=list(results['SeriesInstanceUID'].values)
)

# Format alternatif : BibTeX (pour documents LaTeX)
bibtex_citations = client.citations_from_selection(
    collection_id="tcga_luad",
    citation_format=IDCClient.CITATION_FORMAT_BIBTEX
)

Paramètres :

• collection_id : Filtrer par collection(s)
• patientId : Filtrer par ID patient(s)
• studyInstanceUID : Filtrer par UID étude(s)
• seriesInstanceUID : Filtrer par UID série(s)
• citation_format : Utiliser les constantes IDCClient.CITATION_FORMAT_* :
  • CITATION_FORMAT_APA (par défaut) - Style APA
  • CITATION_FORMAT_BIBTEX - BibTeX pour LaTeX
  • CITATION_FORMAT_JSON - CSL JSON
  • CITATION_FORMAT_TURTLE - RDF Turtle

Meilleure pratique : Lors de la publication de résultats utilisant les données IDC, incluez les citations générées pour attribuer correctement les sources de données et satisfaire aux exigences de licence.

6. Traitement par lot et filtrage

Traitez efficacement les grands ensembles de données avec filtrage :

from idc_index import IDCClient
import pandas as pd

client = IDCClient()

# Trouver les CT du thorax de scanners GE
query = """
SELECT
  SeriesInstanceUID,
  PatientID,
  collection_id,
  ManufacturerModelName
FROM index
WHERE Modality = 'CT'
  AND BodyPartExamined = 'CHEST'
  AND Manufacturer = 'GE MEDICAL SYSTEMS'
  AND license_short_name = 'CC BY 4.0'
LIMIT 100
"""

results = client.sql_query(query)

# Enregistrer le manifeste pour plus tard
results.to_csv('lung_ct_manifest.csv', index=False)

# Télécharger par lots pour éviter le délai d'expiration
batch_size = 10
for i in range(0, len(results), batch_size):
    batch = results.iloc[i:i+batch_size]
    client.download_from_selection(
        seriesInstanceUID=list(batch['SeriesInstanceUID'].values),
        downloadDir=f"./data/batch_{i//batch_size}"
    )

7. Requêtes avancées avec BigQuery

Pour les requêtes nécessitant des métadonnées DICOM complètes, des JOINs complexes, des tables de données cliniques ou des éléments DICOM privés, utilisez Google BigQuery. Nécessite un compte GCP avec facturation activée.

Référence rapide :

• Dataset : bigquery-public-data.idc_current.*
• Table principale : dicom_all (métadonnées combinées)
• Métadonnées complètes : dicom_metadata (tous les tags DICOM)
• Éléments privés : colonne OtherElements (tags spécifiques aux vendeurs comme les valeurs b de diffusion)

Voir references/bigquery_guide.md pour la configuration, les schémas de tables, les motifs de requête, l'accès aux éléments privés et l'optimisation des coûts.

Avant d'utiliser BigQuery, vérifiez toujours si une table d'index spécialisée a déjà les métadonnées dont vous avez besoin :

1. Utilisez client.indices_overview ou la référence indices idc-index pour découvrir toutes les tables disponibles et leurs colonnes
2. Récupérez l'index pertinent : client.fetch_index("table_name")
3. Interrogez localement avec client.sql_query() (gratuit, aucun compte GCP nécessaire)

Index spécialisés courants : seg_index (segmentations), ann_index / ann_group_index (annotations microscopie), sm_index (microscopie de lames), collections_index (métadonnées collection). Utilisez BigQuery seulement si vous avez besoin d'éléments DICOM privés ou d'attributs non disponibles dans aucun index.

8. Guide de sélection des outils

Choix par défaut : Utilisez idc-index pour la plupart des tâches (pas d'auth, API facile, téléchargements par lot).

9. Intégration dans les pipelines d'analyse

Intégrez les données IDC dans les flux de travail d'analyse d'imagerie :

Lire les fichiers DICOM téléchargés :

import pydicom
import os

# Lire les fichiers DICOM d'une série téléchargée
series_dir = "./data/rider/rider_pilot/RIDER-1007893286/CT_1.3.6.1..."

dicom_files = [os.path.join(series_dir, f) for f in os.listdir(series_dir)
               if f.endswith('.dcm')]

# Charger la première image
ds = pydicom.dcmread(dicom_files[0])
print(f"ID patient : {ds.PatientID}")
print(f"Modalité : {ds.Modality}")
print(f"Forme image : {ds.pixel_array.shape}")

Construire un volume 3D à partir d'une série CT :

import pydicom
import numpy as np
from pathlib import Path

def load_ct_series(series_path):
    """Charger une série CT en tant que tableau numpy 3D"""
    files = sorted(Path(series_path).glob('*.dcm'))
    slices = [pydicom.dcmread(str(f)) for f in files]

    # Trier par localisation de coupe
    slices.sort(key=lambda x: float(x.ImagePositionPatient[2]))

    # Empiler en tableau 3D
    volume = np.stack([s.pixel_array for s in slices])

    return volume, slices[0]  # Retourner volume et première coupe pour métadonnées

volume, metadata = load_ct_series("./data/lung_ct/series_dir")
print(f"Forme du volume : {volume.shape}")  # (z, y, x)

Intégrer avec SimpleITK :

import SimpleITK as sitk
from pathlib import Path

# Lire une série DICOM
series_path = "./data/ct_series"
reader = sitk.ImageSeriesReader()
dicom_names = reader.GetGDCMSeriesFileNames(series_path)
reader.SetFileNames(dicom_names)
image = reader.Execute()

# Appliquer le traitement
smoothed = sitk.CurvatureFlow(image1=image, timeStep=0.125, numberOfIterations=5)

# Enregistrer en NIfTI
sitk.WriteImage(smoothed, "processed_volume.nii.gz")

Cas d'usage courants

Voir references/use_cases.md pour les exemples complets de flux de travail de bout en bout incluant :

• Construire des ensembles de données d'entraînement d'apprentissage profond à partir de CT pulmonaires
• Comparer la qualité d'image entre fabricants de scanners
• Prévisualiser les données dans le navigateur avant téléchargement
• Téléchargements par lot respectant les licences pour usage commercial

Bonnes pratiques

• Vérifier la version IDC avant de générer les réponses - Appelez toujours client.get_idc_version() au début d'une session pour confirmer que vous utilisez la version de données attendue (actuellement v23). Si vous utilisez une version plus ancienne, recommandez pip install --upgrade idc-index
• Vérifier les licences avant utilisation - Interrogez toujours le champ license_short_name et respectez les termes de licence (CC BY vs CC BY-NC)
• Générer des citations pour l'attribution - Utilisez citations_from_selection() pour obtenir les citations correctement formatées à partir des valeurs source_DOI ; incluez-les dans les publications
• Commencer par des requêtes petites - Utilisez la clause LIMIT lors de l'exploration pour éviter les téléchargements longs et comprendre la structure des données
• Utiliser le mini-index pour les requêtes simples - Utilisez BigQuery seulement quand vous avez besoin de métadonnées complètes ou de JOINs complexes
• Organiser les téléchargements avec dirTemplate - Utilisez des structures de répertoires significatives comme %collection_id/%PatientID/%Modality
• Mettre en cache les résultats de requête - Enregistrez les DataFrames en fichiers CSV pour éviter les re-requêtes et assurer la reproductibilité
• Estimer la taille en premier - Vérifiez la taille de collection avant téléchargement - certaines tailles de collection sont en téraoctets !
• Enregistrer les manifestes - Enregistrez toujours les résultats de requête avec les UID de série pour la reproductibilité et la traçabilité des données
• Lire la documentation - La structure de données IDC et les champs de métadonnées sont documentés à https://learn.canceridc.dev/
• Utiliser le forum IDC - Cherchez les questions/réponses et posez vos questions aux responsables et utilisateurs d'IDC sur https://discourse.canceridc.dev/

Dépannage

Problème : ModuleNotFoundError: No module named 'idc_index'

• Cause : Package idc-index non installé
• Solution : Installer avec pip install --upgrade idc-index

Problème : Le téléchargement échoue avec délai d'expiration de connexion

• Cause : Instabilité réseau ou taille de téléchargement importante
• Solution :
  • Télécharger des lots plus petits (ex. : 10-20 séries à la fois)
  • Vérifier la connexion réseau
  • Utiliser dirTemplate pour organiser les téléchargements par lot
  • Implémenter une logique de retry avec délais

Problème : BigQuery quota exceeded ou erreurs de facturation

• Cause : BigQuery requiert un projet GCP avec facturation activée
• Solution : Utiliser le mini-index idc-index pour les requêtes simples (pas de facturation requise), ou voir references/bigquery_guide.md pour les conseils d'optimisation des coûts

Problème : UID de série non trouvé ou pas de données retournées

• Cause : Typo dans l'UID, données non disponibles dans la version IDC actuelle, ou nom de champ incorrect
• Solution :
  • Vérifier si les données sont dans la version actuelle d'IDC (certaines anciennes données peuvent être obsolètes)
  • Utiliser LIMIT 5 pour tester la requête d'abord
  • Vérifier les noms de champs dans la documentation du schéma de métadonnées

Problème : Les fichiers DICOM téléchargés ne s'ouvrent pas

• Cause : Téléchargement corrompu ou lecteur incompatible
• Solution :
  • Vérifier le type d'objet DICOM (attributs Modality et SOPClassUID) - certains types d'objet requièrent des outils spécialisés
  • Vérifier l'intégrité des fichiers (vérifier les tailles de fichiers)
  • Utiliser pydicom pour valider : pydicom.dcmread(file, force=True)
  • Essayer un lecteur DICOM différent (3D Slicer, Horos, RadiAnt, QuPath)
  • Retélécharger la série

Motifs de requête SQL courants

Voir references/sql_patterns.md pour des motifs SQL de référence rapide incluant :

• Découverte de valeur de filtre (modalités, parties du corps, fabricants)
• Requêtes d'annotations et segmentations (jointures seg_index, ann_index incluses)
• Requêtes de microscopie de lames (motifs sm_index)
• Estimation de taille de téléchargement
• Liaison de données cliniques

Pour les détails de segmentation et annotation, voir aussi references/digital_pathology_guide.md.

Skills connexes

Les skills suivantes complètent les flux de travail IDC pour l'analyse en aval et la visualisation :

Traitement DICOM

• pydicom - Lire, écrire et manipuler les fichiers DICOM téléchargés. À utiliser pour extraire les données de pixels, lire les métadonnées, l'anonymisation et la conversion de format. Essentiel pour travailler avec les données radiologie IDC (CT, IRM, TEP).

Pathologie et microscopie de lames

Voir references/digital_pathology_guide.md pour les outils compatibles DICOM (highdicom, wsidicom, TIA-Toolbox, lecteur Slim).

Visualisation de métadonnées

• matplotlib - Traçage bas niveau pour personnalisation complète. À utiliser pour créer des figures statiques résumant les résultats de requête IDC (graphiques en barres de modalités, histogrammes de comptages de séries, etc.).
• seaborn - Visualisation statistique avec intégration pandas. À utiliser pour l'exploration rapide des distributions de métadonnées IDC, relations entre variables et comparaisons catégoriques avec des défauts attrayants.
• plotly - Visualisation interactive. À utiliser quand vous avez besoin d'infos au survol, zoom et panoramique pour explorer les métadonnées IDC, ou pour créer des tableaux de bord web des statistiques collection.

Exploration de données

• exploratory-data-analysis - EDA complet sur les fichiers de données scientifiques. À utiliser après téléchargement des données IDC pour comprendre la structure de fichiers, la qualité et les caractéristiques avant l'analyse.

Ressources

Référence de schéma (source primaire)

Utilisez toujours client.indices_overview pour les schémas de colonnes actuels. Cela garantit la précision avec la version idc-index installée :

# Obtenir tous les noms et types de colonnes pour n'importe quelle table
schema = client.indices_overview["index"]["schema"]
columns = [(c['name'], c['type'], c.get('description', '')) for c in schema['columns']]

Documentation de référence

Voir la section de navigation rapide en haut pour la liste complète des guides de référence avec déclencheurs de décision.

• indices_reference - Documentation externe pour les tables d'index (peut être en avance sur la version installée)

Liens externes

• Portail IDC : https://portal.imaging.datacommons.cancer.gov/explore/
• Documentation : https://learn.canceridc.dev/
• Tutoriels : https://github.com/ImagingDataCommons/IDC-Tutorials
• Forum utilisateur : https://discourse.canceridc.dev/
• GitHub idc-index : https://github.com/ImagingDataCommons/idc-index
• Citation : Fedorov, A., et al. "National Cancer Institute Imaging Data Commons: Toward Transparency, Reproducibility, and Scalability in Imaging Artificial Intelligence." RadioGraphics 43.12 (2023). https://doi.org/10.1148/rg.230180

Mises à jour de skill

Cette version de skill est disponible dans les métadonnées de skill. Pour vérifier les mises à jour :

• Visiter la page des releases
• Regarder le repository sur GitHub (Watch → Custom → Releases)