Generer automatisk indtryk fra fund i radiologirapporter ved hjælp af generativ AI på AWS | Amazon Web Services

Radiologirapporter er omfattende, lange dokumenter, der beskriver og fortolker resultaterne af en radiologisk billeddiagnostisk undersøgelse. I en typisk arbejdsgang overvåger, læser og fortolker radiologen billederne og opsummerer derefter de vigtigste resultater. Opsummeringen (eller indtryk) er den vigtigste del af rapporten, fordi den hjælper klinikere og patienter med at fokusere på det kritiske indhold af rapporten, der indeholder information til klinisk beslutningstagning. At skabe et klart og virkningsfuldt indtryk kræver meget mere indsats end blot at gentage resultaterne. Hele processen er derfor besværlig, tidskrævende og udsat for fejl. Det tager ofte år uddannelse for læger at akkumulere nok ekspertise i at skrive kortfattede og informative radiologirapportresuméer, hvilket yderligere fremhæver betydningen af ​​at automatisere processen. Derudover automatisk generering af rapportresultater er afgørende for radiologirapportering. Det muliggør oversættelse af rapporter til et sprog, der kan læses af mennesker, og letter derved patienternes læsebyrde gennem lange og dunkle rapporter.

For at løse dette problem foreslår vi brugen af ​​generativ AI, en type AI, der kan skabe nyt indhold og nye ideer, herunder samtaler, historier, billeder, videoer og musik. Generativ AI er drevet af maskinlæringsmodeller (ML) - meget store modeller, der er forudtrænede på enorme mængder data og almindeligvis omtalt som fundamentmodeller (FM'er). Nylige fremskridt inden for ML (specifikt opfindelsen af ​​den transformer-baserede neurale netværksarkitektur) har ført til fremkomsten af ​​modeller, der indeholder milliarder af parametre eller variable. Den foreslåede løsning i dette indlæg bruger finjustering af fortrænede store sprogmodeller (LLM'er) for at hjælpe med at generere opsummeringer baseret på resultater i radiologirapporter.

Dette indlæg demonstrerer en strategi til finjustering af offentligt tilgængelige LLM'er til opgaven med at sammenfatte radiologirapporter ved hjælp af AWS-tjenester. LLM'er har demonstreret bemærkelsesværdige evner inden for naturlig sprogforståelse og -generering, og fungerer som grundlagsmodeller, der kan tilpasses til forskellige domæner og opgaver. Der er betydelige fordele ved at bruge en præ-trænet model. Det reducerer beregningsomkostningerne, reducerer COXNUMX-fodaftryk og giver dig mulighed for at bruge avancerede modeller uden at skulle træne en fra bunden.

Vores løsning bruger FLAN-T5 XL FM, ved hjælp af Amazon SageMaker JumpStart, som er en ML-hub, der tilbyder algoritmer, modeller og ML-løsninger. Vi demonstrerer, hvordan du opnår dette ved hjælp af en notesbog i Amazon SageMaker Studio. Finjustering af en fortrænet model involverer yderligere træning i specifikke data for at forbedre ydeevnen på en anden, men relateret opgave. Denne løsning involverer finjustering af FLAN-T5 XL-modellen, som er en forbedret version af T5 (Text-to-Text Transfer Transformer) generelle LLM'er. T5 omformer opgaver til naturlig sprogbehandling (NLP) til et samlet tekst-til-tekst-format, i modsætning til BERTImodeller, der kun kan udskrive enten en klasseetiket eller et spænd af input. Den er finjusteret til en opsummeringsopgave på 91,544 fritekstradiologirapporter indhentet fra MIMIC-CXR datasæt.

Oversigt over løsning

I dette afsnit diskuterer vi nøglekomponenterne i vores løsning: valg af strategi for opgaven, finjustering af en LLM og evaluering af resultaterne. Vi illustrerer også løsningsarkitekturen og trinene til implementering af løsningen.

Identificer strategien for opgaven

Der er forskellige strategier til at nærme sig opgaven med at automatisere opsummering af kliniske rapporter. For eksempel kunne vi bruge en specialiseret sprogmodel, der er fortrænet på kliniske rapporter fra bunden. Alternativt kunne vi direkte finjustere en offentligt tilgængelig generel sprogmodel til at udføre den kliniske opgave. Det kan være nødvendigt at bruge en finjusteret domæneagnostisk model i omgivelser, hvor træning a sprogmodel fra bunden er for dyrt. I denne løsning demonstrerer vi den sidstnævnte tilgang med at bruge en FLAN -T5 XL-model, som vi finjusterer til den kliniske opgave med at opsummere radiologirapporter. Følgende diagram illustrerer modellens arbejdsgang.

En typisk radiologirapport er velorganiseret og kortfattet. Sådanne rapporter har ofte tre nøgleafsnit:

• Baggrund – Giver generel information om patientens demografi med væsentlig information om patienten, klinisk historie og relevant sygehistorie og detaljer om undersøgelsesprocedurer
• Fund – Præsenterer detaljeret eksamensdiagnose og resultater
• udskrivning – Kortfattet opsummerer de mest markante fund eller fortolkning af resultaterne med en vurdering af signifikans og potentiel diagnose baseret på de observerede abnormiteter

Ved hjælp af fundafsnittet i røntgenrapporterne genererer løsningen indtryksafsnittet, som svarer til lægernes opsummering. Følgende figur er et eksempel på en radiologirapport.

Finjuster en generel LLM til en klinisk opgave

I denne løsning finjusterer vi en FLAN-T5 XL-model (tuner alle modellens parametre og optimerer dem til opgaven). Vi finjusterer modellen ved hjælp af det kliniske domænedatasæt MIMIC-CXR, som er et offentligt tilgængeligt datasæt af røntgenbilleder af thorax. For at finjustere denne model gennem SageMaker Jumpstart skal mærkede eksempler leveres i form af {prompt, afslutning}-par. I dette tilfælde bruger vi par af {Findings, Impression} fra de originale rapporter i MIMIC-CXR-datasættet. Til inferencing bruger vi en prompt som vist i følgende eksempel:

Modellen er finjusteret på en accelereret databehandling ml.p3.16xlarge instans med 64 virtuelle CPU'er og 488 GiB hukommelse. Til validering blev 5 % af datasættet udvalgt tilfældigt. Den forløbne tid af SageMaker træningsjob med finjustering var 38,468 sekunder (ca. 11 timer).

Evaluer resultaterne

Når træningen er afsluttet, er det afgørende at evaluere resultaterne. Til en kvantitativ analyse af det genererede indtryk bruger vi RED (Recall-Oriented Understudy for Gisting Evaluation), den mest almindeligt anvendte metrik til evaluering af opsummering. Denne metrik sammenligner et automatisk fremstillet resumé med en reference eller et sæt referencer (menneskeproduceret) resumé eller oversættelse. ROUGE1 refererer til overlapningen af unigrammer (hvert ord) mellem kandidaten (modellens output) og referenceresuméer. ROUGE2 refererer til overlapningen af bigrammer (to ord) mellem kandidat- og referenceresuméet. ROUGEL er en metrik på sætningsniveau og refererer til den længste fælles subsequence (LCS) mellem to stykker tekst. Den ignorerer nye linjer i teksten. ROUGELsum er en metrik på oversigtsniveau. For denne metrik ignoreres linjeskift i teksten ikke, men tolkes som sætningsgrænser. LCS beregnes derefter mellem hvert par af reference- og kandidatsætninger, og derefter beregnes union-LCS. Til aggregering af disse scores over et givet sæt reference- og kandidatsætninger beregnes gennemsnittet.

Gennemgang og arkitektur

Den overordnede løsningsarkitektur som vist i den følgende figur består primært af et modeludviklingsmiljø, der bruger SageMaker Studio, modelimplementering med et SageMaker-slutpunkt og et rapporteringsdashboard vha. Amazon QuickSight.

I de følgende afsnit demonstrerer vi finjustering af en LLM tilgængelig på SageMaker JumpStart til opsummering af en domænespecifik opgave via SageMaker Python SDK. Vi diskuterer især følgende emner:

• Trin til opsætning af udviklingsmiljøet
• En oversigt over de radiologirapportdatasæt, som modellen er finjusteret og evalueret på
• En demonstration af finjustering af FLAN-T5 XL-modellen ved hjælp af SageMaker JumpStart programmatisk med SageMaker Python SDK
• Inferencing og evaluering af de fortrænede og finjusterede modeller
• Sammenligning af resultater fra fortrænede modeller og finjusterede modeller

Løsningen er tilgængelig i Generering af radiologisk rapportindtryk ved hjælp af generativ AI med stor sprogmodel på AWS GitHub repo.

Forudsætninger

For at komme i gang skal du bruge en AWS-konto hvor du kan bruge SageMaker Studio. Du skal oprette en brugerprofil til SageMaker Studio, hvis du ikke allerede har en.

Træningsinstanstypen, der bruges i dette indlæg, er ml.p3.16xlarge. Bemærk, at p3-instansen type kræver en forhøjelse af servicekvotegrænsen.

MIMIC CXR-datasæt kan tilgås via en databrugsaftale, som kræver brugerregistrering og fuldførelse af en legitimationsproces.

Indstil udviklingsmiljøet

For at konfigurere dit udviklingsmiljø opretter du en S3-bucket, konfigurerer en notesbog, opretter slutpunkter og implementerer modellerne og opretter et QuickSight-dashboard.

Opret en S3-spand

Opret en S3-spand kaldet llm-radiology-bucket at være vært for trænings- og evalueringsdatasættene. Dette vil også blive brugt til at gemme modelartefaktet under modeludvikling.

Konfigurer en notesbog

Udfør følgende trin:

1. Start SageMaker Studio fra enten SageMaker-konsollen eller AWS kommandolinjegrænseflade (AWS CLI).

For mere information om onboarding til et domæne, se Ombord på Amazon SageMaker Domain.

2. Opret en ny SageMaker Studio notesbog til rensning af rapportdata og finjustering af modellen. Vi bruger en ml.t3.medium 2vCPU+4GiB notebook-instans med en Python 3-kerne.

3. Inden i notesbogen skal du installere de relevante pakker som f.eks nest-asyncio, IPyWidgets (til interaktive widgets til Jupyter notebook) og SageMaker Python SDK:

!pip install nest-asyncio==1.5.5 --quiet !pip install ipywidgets==8.0.4 --quiet !pip install sagemaker==2.148.0 --quiet

For at udlede de fortrænede og finjusterede modeller, oprette et slutpunkt og implementere hver model i notesbogen som følger:

1. Opret et modelobjekt fra Model-klassen, der kan implementeres til et HTTPS-slutpunkt.
2. Opret et HTTPS-slutpunkt med modelobjektets forudbyggede deploy() metode:

from sagemaker import model_uris, script_uris
from sagemaker.model import Model
from sagemaker.predictor import Predictor
from sagemaker.utils import name_from_base # Retrieve the URI of the pre-trained model
pre_trained_model_uri =model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="inference") large_model_env = {"SAGEMAKER_MODEL_SERVER_WORKERS": "1", "TS_DEFAULT_WORKERS_PER_MODEL": "1"} pre_trained_name = name_from_base(f"jumpstart-demo-pre-trained-{model_id}") # Create the SageMaker model instance of the pre-trained model
if ("small" in model_id) or ("base" in model_id): deploy_source_uri = script_uris.retrieve( model_id=model_id, model_version=model_version, script_scope="inference" ) pre_trained_model = Model( image_uri=deploy_image_uri, source_dir=deploy_source_uri, entry_point="inference.py", model_data=pre_trained_model_uri, role=aws_role, predictor_cls=Predictor, name=pre_trained_name, )
else: # For those large models, we already repack the inference script and model # artifacts for you, so the `source_dir` argument to Model is not required. pre_trained_model = Model( image_uri=deploy_image_uri, model_data=pre_trained_model_uri, role=aws_role, predictor_cls=Predictor, name=pre_trained_name, env=large_model_env, ) # Deploy the pre-trained model. Note that we need to pass Predictor class when we deploy model
# through Model class, for being able to run inference through the SageMaker API
pre_trained_predictor = pre_trained_model.deploy( initial_instance_count=1, instance_type=inference_instance_type, predictor_cls=Predictor, endpoint_name=pre_trained_name,
)

Opret et QuickSight-dashboard

Opret en QuickSight-dashboard med en Athena-datakilde med konklusioner resulterer i Amazon Simple Storage Service (Amazon S3) for at sammenligne slutningsresultaterne med grundsandheden. Følgende skærmbillede viser vores eksempel på dashboard.

Radiologi rapportdatasæt

Modellen er nu finjusteret, alle modelparametre er tunet på 91,544 rapporter downloadet fra MIMIC-CXR v2.0 datasæt. Fordi vi kun brugte radiologirapportens tekstdata, downloadede vi kun én komprimeret rapportfil (mimic-cxr-reports.zip) fra MIMIC-CXR-webstedet. Nu evaluerer vi den finjusterede model på 2,000 rapporter (omtalt som dev1 datasæt) fra den separate holdt ud undersæt af dette datasæt. Vi bruger yderligere 2,000 radiologirapporter (omtalt som dev2) til evaluering af den finjusterede model fra røntgenkollektionen fra thorax Indiana University hospital netværk. Alle datasæt læses som JSON-filer og uploades til den nyoprettede S3-bøtte llm-radiology-bucket. Bemærk, at alle datasæt som standard ikke indeholder nogen beskyttet sundhedsinformation (PHI); alle følsomme oplysninger erstattes med tre på hinanden følgende understregninger (___) af udbyderne.

Finjuster med SageMaker Python SDK

Til finjustering model_id er angivet som huggingface-text2text-flan-t5-xl fra listen over SageMaker JumpStart-modeller. Det training_instance_type er indstillet til ml.p3.16xlarge og den inference_instance_type som ml.g5.2xlarge. Træningsdataene i JSON-format læses fra S3-bøtten. Næste trin er at bruge det valgte model_id til at udtrække SageMaker JumpStart-ressource-URI'erne, inklusive image_uri (Den Amazon Elastic Container Registry (Amazon ECR) URI til Docker-billedet), model_uri (den fortrænede modelartefakt Amazon S3 URI), og script_uri (træningsmanuskriptet):

from sagemaker import image_uris, model_uris, script_uris # Training instance will use this image
train_image_uri = image_uris.retrieve( region=aws_region, framework=None, # automatically inferred from model_id model_id=model_id, model_version=model_version, image_scope="training", instance_type=training_instance_type,
) # Pre-trained model
train_model_uri = model_uris.retrieve( model_id=model_id, model_version=model_version, model_scope="training"
) # Script to execute on the training instance
train_script_uri = script_uris.retrieve( model_id=model_id, model_version=model_version, script_scope="training"
) output_location = f"s3://{output_bucket}/demo-llm-rad-fine-tune-flan-t5/"

En outputplacering er også konfigureret som en mappe i S3-bøtten.

Kun én hyperparameter, epoker, ændres til 3, og resten er alle indstillet som standard:

from sagemaker import hyperparameters # Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version) # We will override some default hyperparameters with custom values
hyperparameters["epochs"] = "3"
print(hyperparameters)

Træningsmålingerne som f.eks eval_loss (for valideringstab), loss (ved træningstab), og epoch der skal spores, er defineret og listet:

from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base model_name = "-".join(model_id.split("-")[2:]) # get the most informative part of ID
training_job_name = name_from_base(f"js-demo-{model_name}-{hyperparameters['epochs']}")
print(f"{bold}job name:{unbold} {training_job_name}") training_metric_definitions = [ {"Name": "val_loss", "Regex": "'eval_loss': ([0-9.]+)"}, {"Name": "train_loss", "Regex": "'loss': ([0-9.]+)"}, {"Name": "epoch", "Regex": "'epoch': ([0-9.]+)"},
]

Vi bruger SageMaker JumpStart ressource-URI'er (image_uri, model_uri, script_uri) identificeret tidligere for at oprette en estimator og finjustere den på træningsdatasættet ved at angive S3-stien til datasættet. Estimator-klassen kræver en entry_point parameter. I dette tilfælde bruger JumpStart transfer_learning.py. Træningsjobbet kører ikke, hvis denne værdi ikke er indstillet.

# Create SageMaker Estimator instance
sm_estimator = Estimator( role=aws_role, image_uri=train_image_uri, model_uri=train_model_uri, source_dir=train_script_uri, entry_point="transfer_learning.py", instance_count=1, instance_type=training_instance_type, volume_size=300, max_run=360000, hyperparameters=hyperparameters, output_path=output_location, metric_definitions=training_metric_definitions,
) # Launch a SageMaker training job over data located in the given S3 path
# Training jobs can take hours, it is recommended to set wait=False,
# and monitor job status through SageMaker console
sm_estimator.fit({"training": train_data_location}, job_name=training_job_name, wait=True)

Dette træningsjob kan tage timer at fuldføre; derfor anbefales det at indstille venteparameteren til False og overvåge træningsjobstatus på SageMaker-konsollen. Brug TrainingJobAnalytics funktion til at holde styr på træningsmålingerne ved forskellige tidsstempler:

from sagemaker import TrainingJobAnalytics # Wait for a couple of minutes for the job to start before running this cell
# This can be called while the job is still running
df = TrainingJobAnalytics(training_job_name=training_job_name).dataframe()

Implementer inferensendepunkter

For at drage sammenligninger implementerer vi inferens-endepunkter for både de fortrænede og finjusterede modeller.

Hent først inferensen Docker image URI ved hjælp af model_id, og brug denne URI til at oprette en SageMaker-modelforekomst af den forudtrænede model. Implementer den forudtrænede model ved at oprette et HTTPS-slutpunkt med modelobjektets forudbyggede deploy() metode. For at køre inferens gennem SageMaker API skal du sørge for at bestå Predictor-klassen.

from sagemaker import image_uris
# Retrieve the inference docker image URI. This is the base HuggingFace container image
deploy_image_uri = image_uris.retrieve( region=aws_region, framework=None, # automatically inferred from model_id model_id=model_id, model_version=model_version, image_scope="inference", instance_type=inference_instance_type,
) # Retrieve the URI of the pre-trained model
pre_trained_model_uri = model_uris.retrieve( model_id=model_id, model_version=model_version, model_scope="inference"
) pre_trained_model = Model( image_uri=deploy_image_uri, model_data=pre_trained_model_uri, role=aws_role, predictor_cls=Predictor, name=pre_trained_name, env=large_model_env, ) # Deploy the pre-trained model. Note that we need to pass Predictor class when we deploy model
# through Model class, for being able to run inference through the SageMaker API
pre_trained_predictor = pre_trained_model.deploy( initial_instance_count=1, instance_type=inference_instance_type, predictor_cls=Predictor, endpoint_name=pre_trained_name,
)

Gentag det foregående trin for at oprette en SageMaker-modelforekomst af den finjusterede model og oprette et slutpunkt til at implementere modellen.

Vurder modellerne

Indstil først længden af ​​opsummeret tekst, antallet af modeloutput (skal være større end 1, hvis der skal genereres flere opsummeringer) og antallet af stråler for strålesøgning.

Konstruer slutningsanmodningen som en JSON-nyttelast, og brug den til at forespørge om slutpunkterne for de forudtrænede og finjusterede modeller.

Beregn det aggregerede ROUGE scorer (ROUGE1, ROUGE2, ROUGEL, ROUGELsum) som beskrevet tidligere.

Sammenlign resultaterne

Følgende tabel viser evalueringsresultaterne for dev1 , dev2 datasæt. Evalueringsresultatet vedr dev1 (2,000 fund fra MIMIC CXR Radiology Report) viser en forbedring på ca. 38 procentpoint i det aggregerede gennemsnit ROUGE1 og ROUGE2 score sammenlignet med den fortrænede model. For dev2 observeres en forbedring på 31 procentpoint og 25 procentpoint i ROUGE1 og ROUGE2 score. Samlet set førte finjustering til en forbedring på 38.2 procentpoint og 31.3 procentpoint i ROUGELsum-score for dev1 , dev2 datasæt, hhv.

Følgende boksplot viser fordelingen af ​​ROUGE-score for dev1 , dev2 datasæt evalueret ved hjælp af den finjusterede model.

(en): dev1	(b): dev2

Følgende tabel viser, at ROUGE-score for evalueringsdatasættene har omtrent samme median og middelværdi og derfor er symmetrisk fordelt.

Ryd op

For at undgå fremtidige gebyrer skal du slette de ressourcer, du har oprettet med følgende kode:

# Delete resources
pre_trained_predictor.delete_model()
pre_trained_predictor.delete_endpoint()
fine_tuned_predictor.delete_model()
fine_tuned_predictor.delete_endpoint()

Konklusion

I dette indlæg demonstrerede vi, hvordan man finjusterer en FLAN-T5 XL-model til en klinisk domænespecifik opsummeringsopgave ved hjælp af SageMaker Studio. For at øge tilliden sammenlignede vi forudsigelserne med sandheden og evaluerede resultaterne ved hjælp af ROUGE-metrics. Vi demonstrerede, at en model, der er finjusteret til en specifik opgave, giver bedre resultater end en model, der er fortrænet på en generisk NLP-opgave. Vi vil gerne påpege, at finjustering af en LLM til generelle formål helt eliminerer omkostningerne ved fortræning.

Selvom det arbejde, der præsenteres her, fokuserer på røntgenrapporter af thorax, har det potentiale til at blive udvidet til større datasæt med forskellige anatomier og modaliteter, såsom MR og CT, for hvilke radiologirapporter kan være mere komplekse med flere fund. I sådanne tilfælde kunne radiologer generere indtryk i rækkefølge efter kritikalitet og inkludere opfølgningsanbefalinger. Desuden vil opsætning af en feedback-loop til denne applikation gøre det muligt for radiologer at forbedre modellens ydeevne over tid.

Som vi viste i dette indlæg, genererer den finjusterede model indtryk for radiologirapporter med høje ROUGE-score. Du kan prøve at finjustere LLM'er på andre domænespecifikke medicinske rapporter fra forskellige afdelinger.

Om forfatterne

Dr. Adewale Akinfaderin er Senior Data Scientist i Healthcare and Life Sciences hos AWS. Hans ekspertise er i reproducerbare og end-to-end AI/ML-metoder, praktiske implementeringer og at hjælpe globale sundhedskunder med at formulere og udvikle skalerbare løsninger på tværfaglige problemer. Han har to kandidatgrader i fysik og en doktorgrad i ingeniør.

Priya Padate er en Senior Partner Solutions Architect med omfattende ekspertise inden for Healthcare og Life Sciences hos AWS. Priya driver go-to-market-strategier med partnere og driver løsningsudvikling for at accelerere AI/ML-baseret udvikling. Hun brænder for at bruge teknologi til at transformere sundhedsindustrien for at skabe bedre resultater for patientbehandling.

Ekta Walia Bhullar, PhD, er en senior AI/ML-konsulent hos AWS Healthcare and Life Sciences (HCLS) forretningsenhed for professionel service. Hun har stor erfaring med anvendelse af AI/ML inden for sundhedsområdet, især inden for radiologi. Uden for arbejdet, når hun ikke diskuterer AI i radiologi, kan hun lide at løbe og vandre.

• SEO Powered Content & PR Distribution. Bliv forstærket i dag.
• PlatoData.Network Vertical Generative Ai. Styrk dig selv. Adgang her.
• PlatoAiStream. Web3 intelligens. Viden forstærket. Adgang her.
• PlatoESG. Automotive/elbiler, Kulstof, CleanTech, Energi, Miljø, Solenergi, Affaldshåndtering. Adgang her.
• PlatoHealth. Bioteknologiske og kliniske forsøgs intelligens. Adgang her.
• ChartPrime. Løft dit handelsspil med ChartPrime. Adgang her.
• BlockOffsets. Modernisering af miljømæssig offset-ejerskab. Adgang her.
• Kilde: https://aws.amazon.com/blogs/machine-learning/automatically-generate-impressions-from-findings-in-radiology-reports-using-generative-ai-on-aws/