AI și învățarea mașinilor transformă imaginea medicală, dar formarea acestor modele necesită seturi de date mari, adecvat anonimizate. în acest ghid, veți învăța cum să preparați seturile de informații DICOM pentru cercetarea AI folosind un flux de lucru complet care combină anonimizarea batch-ului cu exportul metadata JSON pentru integrarea fără fir în tuburile ML.

Tabelul conținutului

De ce AI Research are nevoie de date DICOM anonimizate

Modelele de imagini medicale AI pentru diagnostic, segmentare și detectare necesită date de formare substanțiale. Aceste date trebuie să fie anonimizate în mod corespunzător pentru a respecta HIPAA, GDPR și politicile instituționale. În plus, colaborările de cercetare adesea extind mai multe instituții, ceea ce face de-identificare standardizată esențială.

Pregătirea corectă a setului de date implică mai mult decât pur și simplu îndepărtarea numelor pacienților. necesită gestionarea sistematică a tuturor informațiilor de identificare, aplicarea consecventă a regulilor de anonimizare pe mii de fișiere și conversia formatului care face datele accesibile cadrelor ML.

Riscuri pentru prepararea unui set de date incorect

Utilizarea seturilor de date parțial anonimizate sau neconstrucționate creează probleme semnificative. Anonimizarea incompletă poate expune informațiile pacienților, ceea ce duce la încălcări de reglementare și înșelăciuni etice. anonymizarea inconsistentă prin intermediul unui set de informații poate introduce probleme de calitate a datelor. Metadata nestrukturată face dificilă filtrarea, interogarea și prelucrarea datelor pentru formarea modelului.

Aceste riscuri sunt mitigate prin utilizarea unor pipelini de anonimizare automatizate și coerente și prin convertirea datelor în formate prietenoase cu mașina.

Flux de lucru complet de pregătire

Fluxul de lucru complet este format din patru etape. În primul rând, batch anonimizează studiile DICOM folosind profiluri consistente. pe de altă parte, convertează metadate anonime la JSON pentru intrarea în pipeline. al treilea, stocați imagini și metadata pentru accesul la cadru ML. Pe de al patrulea, păstrați hărțuirea între ID-uri anonimizate și originale în stocare sigură.

Să punem în aplicare fiecare etapă cu exemple de cod.

Anonimizarea batch-ului

Începeți prin anonimizarea colecției DICOM cu un profil 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}");
    }
}

Convertarea metadata la JSON

După anonimizare, convertiți metadata la JSON pentru ingestia tubului 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}");
    }
}

Integrație cu pipe ML

JSON-ul exportat poate fi încărcat în diferite cadre și instrumente ML.

Încărcarea în Python cu 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}")

Etichetă: 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")

Scrisoare completă Pipeline

Iată un script complet C# care execută întregul flux de lucru de pregătire:

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

Cele mai bune practici

Safe ID mapping stocare este esențială.Mapingul între identificatorii anonimi și originali ar trebui să fie stocat într-o locație sigură, controlată de acces separat de datele anonime.Acest lucru permite reidentificarea dacă este necesar pentru urmărirea clinică, menținând în același timp confidențialitatea.

Înregistrează toate operațiunile pentru reproducere. înregistrați care fișiere au fost prelucrate, când, cu ce profil și orice erori întâmpinate.

Validați rezultatele de eșantion înainte de prelucrarea întregului set de date. verificați fișierele anonime pentru a se asigura că profilul funcționează așa cum se așteaptă și că calitatea imaginii este păstrată.

Trebuie să se ia în considerare partiționarea datelor pentru seturile mari de date.Organizează rezultatul prin tipul de studiu, modalitatea sau alte criterii relevante pentru a facilita selectarea subsetelor pentru diferite sarcini de formare.

Concluziune #conclusie

Pregătirea seturilor de date DICOM pentru AI și învățarea mașinilor necesită o atenție atentă la confidențialitate, coerență și compatibilitate cu formatele. folosind Aspose.Medical pentru .NET, puteți construi tuburi automatizate care combină studiile de anonimizare cu profiluri consistente, exportați metadate la JSON pentru ingestia cadrului ML și mențineți căi de audit pentru reproducere.

Acest flux de lucru vă asigură că datele dvs. de cercetare sunt de-identificate în mod corespunzător, bine structurate și pregătite pentru următoarea generație de imagini medicale AI.

Pentru mai multe informații și exemple, vizitați Aspose.Documentație medicalăPentru a încerca toate capacitățile API, Obțineți o licență temporară gratuită.

More in this category