AI i aprenentatge de màquina estan transformant la imatge mèdica, però la formació d’aquests models requereix grans set de dades adequadament anònims. En aquest guia, aprendràs com pre DICOM per a la investigació de la AI utilitzant un flux de treball complet que combina l’anonimatització de batxies amb les exportacions de metadades JSON per la integració sense segell en els tubs ML.

Taula de continguts

Per què la investigació intel·ligent necessita dades anònimes de DICOM {#per què-ai-investigació-needs-anònomes-dicom-data}

Els models d’IA de la imatge mèdica per al diagnòstic, la segmentació i la detecció requereixen dades de formació substancials. Aquestes dades han de ser adequadament anònimes per complir amb les polítiques HIPAA, GDPR i institucionals. A més, les col·laboracions de recerca sovint s’estenen a diverses institucions, fent que la de-identificació estàndard és essencial.

La correcta preparació del conjunt de dades implica més que simplement eliminar els noms dels pacients. requereix el tractament sistemàtic de tota la informació identificadora, l’aplicació coherent de les regles d’anonimatització a través de milers de fitxers, i la conversió de format que fa que les dades siguin accessibles als marc ML.

Els riscos de la preparació d’un sistema de dades incorrecte

L’ús de conjunts de dades parcialment anònims o incorrectament estructurats crea problemes significatius. La anonimatització incompleta pot exposar informació del pacient, conduint a violacions regulamentals i infraccions ètiques. l’anonimatzació incoherent a través d’un conjunt de datos pot introduir problemes de qualitat o dades. Metadades inconstructuades fa que sigui difícil filtrar, sol·licitar i preprocessar les dades per a la formació de model.

Aquests riscos són mitigats mitjançant l’ús de tubs d’anonimització automatitzats i consistents i la conversió de dades en formats amistosos a la màquina.

Flux de treball de preparació completa

El flux de treball complet consisteix en quatre etapes. primer, el grup anònimitza els estudis DICOM utilitzant perfils coherents. segon, convertir metadades anonimitzades a JSON per a la ingestió de pipeline. tercer, emmagatzemar imatges i metades per accedir al marc ML. quart, mantenir el mapeig entre els identificadors anònims i originals en un magatzem segur.

Implementem cada etapa amb exemples de codi.

Anònims de batxillerat

Comencem anonimitzant la vostra col·lecció DICOM amb un perfil consistent:

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 metadades a JSON

Després de l’anonimatització, convertir els metadats a JSON per a la ingesta de tub 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}");
    }
}

Integració amb els tubs ML

El JSON exportat es pot carregar en diversos quadres ML i eines.

Carregar en Python amb 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}")

Introducció a 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")

Escriptura de pipeline completa

Aquí teniu un complet script C# que realitza tot el flux de treball de preparació:

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 millors pràctiques

L’emmagatzematge entre els identificadors anònims i originals ha de ser emmagatzemat en un lloc segur i controlat d’accés separat dels dades anonimitzats.

Logueu totes les operacions per a la reproductibilitat.Recordeu quins arxius s’han processat, quan, amb quin perfil, i qualsevol error que hagi trobat.Aquesta documentació és crítica per als requisits de reproductivitat de la investigació i auditoria.

Valida les sortides de mostre abans de processar tota la sèrie de dades. comprova els arxius anònims per assegurar-se que el perfil funciona com s’esperava i que la qualitat de la imatge es manté.

** Considera la partició de dades** per a grans grups de datos. Organitza la producció per tipus d’estudi, modalitat o altres criteris rellevants per facilitar la selecció dels subset per diferents tasques de formació.

La conclusió

La preparació de set de dades DICOM per a la intel·ligència artificial i l’aprenentatge màquina requereix una atenció cuidada en la privacitat, la consistència i la compatibilitat de format. Utilitzant Aspose.Medical per .NET, es poden construir tubs automatitzats que combinin estudis anònims amb perfils coherents, exportar metadades a JSON per la ingestió del marc ML, i mantenir les pistes d’audit per reproductibilitat.

Aquest flux de treball assegura que les seves dades de recerca estan correctament desidentificades, ben estructurades i preparades per a la pròxima generació d’Imació Mèdica.

Per a més informació i exemples, visiteu el Aspose.Documentació mèdicaPer provar les capacitats API completes, Obtenir una llicència temporal gratuïta.

More in this category