AI et machine learning transforment l’image médicale, mais la formation de ces modèles nécessite de grands ensembles de données, correctement anonymisés. Dans ce guide, vous apprendrez comment ** préparer les données DICOM pour la recherche artificielle** en utilisant un flux de travail complet qui combine l’anonymisation d’un ensemble avec les exportations de métadonnées JSON pour une intégration sans fil dans les pipelines ML.

Table des contenus

Pourquoi la recherche artificielle a besoin de données DICOM anonymisées

Les modèles d’imagerie médicale pour le diagnostic, la segmentation et la détection nécessitent des données de formation substantielles. Ces données doivent être correctement anonymisées pour respecter les politiques HIPAA, GDPR et institutionnelle. En outre, les collaborations de recherche s’étendent souvent sur plusieurs institutions, ce qui rend la désidentification standardisée essentielle.

La préparation correcte des données implique plus que simplement la suppression des noms des patients. Il nécessite un traitement systématique de toutes les informations d’identification, l’application cohérente des règles d’anonymisation sur des milliers de fichiers, et la conversion de format qui rend les données accessibles aux cadres ML.

Les risques de la préparation de données inappropriée

L’utilisation d’un ensemble de données partiellement anonyme ou mal structuré crée des problèmes significatifs. l’anonymisation incomplète peut exposer les informations du patient, conduisant à des violations réglementaires et des violences éthiques. la anonymisation incohérente à travers un ensemble peut introduire des bias ou des questions de qualité des données. Les métadonnées non structurées rendent difficile de filtrer, de demander et de pré-procéder les données pour la formation de modèle.

Ces risques sont réduits en utilisant des pipelines d’anonymisation automatisées et cohérentes et en convertissant les données dans des formats machine-friendly.

Le flux de travail de préparation complet

Le flux de travail complet se compose de quatre étapes. Tout d’abord, le groupe anonymise les études DICOM en utilisant des profils cohérents. Deuxièmement, convertir les métadonnées anonymisées à JSON pour l’insertion du pipeline. Troisième, enregistrer les images et les metadonnes pour un accès au framework ML. Quatrièmes, maintenir la cartographie entre les identifiants anonymes et originaux dans un stockage sécurisé.

Nous allons mettre en œuvre chaque étape avec des exemples de code.

L’anonymisation du batch

Commencez par anonymiser votre collection DICOM avec un profil cohérent:

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Anonymization;

public class DicomDatasetPreparation
{
    private readonly string _inputFolder;
    private readonly string _outputFolder;
    private readonly string _mappingFile;
    private readonly Anonymizer _anonymizer;
    private readonly List<string> _mappings = new();

    public DicomDatasetPreparation(string inputFolder, string outputFolder)
    {
        _inputFolder = inputFolder;
        _outputFolder = outputFolder;
        _mappingFile = Path.Combine(outputFolder, "id_mapping.csv");

        Directory.CreateDirectory(outputFolder);

        // Create anonymizer with research-appropriate profile
        ConfidentialityProfile profile = ConfidentialityProfile.CreateDefault(
            ConfidentialityProfileOptions.BasicProfile |
            ConfidentialityProfileOptions.RetainPatientChars
        );
        _anonymizer = new Anonymizer(profile);

        _mappings.Add("OriginalFile,AnonymizedFile,Timestamp");
    }

    public async Task ProcessDatasetAsync()
    {
        string[] dicomFiles = Directory.GetFiles(_inputFolder, "*.dcm", SearchOption.AllDirectories);
        Console.WriteLine($"Found {dicomFiles.Length} DICOM files to process.");

        int processed = 0;
        int failed = 0;

        foreach (string filePath in dicomFiles)
        {
            try
            {
                string relativePath = Path.GetRelativePath(_inputFolder, filePath);
                string outputPath = Path.Combine(_outputFolder, "images", relativePath);

                Directory.CreateDirectory(Path.GetDirectoryName(outputPath)!);

                DicomFile dcm = DicomFile.Open(filePath);
                DicomFile anonymizedDcm = _anonymizer.Anonymize(dcm);
                anonymizedDcm.Save(outputPath);

                // Record mapping for audit trail
                _mappings.Add($"\"{relativePath}\",\"{outputPath}\",\"{DateTime.UtcNow:O}\"");

                processed++;
                if (processed % 100 == 0)
                {
                    Console.WriteLine($"Progress: {processed}/{dicomFiles.Length}");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error processing {filePath}: {ex.Message}");
                failed++;
            }
        }

        // Save mapping file
        await File.WriteAllLinesAsync(_mappingFile, _mappings);

        Console.WriteLine($"\nAnonymization complete:");
        Console.WriteLine($"  Processed: {processed}");
        Console.WriteLine($"  Failed: {failed}");
        Console.WriteLine($"  Mapping file: {_mappingFile}");
    }
}

Convertir les métadonnées en JSON

Après l’anonymisation, convertir les métadonnées à JSON pour la prise de pipeline ML :

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Serialization;

public class MetadataExporter
{
    public async Task ExportMetadataToJsonAsync(string dicomFolder, string jsonOutputPath)
    {
        string[] dicomFiles = Directory.GetFiles(dicomFolder, "*.dcm", SearchOption.AllDirectories);
        List<Dataset> datasets = new();

        Console.WriteLine($"Extracting metadata from {dicomFiles.Length} files...");

        foreach (string filePath in dicomFiles)
        {
            try
            {
                DicomFile dcm = DicomFile.Open(filePath);
                datasets.Add(dcm.Dataset);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Skipping {filePath}: {ex.Message}");
            }
        }

        // Serialize all datasets to JSON array
        string jsonArray = DicomJsonSerializer.Serialize(datasets.ToArray(), writeIndented: true);
        await File.WriteAllTextAsync(jsonOutputPath, jsonArray);

        Console.WriteLine($"Exported {datasets.Count} datasets to {jsonOutputPath}");
    }

    public async Task ExportMetadataPerFileAsync(string dicomFolder, string jsonOutputFolder)
    {
        Directory.CreateDirectory(jsonOutputFolder);
        string[] dicomFiles = Directory.GetFiles(dicomFolder, "*.dcm", SearchOption.AllDirectories);

        foreach (string filePath in dicomFiles)
        {
            try
            {
                DicomFile dcm = DicomFile.Open(filePath);
                string json = DicomJsonSerializer.Serialize(dcm, writeIndented: true);

                string jsonFileName = Path.GetFileNameWithoutExtension(filePath) + ".json";
                string jsonPath = Path.Combine(jsonOutputFolder, jsonFileName);
                await File.WriteAllTextAsync(jsonPath, json);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error exporting {filePath}: {ex.Message}");
            }
        }

        Console.WriteLine($"Individual JSON files saved to {jsonOutputFolder}");
    }
}

Intégration avec les pipelines ML

Le JSON exporté peut être chargé dans divers cadres et outils ML.

Télécharger Python avec Pandas

import json
import pandas as pd

# Load the JSON array
with open('dicom_metadata.json', 'r') as f:
    dicom_data = json.load(f)

# Flatten nested structure for analysis
def extract_values(record):
    result = {}
    for tag, data in record.items():
        if 'Value' in data and data['Value']:
            value = data['Value'][0]
            if isinstance(value, dict) and 'Alphabetic' in value:
                result[tag] = value['Alphabetic']
            else:
                result[tag] = value
    return result

flat_data = [extract_values(record) for record in dicom_data]
df = pd.DataFrame(flat_data)

print(df.head())
print(f"Dataset shape: {df.shape}")

Étiquette dans Elasticsearch

from elasticsearch import Elasticsearch, helpers

es = Elasticsearch(['http://localhost:9200'])

with open('dicom_metadata.json', 'r') as f:
    dicom_data = json.load(f)

def generate_actions(data):
    for i, record in enumerate(data):
        yield {
            '_index': 'dicom_studies',
            '_id': i,
            '_source': record
        }

helpers.bulk(es, generate_actions(dicom_data))
print(f"Indexed {len(dicom_data)} records to Elasticsearch")

Un script de pipeline complet

Voici un script C# complet qui effectue l’ensemble du flux de travail de préparation:

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Anonymization;
using Aspose.Medical.Dicom.Serialization;

class Program
{
    static async Task Main(string[] args)
    {
        string inputFolder = args.Length > 0 ? args[0] : @"C:\DicomSource";
        string outputFolder = args.Length > 1 ? args[1] : @"C:\DicomPrepared";

        Console.WriteLine("=== DICOM Dataset Preparation for AI ===\n");

        // Step 1: Anonymize
        Console.WriteLine("Step 1: Anonymizing DICOM files...");
        var prep = new DicomDatasetPreparation(inputFolder, outputFolder);
        await prep.ProcessDatasetAsync();

        // Step 2: Export metadata to JSON
        Console.WriteLine("\nStep 2: Exporting metadata to JSON...");
        var exporter = new MetadataExporter();
        string anonymizedFolder = Path.Combine(outputFolder, "images");
        string jsonOutput = Path.Combine(outputFolder, "metadata.json");
        await exporter.ExportMetadataToJsonAsync(anonymizedFolder, jsonOutput);

        Console.WriteLine("\n=== Dataset Preparation Complete ===");
        Console.WriteLine($"Anonymized images: {Path.Combine(outputFolder, "images")}");
        Console.WriteLine($"Metadata JSON: {jsonOutput}");
        Console.WriteLine($"ID Mapping: {Path.Combine(outputFolder, "id_mapping.csv")}");
    }
}

Les meilleures pratiques

Safe ID mapping storage est essentiel.La mape entre les identifiants anonymisés et originaux doit être stockée dans un emplacement sécurisé et contrôlé par l’accès séparé des données anonymes.Cela permet la réidentification si nécessaire pour le suivi clinique tout en conservant la vie privée.

Logue toutes les opérations pour la reproductibilité.Enregistrez quels fichiers ont été traités, quand, avec quel profil, et tous les erreurs rencontrées.Cette documentation est essentielle pour les exigences de reproduction de la recherche et de l’audit.

Valider les sorties d’échantillons avant de traiter l’ensemble des ensembles de données. vérifier les fichiers anonymisés pour s’assurer que le profil fonctionne comme prévu et que la qualité des images est préservée.

Considère la partition des données pour les grands ensembles de données.Organisez la sortie selon le type d’étude, la modalité ou autres critères pertinents pour faciliter la sélection des sous-sets pour différentes tâches de formation.

La conclusion (conclusion)

La préparation des données DICOM pour l’intelligence artificielle et l’apprentissage automatique nécessite une attention attentive à la confidentialité, la cohérence et la compatibilité des formats.Utilisant Aspose.Medical pour .NET, vous pouvez construire des pipelines automatisées qui combinent des études anonymisées avec des profils consistent, exporter des métadonnées à JSON pour la mise en œuvre du cadre ML et maintenir des traces d’audit de reproductibilité.

Ce flux de travail garantit que vos données de recherche sont correctement déidentifiées, bien structurées et prêtes pour la prochaine génération d’imagerie médicale.

Pour plus d’informations et de exemples, visitez le Aspose.Documentation médicalePour tester les capacités API complètes, obtenir une licence temporaire gratuite.

More in this category