AI a strojové učení transformují lékařskou obrazovku, ale školení těchto modelů vyžaduje velké, řádně anonymizované datové sady.V tomto průvodci se dozvíte, jak pripravit datová sady DICOM pro výzkum AI pomocí kompletního pracovního toku, který kombinuje anonymizaci souboru s vývozem metadata JSON pro bezdrátovou integraci do potrubí ML.

Tabulka obsahů

Proč AI výzkum potřebuje anonymizované údaje DICOM

Modely zdravotnického umění pro diagnostiku, segmentování a detekci vyžadují podstatné školení. Tyto údaje musí být řádně anonymizovány, aby byly v souladu s HIPAA, GDPR a institucionálními politikami. Kromě toho, výzkumná spolupráce často rozšiřuje více institucí, což je nezbytné pro standardizované de-identifikace.

Správná příprava databáze zahrnuje více než jen odstranění jmen pacientů. vyžaduje systematickou manipulaci se všemi identifikačními informacemi, konzistentní uplatňování pravidel anonymizace přes tisíce souborů a formátovou konverzi, která činí údaje přístupnými k ML rámcům.

Rizika správné přípravy databáze

Použití částečně anonymizovaných nebo nesprávně strukturovaných datových souborů vytváří významné problémy. Neúplná anonymizace může vystavovat informace o pacientovi, což vede k porušování právních předpisů a etickým porušením. Neslučitelná anonimizace prostřednictvím datové sady může vést k problémům s kvalitou dat nebo nekonstrukční metadata ztěžuje filtrování, vyhledávání a předběžné zpracování dat pro modelové školení.

Tyto rizika se zmírňují pomocí automatizovaných, konzistentních anonymizačních potrubí a konverzí dat do strojově přívětivých formátů.

Kompletní přípravný pracovní proud

Kompletní pracovní tok se skládá ze čtyř fází. První, batch anonymizuje studie DICOM pomocí konzistentních profilů. Druhý, převést anonymní metadata do JSON pro zásobování potrubí. Třetí, ukládat obrázky a metadat pro přístup k ML rámu.

Pojďme provést každou fázi s kódovými příklady.

Anonymizace batchů

Začněte anonymizováním kolekce DICOM s konzistentním profilem:

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}");
    }
}

Převod metadata na JSON

Po anonymizaci konvertujte metadata do JSON pro vstřikování potrubí 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}");
    }
}

Integrace s ml potrubí

Exportovaný JSON lze načítat do různých ML rámů a nástrojů.

Stáhnout do Pythonu s Pandami

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}")

Vyhledávání v 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")

Kompletní potrubní skript

Zde je kompletní skript C#, který provádí celý přípravný pracovní tok:

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")}");
    }
}

Nejlepší postupy

Bezpečné ukládání mapování ID je nezbytné.Mapování mezi anonymizovanými a původními identifikátory by mělo být uloženo v bezpečném, přístupově kontrolovaném místě odděleném od anonymizačních údajů.Toto umožňuje opětovnou identifikaci v případě potřeby pro klinické sledování při zachování soukromí.

Zaznamenávejte všechny operace pro reprodukovatelnost. zaznamenáváte, které soubory byly zpracovány, kdy, s jakým profilem a jakékoli chyby se vyskytly.

Validujte vzorkové výstupy před zpracováním celých datových souborů.Spot-check anonymizované soubory, aby se ujistil, že profil pracuje podle očekávání a že kvalita obrazu je zachována.

Vezměte v úvahu partitioning dat pro velké databáze. organizujte výsledek podle typu studia, modality nebo jiných relevantních kritérií, abyste usnadnili výběr subsetů pro různé vzdělávací úkoly.

Závěrečný závěr

Příprava datových setů DICOM pro AI a strojové učení vyžaduje pečlivou pozornost na soukromí, konzistenci a kompatibilitu formátů. Pomocí Aspose.Medical pro .NET můžete vytvořit automatizované potrubia, které kombinují anonymizace studií s konzistentními profily, exportovat metadata do JSON pro vstřikování rámce ML a udržovat auditní stopy pro reprodukovatelnost.

Tento tok práce zajišťuje, že vaše výzkumné údaje jsou řádně de-identifikovány, dobře strukturované a připravené pro další generaci lékařské imaging AI.

Pro více informací a příkladů navštivte Aspose. lékařská dokumentacePro zkoušku plné kapacity API, Získejte bezplatnou dočasnou licenci.

More in this category