Az AI és a gépi tanulás átalakítja az orvosi képet, de ezeknek a modelleknek a képzése nagy, megfelelően anonimizált adatkészleteket igényel. Ebben az útmutatóban megtanulhatja, hogyan készítsen egy teljes munkafolyamatot a DICOM-adatkészletek AI kutatáshoz**, amely összekapcsolja az anonimációt a JSON metadatok exportjával az ML csővezetékekbe való homály nélküli integrációhoz.

Tartalmak táblája

Miért van szükség az AI Kutatás Anonim DICOM adatokat

Az orvosi képalkotási AI modellek diagnosztizálására, szegmensítésére és kimutatására lényeges képzési adatokat igényelnek. Ezek az adatoknak megfelelően anonimizálva kell lenniük a HIPAA, a GDPR és az intézményi politikáknak való megfelelés érdekében. Ezenkívül a kutatási együttműködés gyakran több intézményt terjed ki, így a szabványosított de-identifikáció elengedhetetlen.

A megfelelő adatkészlet előkészítése több, mint egyszerűen a betegek nevének eltávolítása. Szisztematikus kezelést igényel az összes azonosító információ, az anonimizációs szabályok következetes alkalmazása több ezer fájlban, és a formatervezés, amely az adatokat az ML keretekhez hozzáférhetővé teszi.

A rossz adatkészítés kockázata

A részben névtelen vagy helytelenül strukturált adatkészletek használatával jelentős problémák merülnek fel. A hiányos névtelenség a páciens információit kimutathatja, ami szabályozási és etikai megsértésekhez vezet. Az adatok szerkezetén belüli következetlenség nélküli anonimizáció hibákat vagy adatminőségi problémákat hozhat létre. Anstruktív metadatok nehezítik a szűrést, a lekérdezéseket és a preprocess adatokat a modellképzéshez.

Ezek a kockázatok enyhülnek az automatizált, következetes névtelenítési csővezetékek használatával és az adatok gépi formátumokra történő átalakításával.

Teljes előkészítő munkafolyamat

A teljes munkafolyamat négy szakaszból áll. Először is, a DICOM tanulmányokat konzisztenciális profilokkal anonimizáljuk. Másodszor, az anonim metadatok átalakítása a JSON-ba a csővezetékbe való beilleszkedéshez. Harmadszor a képek és a metadatok tárolása az ML keretrendszerhez való hozzáférésre. Negyedszer az anonimitált és az eredeti ID-k közötti mappázást biztonságos tárolásban tartjuk fenn.

Végezzük el az egyes szakaszokat kód példákkal.

Batch Anonymizálás

Kezdjük azzal, hogy a DICOM gyűjteményét egy következetes profilmal anonimizáljuk:

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

Metadata átalakítása JSON

Az anonimizálás után a metadát JSON-ra konvertáljuk az ML csővezeték befogadásához:

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

Az ML csővezetékekkel való integráció

Az exportált JSON-t különböző ML keretekbe és eszközökbe lehet feltölteni.

Töltse fel a Python-ot Pandával

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

Összefoglaló 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")

Tökéletes Pipeline Script

Íme egy teljes C# forgatókönyv, amely teljes előkészítő munkafolyamatot hajt végre:

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

A legjobb gyakorlatok (Best Practices)

Az anonimizált és az eredeti azonosítók közötti mappázást biztonságos, hozzáférés-ellenőrzött helyen kell tárolni, külön a névtelen adatoktól. Ez lehetővé teszi a klinikai nyomon követéshez szükséges újraazonosítást, miközben a magánéletet fenntartja.

Megjegyezze az összes műveletet a reprodukálhatóság céljából. rögzítse, hogy mely fájlokat feldolgozták, mikor, melyik profilmal, és bármilyen hibát találtak.

Validálja a minta kimenetelét az egész adatkészlet feldolgozását megelőzően.A profil várhatóan működik és a képminőség megőrzése érdekében ellenőrizze az anonimizált fájlokat.

**A nagy adatkészletekre vonatkozó adatok részlegelését figyelembe véve.A tanulmány típusa, módszere vagy egyéb releváns kritériumok alapján szervezze az eredményt, hogy megkönnyítse a különböző képzési feladatok alrendszerének kiválasztását.

A következtetés

A DICOM adatkészletek előkészítése az AI és a gépi tanulás érdekében gondos figyelmet igényel a magánélet, a konzisztencia, valamint a formatervezési kompatibilitás iránt. Az Aspose.Medical for .NET használatával automatizált csővezetékeket építhet, amelyek anonimizálják a tanulmányokat a következetes profilokkal, exportálnak metadatait a JSON-hoz az ML keretrendszer beviteléhez, és ellenőrizhetik a reprodukálhatóság ellenőrzési útvonalait.

Ez a munkafolyamat biztosítja, hogy a kutatási adatok megfelelően azonosított, jól strukturált, és készen áll a következő generációs orvosi képalkotó AI.

További információkért és példákért látogasson el a Gyógyszertár - orvosi dokumentációA teljes API képességek kipróbálása, Ingyenes ideiglenes licenc.

More in this category