from tkinter import E import torch import torch.nn as nn import torch.nn.functional as F import json import openai import matplotlib.pyplot as plt import numpy as np import io from PIL import Image import base64 from monai.networks.nets import DynUNet from Segmentation.dynunet_pipeline.create_network import get_kernels_strides from Segmentation.dynunet_pipeline.task_params import deep_supr_num from Synthesis.Segmentation.TumorGeneration.utils import synt_model_prepare, synthesize_tumor from Survival.model.aggregator_wMask import aggregator_wMask from dataset import ImageDataset from torch.utils.data import DataLoader import random from tqdm import tqdm from openai import OpenAI class Policy: def __init__(self, api_key): self.client = OpenAI(api_key=api_key) def get_drug_embolism_sets(self, prompt): try: response = self.client.chat.completions.create( model="gpt-4o", messages=[ {"role": "system", "content": ( "You are a medical AI assistant. Based on clinical guidelines, generate a JSON with 'drug_set' and 'embolism_set' for TACE treatment.")}, {"role": "user", "content": prompt} ], temperature=0.2, ) content = response.choices[0].message.content result = json.loads(content) return result.get("drug_set", []), result.get("embolism_set", []) except Exception as e: print(f"[GPT-4o Text Prompt Error] {e}") return [], [] def get_drug_embolism_sets_with_image(self, prompt, image_bytes): try: image_base64 = base64.b64encode(image_bytes.getvalue()).decode() response = self.client.chat.completions.create( model="gpt-4o", messages=[ {"role": "system", "content": ( "You are a medical AI assistant. Based on the CT image and prompt, return a JSON with 'drug_set' and 'embolism_set' for TACE treatment.")}, {"role": "user", "content": [ {"type": "text", "text": prompt}, {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}} ]} ], temperature=0.2, ) content = response.choices[0].message.content result = json.loads(content) return result.get("drug_set", []), result.get("embolism_set", []) except Exception as e: print(f"[GPT-4o Image+Text Prompt Error] {e}") return [], [] class SegmentationModel(nn.Module): def __init__(self, model_path): super(SegmentationModel, self).__init__() task_id = 'custom' kernels, strides = get_kernels_strides(task_id) self.model = DynUNet( spatial_dims=3, in_channels=1, out_channels=3, kernel_size=kernels, strides=strides, upsample_kernel_size=strides[1:], norm_name="instance", deep_supervision=False, deep_supr_num=deep_supr_num[task_id], ) self.model.load_state_dict(torch.load(model_path)['state_dict']) def forward(self, x): seg_pred = self.model(x) return seg_pred class TumorGenerativeWorldModel(nn.Module): def __init__(self, device, cfg): super(TumorGenerativeWorldModel, self).__init__() self.vqgan, self.tester = synt_model_prepare( device=device, cfg=cfg, ) def forward(self, x, tumor_mask, action): generated_volumes, blur_mask = synthesize_tumor( ct_volume=x, tumor_mask=tumor_mask, # organ_type=cfg.model.organ, vqgan=self.vqgan, tester=self.tester, text_description=action ) return generated_volumes, blur_mask class InverseDynamics(nn.Module): def __init__(self, model_path): super(InverseDynamics, self).__init__() from Survival.config import create_arg_parser args = create_arg_parser() self.model = aggregator_wMask(args) loc = "cuda:0" self.model.load_state_dict(torch.load(model_path, map_location=loc)["state_dict"]) def forward(self, x, gen_x, tumor_mask, pred_mask): risk_score,_,_,_ = self.model([x, gen_x], [tumor_mask, pred_mask]) return risk_score def get_conflicting_drugs(drug): # Rule 1 conflicts = { 'Oxaliplatin': ['Lobaplatin', 'Cisplatin'], 'Lobaplatin': ['Oxaliplatin', 'Cisplatin'], 'Cisplatin': ['Oxaliplatin', 'Lobaplatin'], 'Epirubicin': ['Idarubicin', 'THP'], 'Idarubicin': ['Epirubicin', 'THP'], 'THP': ['Epirubicin', 'Idarubicin'] } return conflicts.get(drug, []) def get_conflicting_embolisms(emb): # Rule 2 conflicts = { 'Absolute Alcohol': ['PVA'], 'PVA': ['Absolute Alcohol', 'Gelatin Sponge'], 'Gelatin Sponge': ['PVA'] } return conflicts.get(emb, []) def has_conflicts(item, plan, is_drug=True): if is_drug: conflicts = get_conflicting_drugs(item) else: conflicts = get_conflicting_embolisms(item) return any(conflict in plan for conflict in conflicts) def argmin_drug(fgm_model, hsurv_model, hseg_model, x, tumor_mask, drug_set, plan, scores, T): best_score = scores best_drug = None # 1. Filter out used drugs and conflicting drugs available_drugs = [d for d in drug_set if d not in plan and not has_conflicts(d, plan, is_drug=True)] if not available_drugs: return None, best_score # 2. Batch processing, each batch processes 2 drugs BATCH_SIZE = 1 scaler = torch.cuda.amp.GradScaler() for i in range(0, len(available_drugs), BATCH_SIZE): batch_drugs = available_drugs[i:i + BATCH_SIZE] # 3. Build the actions for the current batch base_action = ';'.join(plan) actions = [] for d in batch_drugs: action = d if not base_action else base_action + ';' + d actions.extend([action] * T) # 4. Build the input for the current batch batch_size = len(batch_drugs) x_batch = x.repeat(batch_size, 1, 1, 1, 1) tumor_mask_batch = tumor_mask.repeat(batch_size, 1, 1, 1, 1) # 5. Use mixed precision to calculate the score of the current batch # with torch.cuda.amp.autocast(): with torch.no_grad(): gen_x, gen_mask = fgm_model(x_batch, tumor_mask_batch, actions) pred_mask = hseg_model(gen_x) pred_mask = torch.softmax(pred_mask, 1) pred_mask = torch.argmax(pred_mask, dim=1).unsqueeze(1) # print(gen_x.shape, pred_mask.shape, tumor_mask_batch.shape, tumor_mask_post_batch.shape) scores_batch = hsurv_model(x_batch, gen_x, tumor_mask_batch, pred_mask) scores_batch = scores_batch.view(batch_size, T).mean(dim=1) # 6. Update the best score min_score_idx = torch.argmin(scores_batch) min_score = scores_batch[min_score_idx] if min_score < best_score: best_score = min_score best_drug = batch_drugs[min_score_idx] print('score:', min_score, 'best_score:', best_score) # 7. Clean up memory del gen_x, gen_mask, pred_mask, scores_batch torch.cuda.empty_cache() return best_drug, best_score def argmin_embolism(fgm_model, hsurv_model, hseg_model, x, tumor_mask, embolism_set, plan, scores, T): best_score = scores best_emb = None # 1. Filter out used embolisms and conflicting embolisms available_embs = [e for e in embolism_set if e not in plan and not has_conflicts(e, plan, is_drug=False)] if not available_embs: return None, best_score # 2. Batch processing, each batch processes 2 embolisms BATCH_SIZE = 1 scaler = torch.cuda.amp.GradScaler() for i in range(0, len(available_embs), BATCH_SIZE): batch_embs = available_embs[i:i + BATCH_SIZE] # 3. Build the actions for the current batch base_action = ';'.join(plan) actions = [] for e in batch_embs: action = e + ';' if not base_action else base_action + ';' + e actions.extend([action] * T) # 4. Build the input for the current batch batch_size = len(batch_embs) x_batch = x.repeat(batch_size, 1, 1, 1, 1) tumor_mask_batch = tumor_mask.repeat(batch_size, 1, 1, 1, 1) # 5. Use mixed precision to calculate the score of the current batch # with torch.cuda.amp.autocast(): with torch.no_grad(): gen_x, gen_mask = fgm_model(x_batch, tumor_mask_batch, actions) pred_mask = hseg_model(gen_x) pred_mask = torch.softmax(pred_mask, 1) pred_mask = torch.argmax(pred_mask, dim=1).unsqueeze(1) scores_batch = hsurv_model(x_batch, gen_x, tumor_mask_batch, pred_mask) scores_batch = scores_batch.view(batch_size, T).mean(dim=1) # 6. Update the best score min_score_idx = torch.argmin(scores_batch) min_score = scores_batch[min_score_idx] if min_score < best_score: best_score = min_score best_emb = batch_embs[min_score_idx] print('score:', min_score, 'best_score:', best_score) # 7. Clean up memory del gen_x, gen_mask, pred_mask, scores_batch torch.cuda.empty_cache() return best_emb, best_score def ct_tensor_to_png_bytes(ct_tensor): # ct_tensor: torch.Tensor, shape [1, D, H, W] or [D, H, W] if ct_tensor.ndim == 4: ct_tensor = ct_tensor.squeeze(0) D = ct_tensor.shape[0] mid_slice = ct_tensor[D // 2].cpu().numpy() img = (mid_slice + 1) / 2 * 255 img = np.clip(img, 0, 255) img = img.astype(np.uint8) pil_img = Image.fromarray(img) buf = io.BytesIO() pil_img.save(buf, format='PNG') buf.seek(0) return buf ############################################################## # 3. Main function: TACE Protocol Exploration with MeWM ############################################################## def tace_protocol_exploration( x, tumor_mask, drug_set, embolism_set, fgm_model, hsurv_model, hseg_model, T, B, H_d, H_e ): """ Implement the main inference logic. """ # Initialize B plans, each starting with a random drug plans = [[] for _ in range(B)] scores = [float('inf') for _ in range(B)] # Drug horizon for h in range(H_d): for b in range(B): drug, score = argmin_drug(fgm_model, hsurv_model, hseg_model, x, tumor_mask, drug_set, plans[b], scores[b], T) if drug is not None: plans[b].append(drug) scores[b] = score min_score_idx = scores.index(min(scores)) max_score_idx = scores.index(max(scores)) plans[max_score_idx] = plans[min_score_idx].copy() scores[max_score_idx] = scores[min_score_idx] # cTACE Rule 3 for b in range(B): plans[b].append('Lipiodol') # Continue searching for additional embolisms for h in range(H_e-1): for b in range(B): emb, score = argmin_embolism(fgm_model, hsurv_model, hseg_model, x, tumor_mask, embolism_set, plans[b], scores[b], T) if emb is not None: plans[b].append(emb) scores[b] = score min_score_idx = scores.index(min(scores)) max_score_idx = scores.index(max(scores)) plans[max_score_idx] = plans[min_score_idx].copy() scores[max_score_idx] = scores[min_score_idx] # Select the best plan min_score_idx = scores.index(min(scores)) best_plan = plans[min_score_idx] best_score = scores[min_score_idx] return best_plan, best_score ############################################################## # 4. Example inference script call ############################################################## if __name__ == "__main__": # Model loading fgm_model = TumorGenerativeWorldModel(device='cuda:0', cfg='Synthesis/model/ddpm.yaml') hsurv_model = InverseDynamics(model_path='checkpoint_best.pth.tar') hseg_model = SegmentationModel(model_path='Segmentation/runs/hcc.fold0.nnunet/model.pt') fgm_model = fgm_model.to('cuda:0') hseg_model = hseg_model.to('cuda:0') hsurv_model = hsurv_model.to('cuda:0') fgm_model.eval() hseg_model.eval() hsurv_model.eval() # Parameter settings T = 5 # Assume there are 5 tumors B = 5 # Generate 5 different plans H_d = 2 # drug horizon H_e = 2 # embolism h prompt = ( "You are a radiation oncologist, please **list potential TACE drug and embolism sets** based on the clinical guidelines and patient's pre-treatment CT image. Please follow the below description:" "###* * Task Description**" "1. Analyze the input CT images and output potential TACE chemotherapy drug and embolization material sets for treatment. You can include any drugs and embolisms that you think may be helpful for the treatment. Chemotherapy drugs and embolization materials are limited to those in the Action Base." "2. The TACE action set is output in JSON format, including treatment plan keywords such as drugs and embolization materials." "### **Action Base**" "#### **Chemotherapy Drugs**" "- Raltitrexed" "- Epirubicin" "- Oxaliplatin" "- Lobaplatin" "- Mitomycin" "- Idarubicin" "- Nedaplatin" "- Pirarubicin" "- Cisplatin" "- Idarubicin" "- THP" "#### ** Embolization Materials **" "- Lipiodol" "- Gelatin Sponge" "- PVA" "- Absolute Alcohol" "- NBCA" "---" "output format as JSON: {\"drug_set\": [...], \"embolism_set\": [...]}." ) # You can also manually set the available drug and embolism sets of your institution client = Policy(api_key="YOUR_API_KEY") # drug_set, embolism_set = client.get_drug_embolism_sets(prompt) # print("Policy generated drug_set:", drug_set) # print("Policy generated embolism_set:", embolism_set) # Data loading data_root = 'your-data-path' data_list_file = 'data_list.txt' dataset = ImageDataset(data_root, data_list_file) dataloader = DataLoader(dataset, batch_size=1, shuffle=False, num_workers=8, pin_memory=True) # Inference and save results results_dict = {} for i, data_dict in tqdm(enumerate(dataloader)): x = data_dict['input_CT_pre'].cuda() tumor_mask = data_dict['label_CT_pre'].cuda() name = data_dict['name'] if name[0] in results_dict: print(f"Processed {name}: {results_dict[name[0]]}") continue x = x.squeeze(0).unsqueeze(1) tumor_mask = tumor_mask.squeeze(0).unsqueeze(1) img_bytes = ct_tensor_to_png_bytes(x.cpu().squeeze(1)[0]) # [B, 1, D, H, W] -> [D, H, W] drug_set, embolism_set = client.get_drug_embolism_sets_with_image(prompt, img_bytes) print("Policy generated drug_set:", drug_set) print("Policy generated embolism_set:", embolism_set) with torch.no_grad(): best_plan, best_risk = tace_protocol_exploration( x, tumor_mask, drug_set, embolism_set, fgm_model, hsurv_model, hseg_model, T, B, H_d, H_e ) # Convert tensor to float best_risk = best_risk.item() if isinstance(best_risk, torch.Tensor) else float(best_risk) # Add new results results_dict[name[0]] = { 'keywords': best_plan, 'best_risk': best_risk } with open('best_plan.json', 'w') as f: json.dump(results_dict, f, indent=4) print(f"Processed {name}: {results_dict[name[0]]}")