import math import copy import torch from torch import nn, einsum import torch.nn.functional as F from functools import partial from torch.utils import data from pathlib import Path from torch.optim import Adam from torchvision import transforms as T, utils from torch.cuda.amp import autocast, GradScaler from PIL import Image from tqdm import tqdm from einops import rearrange from einops_exts import check_shape, rearrange_many from rotary_embedding_torch import RotaryEmbedding from ddpm.text import tokenize, bert_embed, BERT_MODEL_DIM from torch.utils.data import Dataset, DataLoader from vq_gan_3d.model.vqgan import VQGAN import matplotlib.pyplot as plt from transformers import CLIPTextModel, CLIPTokenizer # Initialize CLIP model for text embedding # In Unet3D or GaussianDiffusion initialization, we would do: # self.text_encoder = text_encoder # self.tokenizer = tokenizer def exists(x): return x is not None def noop(*args, **kwargs): pass def is_odd(n): return (n % 2) == 1 def default(val, d): if exists(val): return val return d() if callable(d) else d def cycle(dl): while True: for data in dl: yield data def num_to_groups(num, divisor): groups = num // divisor remainder = num % divisor arr = [divisor] * groups if remainder > 0: arr.append(remainder) return arr def prob_mask_like(shape, prob, device): if prob == 1: return torch.ones(shape, device=device, dtype=torch.bool) elif prob == 0: return torch.zeros(shape, device=device, dtype=torch.bool) else: return torch.zeros(shape, device=device).float().uniform_(0, 1) < prob def is_list_str(x): if not isinstance(x, (list, tuple)): return False return all([type(el) == str for el in x]) class RelativePositionBias(nn.Module): def __init__( self, heads=8, num_buckets=32, max_distance=128 ): super().__init__() self.num_buckets = num_buckets self.max_distance = max_distance self.relative_attention_bias = nn.Embedding(num_buckets, heads) @staticmethod def _relative_position_bucket(relative_position, num_buckets=32, max_distance=128): ret = 0 n = -relative_position num_buckets //= 2 ret += (n < 0).long() * num_buckets n = torch.abs(n) max_exact = num_buckets // 2 is_small = n < max_exact val_if_large = max_exact + ( torch.log(n.float() / max_exact) / math.log(max_distance / max_exact) * (num_buckets - max_exact) ).long() val_if_large = torch.min( val_if_large, torch.full_like(val_if_large, num_buckets - 1)) ret += torch.where(is_small, n, val_if_large) return ret def forward(self, n, device): q_pos = torch.arange(n, dtype=torch.long, device=device) k_pos = torch.arange(n, dtype=torch.long, device=device) rel_pos = rearrange(k_pos, 'j -> 1 j') - rearrange(q_pos, 'i -> i 1') rp_bucket = self._relative_position_bucket( rel_pos, num_buckets=self.num_buckets, max_distance=self.max_distance) values = self.relative_attention_bias(rp_bucket) return rearrange(values, 'i j h -> h i j') class EMA(): def __init__(self, beta): super().__init__() self.beta = beta def update_model_average(self, ma_model, current_model): for current_params, ma_params in zip(current_model.parameters(), ma_model.parameters()): old_weight, up_weight = ma_params.data, current_params.data ma_params.data = self.update_average(old_weight, up_weight) def update_average(self, old, new): if old is None: return new return old * self.beta + (1 - self.beta) * new class Residual(nn.Module): def __init__(self, fn): super().__init__() self.fn = fn def forward(self, x, *args, **kwargs): return self.fn(x, *args, **kwargs) + x class SinusoidalPosEmb(nn.Module): def __init__(self, dim): super().__init__() self.dim = dim def forward(self, x): device = x.device half_dim = self.dim // 2 emb = math.log(10000) / (half_dim - 1) emb = torch.exp(torch.arange(half_dim, device=device) * -emb) emb = x[:, None] * emb[None, :] emb = torch.cat((emb.sin(), emb.cos()), dim=-1) return emb def Upsample(dim): return nn.ConvTranspose3d(dim, dim, (1, 4, 4), (1, 2, 2), (0, 1, 1)) def Downsample(dim): return nn.Conv3d(dim, dim, (1, 4, 4), (1, 2, 2), (0, 1, 1)) class LayerNorm(nn.Module): def __init__(self, dim, eps=1e-5): super().__init__() self.eps = eps self.gamma = nn.Parameter(torch.ones(1, dim, 1, 1, 1)) def forward(self, x): var = torch.var(x, dim=1, unbiased=False, keepdim=True) mean = torch.mean(x, dim=1, keepdim=True) return (x - mean) / (var + self.eps).sqrt() * self.gamma class PreNorm(nn.Module): def __init__(self, dim, fn): super().__init__() self.fn = fn self.norm = LayerNorm(dim) def forward(self, x, **kwargs): x = self.norm(x) return self.fn(x, **kwargs) # building block modules class Block(nn.Module): def __init__(self, dim, dim_out, groups=8): super().__init__() self.proj = nn.Conv3d(dim, dim_out, (1, 3, 3), padding=(0, 1, 1)) self.norm = nn.GroupNorm(groups, dim_out) self.act = nn.SiLU() def forward(self, x, scale_shift=None): x = self.proj(x) x = self.norm(x) if exists(scale_shift): scale, shift = scale_shift x = x * (scale + 1) + shift return self.act(x) class ResnetBlock(nn.Module): def __init__(self, dim, dim_out, *, time_emb_dim=None, groups=8): super().__init__() self.mlp = nn.Sequential( nn.SiLU(), nn.Linear(time_emb_dim, dim_out * 2) ) if exists(time_emb_dim) else None self.block1 = Block(dim, dim_out, groups=groups) self.block2 = Block(dim_out, dim_out, groups=groups) self.res_conv = nn.Conv3d( dim, dim_out, 1) if dim != dim_out else nn.Identity() def forward(self, x, time_emb=None): scale_shift = None if exists(self.mlp): assert exists(time_emb), 'time emb must be passed in' time_emb = self.mlp(time_emb) time_emb = rearrange(time_emb, 'b c -> b c 1 1 1') scale_shift = time_emb.chunk(2, dim=1) h = self.block1(x, scale_shift=scale_shift) h = self.block2(h) return h + self.res_conv(x) class SpatialLinearAttention(nn.Module): def __init__(self, dim, heads=4, dim_head=32): super().__init__() self.scale = dim_head ** -0.5 self.heads = heads hidden_dim = dim_head * heads self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias=False) self.to_out = nn.Conv2d(hidden_dim, dim, 1) def forward(self, x): b, c, f, h, w = x.shape x = rearrange(x, 'b c f h w -> (b f) c h w') qkv = self.to_qkv(x).chunk(3, dim=1) q, k, v = rearrange_many( qkv, 'b (h c) x y -> b h c (x y)', h=self.heads) q = q.softmax(dim=-2) k = k.softmax(dim=-1) q = q * self.scale context = torch.einsum('b h d n, b h e n -> b h d e', k, v) out = torch.einsum('b h d e, b h d n -> b h e n', context, q) out = rearrange(out, 'b h c (x y) -> b (h c) x y', h=self.heads, x=h, y=w) out = self.to_out(out) return rearrange(out, '(b f) c h w -> b c f h w', b=b) # attention along space and time class EinopsToAndFrom(nn.Module): def __init__(self, from_einops, to_einops, fn): super().__init__() self.from_einops = from_einops self.to_einops = to_einops self.fn = fn def forward(self, x, **kwargs): shape = x.shape reconstitute_kwargs = dict( tuple(zip(self.from_einops.split(' '), shape))) x = rearrange(x, f'{self.from_einops} -> {self.to_einops}') x = self.fn(x, **kwargs) x = rearrange( x, f'{self.to_einops} -> {self.from_einops}', **reconstitute_kwargs) return x class Attention(nn.Module): def __init__( self, dim, heads=4, dim_head=32, rotary_emb=None ): super().__init__() self.scale = dim_head ** -0.5 self.heads = heads hidden_dim = dim_head * heads self.rotary_emb = rotary_emb self.to_qkv = nn.Linear(dim, hidden_dim * 3, bias=False) self.to_out = nn.Linear(hidden_dim, dim, bias=False) def forward( self, x, pos_bias=None, focus_present_mask=None ): n, device = x.shape[-2], x.device qkv = self.to_qkv(x).chunk(3, dim=-1) if exists(focus_present_mask) and focus_present_mask.all(): # if all batch samples are focusing on present # it would be equivalent to passing that token's values through to the output values = qkv[-1] return self.to_out(values) # split out heads q, k, v = rearrange_many(qkv, '... n (h d) -> ... h n d', h=self.heads) # scale q = q * self.scale # rotate positions into queries and keys for time attention if exists(self.rotary_emb): q = self.rotary_emb.rotate_queries_or_keys(q) k = self.rotary_emb.rotate_queries_or_keys(k) # similarity sim = einsum('... h i d, ... h j d -> ... h i j', q, k) # relative positional bias if exists(pos_bias): sim = sim + pos_bias if exists(focus_present_mask) and not (~focus_present_mask).all(): attend_all_mask = torch.ones( (n, n), device=device, dtype=torch.bool) attend_self_mask = torch.eye(n, device=device, dtype=torch.bool) mask = torch.where( rearrange(focus_present_mask, 'b -> b 1 1 1 1'), rearrange(attend_self_mask, 'i j -> 1 1 1 i j'), rearrange(attend_all_mask, 'i j -> 1 1 1 i j'), ) sim = sim.masked_fill(~mask, -torch.finfo(sim.dtype).max) # numerical stability sim = sim - sim.amax(dim=-1, keepdim=True).detach() attn = sim.softmax(dim=-1) # aggregate values out = einsum('... h i j, ... h j d -> ... h i d', attn, v) out = rearrange(out, '... h n d -> ... n (h d)') return self.to_out(out) # model import torch import torch.nn as nn from transformers import CLIPModel, CLIPTokenizer from transformers import CLIPTokenizer, CLIPTextModel def extract(a, t, x_shape): b, *_ = t.shape out = a.gather(-1, t) return out.reshape(b, *((1,) * (len(x_shape) - 1))) def cosine_beta_schedule(timesteps, s=0.008): """ cosine schedule """ steps = timesteps + 1 x = torch.linspace(0, timesteps, steps, dtype=torch.float64) alphas_cumprod = torch.cos( ((x / timesteps) + s) / (1 + s) * torch.pi * 0.5) ** 2 alphas_cumprod = alphas_cumprod / alphas_cumprod[0] betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1]) return torch.clip(betas, 0, 0.9999) cache_dir = "/home/yyang303/project/Synthesis/" import torch import torch.nn as nn class Attentiontext(nn.Module): def __init__(self, dim, heads=8, dim_head=64): super().__init__() self.heads = heads self.dim_head = dim_head self.scale = dim_head ** -0.5 self.to_q = nn.Linear(dim, dim_head * heads, bias=False) self.to_kv = nn.Linear(dim, dim_head * heads * 2, bias=False) self.to_out = nn.Linear(dim_head * heads, dim) def forward(self, x, context=None): context = context if context is not None else x q = self.to_q(x) # [batch, seq_length, dim_head * heads] k, v = self.to_kv(context).chunk(2, dim=-1) # [batch, seq_length, dim_head * heads] q = q.view(x.size(0), x.size(1), self.heads, self.dim_head).transpose(1, 2) * self.scale # [batch, heads, seq_length, dim_head] k = k.view(context.size(0), context.size(1), self.heads, self.dim_head).transpose(1, 2) # [batch, heads, seq_length, dim_head] v = v.view(context.size(0), context.size(1), self.heads, self.dim_head).transpose(1, 2) # [batch, heads, seq_length, dim_head] attn = torch.matmul(q, k.transpose(-2, -1)) # [batch, heads, seq_length, seq_length] attn = attn.softmax(dim=-1) out = torch.matmul(attn, v) # [batch, heads, seq_length, dim_head] out = out.transpose(1, 2).contiguous().view(x.size(0), x.size(1), self.heads * self.dim_head) # [batch, seq_length, heads * dim_head] return self.to_out(out) # [batch, seq_length, dim] class CrossAttention(nn.Module): def __init__(self, dim, heads=8, dim_head=64, text_dim=1024): super().__init__() self.dim = dim self.attn = Attentiontext(dim, heads=heads, dim_head=dim_head) self.text_projection = nn.Linear(text_dim, dim) self.to_out = nn.Sequential( nn.LayerNorm(dim), nn.Linear(dim, dim) ) def forward(self, img_features, text_features): batch_size, channels, depth, height, width = img_features.shape text_proj = self.text_projection(text_features) text_proj = text_proj.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1) text_proj = text_proj.expand(-1, -1, depth, height, width) if channels != self.dim: raise ValueError(f"img_features channels ({channels}) must match dim ({self.dim}) in CrossAttention") fused_features = img_features + text_proj fused_features = fused_features.view(batch_size, self.dim, -1).transpose(1, 2) attended = self.attn(fused_features) attended = attended.transpose(1, 2).contiguous().view(batch_size, self.dim, depth, height, width) # [batch, dim, depth, height, width] out = self.to_out(attended) + img_features return out tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32", cache_dir=cache_dir) text_encoder = CLIPTextModel.from_pretrained("openai/clip-vit-base-patch32", cache_dir=cache_dir) class Unet3D(nn.Module): def __init__( self, dim, cond_dim=None, out_dim=None, dim_mults=(1, 2, 4, 8), channels=3, attn_heads=8, attn_dim_head=32, use_bert_text_cond=False, use_cross_attention=True, init_dim=None, init_kernel_size=7, use_sparse_linear_attn=True, block_type='resnet', resnet_groups=8, clip_model_name="openai/clip-vit-base-patch32" ): super().__init__() self.channels = channels self.dim = dim self.init_dim = default(init_dim, dim) self.init_kernel_size = init_kernel_size self.use_cross_attention = use_cross_attention self.clip_model = CLIPModel.from_pretrained(clip_model_name) self.tokenizer = CLIPTokenizer.from_pretrained(clip_model_name) rotary_emb = RotaryEmbedding(min(32, attn_dim_head)) def temporal_attn(dim): return EinopsToAndFrom('b c f h w', 'b (h w) f c', Attention(dim, heads=attn_heads, dim_head=attn_dim_head, rotary_emb=rotary_emb)) self.time_rel_pos_bias = RelativePositionBias(heads=attn_heads, max_distance=32) init_dim = default(init_dim, dim) assert is_odd(init_kernel_size) init_padding = init_kernel_size // 2 self.init_conv = nn.Conv3d(49, init_dim, (1, init_kernel_size, init_kernel_size), padding=(0, init_padding, init_padding)) if self.use_cross_attention: self.cross_attn = CrossAttention(dim=self.dim, heads=8, dim_head=64) self.init_temporal_attn = Residual(PreNorm(init_dim, temporal_attn(init_dim))) dims = [init_dim, *map(lambda m: dim * m, dim_mults)] in_out = list(zip(dims[:-1], dims[1:])) time_dim = dim * 4 self.time_mlp = nn.Sequential( SinusoidalPosEmb(dim), nn.Linear(dim, time_dim), nn.GELU(), nn.Linear(time_dim, time_dim) ) self.has_cond = exists(cond_dim) or use_bert_text_cond cond_dim = BERT_MODEL_DIM if use_bert_text_cond else cond_dim self.null_cond_emb = nn.Parameter( torch.randn(1, cond_dim)) if self.has_cond else None cond_dim = time_dim + int(cond_dim or 0) self.downs = nn.ModuleList([]) self.ups = nn.ModuleList([]) num_resolutions = len(in_out) block_klass = partial(ResnetBlock, groups=resnet_groups) block_klass_cond = partial(block_klass, time_emb_dim=cond_dim) for ind, (dim_in, dim_out) in enumerate(in_out): is_last = ind >= (num_resolutions - 1) self.downs.append(nn.ModuleList([ block_klass_cond(dim_in, dim_out), block_klass_cond(dim_out, dim_out), Residual(PreNorm(dim_out, SpatialLinearAttention(dim_out, heads=attn_heads))) if use_sparse_linear_attn else nn.Identity(), Residual(PreNorm(dim_out, temporal_attn(dim_out))), Downsample(dim_out) if not is_last else nn.Identity() ])) mid_dim = dims[-1] self.mid_block1 = block_klass_cond(mid_dim, mid_dim) spatial_attn = EinopsToAndFrom('b c f h w', 'b f (h w) c', Attention(mid_dim, heads=attn_heads)) self.mid_spatial_attn = Residual(PreNorm(mid_dim, spatial_attn)) self.mid_temporal_attn = Residual(PreNorm(mid_dim, temporal_attn(mid_dim))) self.mid_block2 = block_klass_cond(mid_dim, mid_dim) for ind, (dim_in, dim_out) in enumerate(reversed(in_out)): is_last = ind >= (num_resolutions - 1) self.ups.append(nn.ModuleList([ block_klass_cond(dim_out * 2, dim_in), block_klass_cond(dim_in, dim_in), Residual(PreNorm(dim_in, SpatialLinearAttention(dim_in, heads=attn_heads))) if use_sparse_linear_attn else nn.Identity(), Residual(PreNorm(dim_in, temporal_attn(dim_in))), Upsample(dim_in) if not is_last else nn.Identity() ])) out_dim = default(out_dim, channels) self.final_conv = nn.Sequential( block_klass(dim * 2, dim), nn.Conv3d(dim, out_dim, 1) ) def forward_with_cond_scale( self, *args, cond_scale=2., **kwargs ): logits = self.forward(*args, null_cond_prob=0., **kwargs) if cond_scale == 1 or not self.has_cond: return logits null_logits = self.forward(*args, null_cond_prob=1., **kwargs) return null_logits + (logits - null_logits) * cond_scale def forward( self, x, time, cond=None, null_cond_prob=0., focus_present_mask=None, prob_focus_present=0., text=None ): assert not (self.has_cond and not exists(cond)), 'cond must be passed in if cond_dim specified' #print(text) if text is not None: inputs = self.tokenizer(text, return_tensors="pt", padding=True, truncation=True).to(x.device) text_embeddings = self.clip_model.get_text_features(**inputs) # (batch_size, embedding_dim) #print("text",text_embeddings.shape) x = torch.cat([x, cond], dim=1) batch, device = x.shape[0], x.device focus_present_mask = default(focus_present_mask, lambda: prob_mask_like((batch,), prob_focus_present, device=device)) time_rel_pos_bias = self.time_rel_pos_bias(x.shape[2], device=x.device) input_channels = x.shape[1] x = self.init_conv(x) r = x.clone() x = self.init_temporal_attn(x, pos_bias=time_rel_pos_bias) t = self.time_mlp(time) if exists(self.time_mlp) else None # Text embeddings passed through all layers if self.has_cond: batch, device = x.shape[0], x.device mask = prob_mask_like((batch,), null_cond_prob, device=device) cond = torch.where(rearrange(mask, 'b -> b 1'), self.null_cond_emb, cond) t = torch.cat((t, cond), dim=-1) h = [] # print("x",x.shape) for block1, block2, spatial_attn, temporal_attn, downsample in self.downs: x = block1(x, t) x = block2(x, t) #x = self.cross_attn(x, text_embeddings) x = spatial_attn(x) x = temporal_attn(x, pos_bias=time_rel_pos_bias, focus_present_mask=focus_present_mask) h.append(x) x = downsample(x) x = self.mid_block1(x, t) #x = self.cross_attn(x, text_embeddings) x = self.mid_spatial_attn(x) x = self.mid_temporal_attn(x, pos_bias=time_rel_pos_bias, focus_present_mask=focus_present_mask) x = self.mid_block2(x, t) for block1, block2, spatial_attn, temporal_attn, upsample in self.ups: x = torch.cat((x, h.pop()), dim=1) x = block1(x, t) x = block2(x, t) #x = self.cross_attn(x, text_embeddings) x = spatial_attn(x) x = temporal_attn(x, pos_bias=time_rel_pos_bias, focus_present_mask=focus_present_mask) x = upsample(x) x = torch.cat((x, r), dim=1) return self.final_conv(x) class MedicalTextEncoder(nn.Module): def __init__(self, tokenizer, clip_model, max_segments=8, clip_dim=512): super().__init__() self.tokenizer = tokenizer self.clip_model = clip_model # 定义药物词表 self.drug_list = [ "Raltitrexed", "Epirubicin", "Oxaliplatin", "Lobaplatin", "Idarubicin", "Cisplatin", "THP", "Mitomycin", "Doxorubicin", "Hydroxycamptothecin", "LC beads", "Nedaplatin", "Pirarubicin", "Lipiodol", "PVA", "KMG", "Absolute Alcohol", "NBCA", "Gelatin Sponge" ] # drug embedding self.drug_embedding = nn.Embedding(len(self.drug_list), 64) # text feature processing layer self.segment_encoder = nn.Linear(clip_dim, 256) # fusion layer self.fusion_layer = nn.Sequential( nn.Linear(256*max_segments + 64, 512), nn.GELU(), nn.LayerNorm(512), nn.Linear(512, 256), nn.GELU(), nn.LayerNorm(256) ) self.max_segments = max_segments def split_text(self, text): """Strictly split by semicolon and normalize""" segments = [s.strip() for s in text.split(';') if len(s.strip()) > 3] # filter empty sentences if len(segments) > self.max_segments: # strategy 1: merge short paragraphs merged = [' '.join(segments[i:i+2]) for i in range(0, len(segments), 2)] return merged[:self.max_segments] else: # strategy 2: fill empty paragraphs return segments + ['']*(self.max_segments - len(segments)) def extract_drug_features(self, text): """Extract drug features from text""" drug_indices = [] for i, drug in enumerate(self.drug_list): if drug in text: drug_indices.append(i) if not drug_indices: return torch.zeros(64, device=self.drug_embedding.weight.device) drug_embeddings = self.drug_embedding(torch.tensor(drug_indices, device=self.drug_embedding.weight.device)) return drug_embeddings.mean(dim=0) def forward(self, text_list): batch_embs = [] device = next(self.clip_model.parameters()).device for text in text_list: # split text segments = self.split_text(text) # CLIP text encoding seg_embs = [] for seg in segments: inputs = self.tokenizer(seg, return_tensors="pt", padding=True, truncation=True).to(device) emb = self.clip_model.get_text_features(**inputs) seg_embs.append(self.segment_encoder(emb)) # extract drug features drug_emb = self.extract_drug_features(text) # concatenate and fuse features text_emb = torch.cat(seg_embs, dim=1) combined_emb = torch.cat([text_emb.squeeze(0), drug_emb]) merged = self.fusion_layer(combined_emb) batch_embs.append(merged.unsqueeze(0)) return torch.cat(batch_embs, dim=0) import random class GaussianDiffusion(nn.Module): def __init__( self, denoise_fn, *, image_size, num_frames, text_use_bert_cls=False, channels=3, timesteps=200, loss_type='l1', use_dynamic_thres=False, dynamic_thres_percentile=0.9, vqgan_ckpt=None, contrastive_temp=0.07, contrastive_weight=0.1 ): super().__init__() self.channels = channels self.image_size = image_size self.num_frames = num_frames self.denoise_fn = denoise_fn self.med_text_encoder = MedicalTextEncoder(self.denoise_fn.tokenizer, self.denoise_fn.clip_model) self.contrastive_temp = contrastive_temp self.contrastive_weight = contrastive_weight if vqgan_ckpt: self.vqgan = VQGAN.load_from_checkpoint(vqgan_ckpt).cuda() self.vqgan.eval() else: self.vqgan = None betas = cosine_beta_schedule(timesteps) alphas = 1. - betas alphas_cumprod = torch.cumprod(alphas, axis=0) alphas_cumprod_prev = F.pad(alphas_cumprod[:-1], (1, 0), value=1.) timesteps, = betas.shape self.num_timesteps = int(timesteps) self.loss_type = loss_type def register_buffer(name, val): return self.register_buffer( name, val.to(torch.float32)) register_buffer('betas', betas) register_buffer('alphas_cumprod', alphas_cumprod) register_buffer('alphas_cumprod_prev', alphas_cumprod_prev) register_buffer('sqrt_alphas_cumprod', torch.sqrt(alphas_cumprod)) register_buffer('sqrt_one_minus_alphas_cumprod', torch.sqrt(1. - alphas_cumprod)) register_buffer('log_one_minus_alphas_cumprod', torch.log(1. - alphas_cumprod)) register_buffer('sqrt_recip_alphas_cumprod', torch.sqrt(1. / alphas_cumprod)) register_buffer('sqrt_recipm1_alphas_cumprod', torch.sqrt(1. / alphas_cumprod - 1)) posterior_variance = betas * \ (1. - alphas_cumprod_prev) / (1. - alphas_cumprod) register_buffer('posterior_variance', posterior_variance) register_buffer('posterior_log_variance_clipped', torch.log(posterior_variance.clamp(min=1e-20))) register_buffer('posterior_mean_coef1', betas * torch.sqrt(alphas_cumprod_prev) / (1. - alphas_cumprod)) register_buffer('posterior_mean_coef2', (1. - alphas_cumprod_prev) * torch.sqrt(alphas) / (1. - alphas_cumprod)) self.text_use_bert_cls = text_use_bert_cls self.use_dynamic_thres = use_dynamic_thres self.dynamic_thres_percentile = dynamic_thres_percentile self.text_proj = nn.Linear(256, 32) # other suitable output dimension def get_another_report(self, text): current_dir = os.path.dirname(os.path.abspath(__file__)) file_path = os.path.join(current_dir, "con_report/surgery_action.txt") def process_file(file_path): text_lists = [] with open(file_path, 'r') as file: lines = file.readlines() for line in lines: report = line.strip().replace("\n", "").replace("\r", "") text_lists.append(report) return text_lists def contains_keywords(text, keywords): return any(keyword in text for keyword in keywords) keywords = [ "Raltitrexed", "Epirubicin", "Oxaliplatin", "Lobaplatin", "Idarubicin", "Cisplatin", "THP", "Mitomycin", "Doxorubicin", "Hydroxycamptothecin", "LC beads", "Nedaplatin", "Pirarubicin", "Lipiodol", "PVA", "KMG", "Absolute Alcohol", "NBCA", "Gelatin Sponge" ] text_data = process_file(file_path) text1_keywords = [keyword for keyword in keywords if keyword in text] text2 = random.choice(text_data) while text2 == text or contains_keywords(text2, text1_keywords): text2 = random.choice(text_data) # print(text2) return text2 def q_mean_variance(self, x_start, t): mean = extract(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start variance = extract(1. - self.alphas_cumprod, t, x_start.shape) log_variance = extract( self.log_one_minus_alphas_cumprod, t, x_start.shape) return mean, variance, log_variance def predict_start_from_noise(self, x_t, t, noise): return ( extract(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - extract(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * noise ) def q_posterior(self, x_start, x_t, t): posterior_mean = ( extract(self.posterior_mean_coef1, t, x_t.shape) * x_start + extract(self.posterior_mean_coef2, t, x_t.shape) * x_t ) posterior_variance = extract(self.posterior_variance, t, x_t.shape) posterior_log_variance_clipped = extract( self.posterior_log_variance_clipped, t, x_t.shape) return posterior_mean, posterior_variance, posterior_log_variance_clipped def p_mean_variance(self, x, t, clip_denoised: bool, cond=None, cond_scale=1., text=None): x_recon = self.predict_start_from_noise( x, t=t, noise=self.denoise_fn.forward_with_cond_scale(x, t, cond=cond, cond_scale=cond_scale, text=text) # Include text ) if clip_denoised: s = 1. if self.use_dynamic_thres: s = torch.quantile( rearrange(x_recon, 'b ... -> b (...)').abs(), self.dynamic_thres_percentile, dim=-1 ) s.clamp_(min=1.) s = s.view(-1, *((1,) * (x_recon.ndim - 1))) # clip by threshold, depending on whether static or dynamic x_recon = x_recon.clamp(-s, s) / s model_mean, posterior_variance, posterior_log_variance = self.q_posterior( x_start=x_recon, x_t=x, t=t) return model_mean, posterior_variance, posterior_log_variance @torch.inference_mode() def p_sample(self, x, t, cond=None, cond_scale=1., clip_denoised=True, text=None): b, *_, device = *x.shape, x.device model_mean, _, model_log_variance = self.p_mean_variance( x=x, t=t, clip_denoised=clip_denoised, cond=cond, cond_scale=cond_scale, text=text # Pass text to p_mean_variance ) noise = torch.randn_like(x) # no noise when t == 0 nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1))) return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise @torch.inference_mode() def p_sample_loop(self, shape, cond=None, cond_scale=1., text=None): device = self.betas.device b = shape[0] img = torch.randn(shape, device=device) #print('text', text.shape) for i in tqdm(reversed(range(0, self.num_timesteps)), desc='sampling loop time step', total=self.num_timesteps): img = self.p_sample( img, torch.full((b,), i, device=device, dtype=torch.long), cond=cond, cond_scale=cond_scale, text=text # Pass the text argument here ) return img @torch.inference_mode() def sample(self, cond=None, text=None, cond_scale=1., batch_size=16): device = next(self.denoise_fn.parameters()).device if is_list_str(cond): cond = bert_embed(tokenize(cond)).to(device) batch_size = batch_size image_size = self.image_size channels = 8 # self.channels num_frames = self.num_frames _sample = self.p_sample_loop( (batch_size, channels, num_frames, image_size, image_size), cond=cond, cond_scale=cond_scale, text=text) if isinstance(self.vqgan, VQGAN): _sample = (((_sample + 1.0) / 2.0) * (self.vqgan.codebook.embeddings.max() - self.vqgan.codebook.embeddings.min())) + self.vqgan.codebook.embeddings.min() _sample = self.vqgan.decode(_sample, quantize=True) else: unnormalize_img(_sample) return _sample @torch.inference_mode() def interpolate(self, x1, x2, t=None, lam=0.5): b, *_, device = *x1.shape, x1.device t = default(t, self.num_timesteps - 1) assert x1.shape == x2.shape t_batched = torch.stack([torch.tensor(t, device=device)] * b) xt1, xt2 = map(lambda x: self.q_sample(x, t=t_batched), (x1, x2)) img = (1 - lam) * xt1 + lam * xt2 for i in tqdm(reversed(range(0, t)), desc='interpolation sample time step', total=t): img = self.p_sample(img, torch.full( (b,), i, device=device, dtype=torch.long)) return img def q_sample(self, x_start, t, noise=None): noise = default(noise, lambda: torch.randn_like(x_start)) return ( extract(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start + extract(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) * noise ) def contrastive_loss_3d(self, img1, img2, temperature=0.07): if img1.shape != img2.shape: img2 = F.interpolate(img2, size=img1.shape[2:], mode='trilinear', align_corners=False) assert img1.shape == img2.shape, "Shapes should now match after resizing" b, c, d, h, w = img1.shape img1_flat = img1.view(b, -1) img2_flat = img2.view(b, -1) sim_matrix = F.cosine_similarity(img1_flat.unsqueeze(1), img2_flat.unsqueeze(0), dim=-1) sim_matrix = sim_matrix / temperature sim_matrix_exp = torch.exp(sim_matrix) positive_sim = torch.diag(sim_matrix_exp) contrastive_loss = -torch.log( positive_sim / (sim_matrix_exp.sum(dim=-1) - positive_sim) ).mean() return contrastive_loss def get_cond(self, img, mask, post_img, post_mask, text, device): bs = img.shape[0] # select processing mode based on vascular angiography description def select_occlusion_mode(text): """Parse text description to determine processing intensity""" text_lower = text[0].lower() # assume text is the same description in the batch if 'occlude' in text_lower: return 'partial' elif 'disappear' in text_lower: return 'complete' # completely disappear elif 'reduced' or 'improve' in text_lower: return 'reduced' # significantly reduced else: return 'baseline' # baseline processing # generate dynamic gaussian kernel (adjust parameters based on processing mode) def get_adaptive_gaussian_kernel3d(mask, mode): """Adjust blur parameters based on processing mode""" voxel_ratio = mask.sum() / mask.numel() # different mode parameters configuration params = { 'complete': {'base_sigma': 8.0, 'max_sigma': 12.0, 'exponent': 0.3}, 'partial': {'base_sigma': 4.0, 'max_sigma': 8.0, 'exponent': 0.5}, 'reduced': {'base_sigma': 6.0, 'max_sigma': 10.0, 'exponent': 0.4}, 'baseline':{'base_sigma': 2.0, 'max_sigma': 5.0, 'exponent': 0.7} }[mode] sigma = params['base_sigma'] + (params['max_sigma'] - params['base_sigma']) * (1 - voxel_ratio) return sigma, params['exponent'] # dynamic morphological preprocessing def preprocess_mask_3d(mask, mode): """ 3D morphological processing function Args: mask: 3D tumor mask [B, 1, D, H, W], value range {0, 1} mode: processing mode ('complete', 'partial', 'reduced', 'baseline') Returns: processed_mask: processed 3D mask [B, 1, D, H, W] """ import cv2 import numpy as np # get batch size batch_size = mask.shape[0] # create output tensor processed = torch.zeros_like(mask) # process each batch separately for b in range(batch_size): # get single sample and remove channel dimension mask_np = mask[b, 0].cpu().numpy() # [D, H, W] # define 3D structure element def get_3d_kernel(size): z, y, x = np.ogrid[-size//2:size//2+1, -size//2:size//2+1, -size//2:size//2+1] kernel = (x**2 + y**2 + z**2) <= (size//2)**2 return kernel.astype(np.uint8) # select processing mode kernel_size = max(3, int(np.cbrt(mask_np.sum()) * 0.1)) # dynamic kernel size kernel = get_3d_kernel(kernel_size) # process each depth slice processed_slices = np.zeros_like(mask_np) for z in range(mask_np.shape[0]): slice_2d = mask_np[z] # [H, W] if mode == 'complete': processed_slices[z] = cv2.erode(slice_2d.astype(np.float32), kernel[kernel_size//2], iterations=2) elif mode == 'partial': processed_slices[z] = cv2.erode(slice_2d.astype(np.float32), kernel[kernel_size//2], iterations=1) elif mode == 'reduced': eroded = cv2.erode(slice_2d.astype(np.float32), kernel[kernel_size//2]) processed_slices[z] = cv2.dilate(eroded, kernel[kernel_size//2]) else: # baseline processed_slices[z] = slice_2d processed[b, 0] = torch.tensor(processed_slices, device=mask.device) return processed def get_gaussian_kernel3d(kernel_size=7, sigma=2.0, device=None): # create isotropic gaussian kernel (three-dimensional same sigma) kernel_size = [kernel_size] * 3 sigma = [sigma] * 3 # keep isotropic x = torch.linspace(-kernel_size[0]//2, kernel_size[0]//2, kernel_size[0], device=device) y = torch.linspace(-kernel_size[1]//2, kernel_size[1]//2, kernel_size[1], device=device) z = torch.linspace(-kernel_size[2]//2, kernel_size[2]//2, kernel_size[2], device=device) grid_x, grid_y, grid_z = torch.meshgrid(x, y, z, indexing='ij') gaussian = torch.exp(-(grid_x**2 + grid_y**2 + grid_z**2) / (2*(sigma[0]**2))) gaussian = gaussian / gaussian.sum() return gaussian.view(1, 1, *gaussian.shape) # step 1: determine processing mode mode = select_occlusion_mode(text) # step 2: morphological preprocessing processed_mask = preprocess_mask_3d(mask, mode) # step 3: dynamic blur processing sigma, exponent = get_adaptive_gaussian_kernel3d(processed_mask, mode) gaussian_kernel = get_gaussian_kernel3d(kernel_size=11, sigma=sigma, device=img.device) # keep spatial size padding padding = 11 // 2 # apply gaussian blur mask_blur = F.conv3d(processed_mask.view(-1, 1, *processed_mask.shape[2:])+1e-10, gaussian_kernel, padding=padding, groups=1).view_as(processed_mask) # enhance center retention effect mask_blur = torch.pow(mask_blur, exponent) # generate masked image (adjust decay intensity based on mode) # decay_factor = {'complete': 0.1, 'partial': 0.3, 'reduced': 0.5, 'baseline': 0.7}[mode] masked_img = img * (1 - mask_blur) + img * mask_blur # --- keep original VQGAN processing流程 --- masked_img = masked_img.permute(0, 1, -1, -3, -2) img = img.permute(0, 1, -1, -3, -2) mask = mask.permute(0, 1, -1, -3, -2) if isinstance(self.vqgan, VQGAN): with torch.no_grad(): img_vq = self.vqgan.encode(img, quantize=False, include_embeddings=True) img_vq = ((img_vq - self.vqgan.codebook.embeddings.min()) / (self.vqgan.codebook.embeddings.max() - self.vqgan.codebook.embeddings.min())) * 2.0 - 1.0 masked_img_vq = self.vqgan.encode(masked_img, quantize=False, include_embeddings=True) masked_img_vq = ((masked_img_vq - self.vqgan.codebook.embeddings.min()) / (self.vqgan.codebook.embeddings.max() - self.vqgan.codebook.embeddings.min())) * 2.0 - 1.0 else: img_vq = normalize_img(img) masked_img_vq = normalize_img(masked_img) mask = mask * 2.0 - 1.0 cc = torch.nn.functional.interpolate(mask, size=masked_img_vq.shape[-3:]) cond = torch.cat((masked_img_vq, cc), dim=1) # ==== improved text processing ==== if text is not None: # batch process all texts text_emb = self.med_text_encoder(text) # [B, 512] # use fixed projection layer text_emb = self.text_proj(text_emb) # [B, cond_dim] # dimension adjustment and concatenation text_emb = text_emb.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1) text_emb = text_emb.expand(-1, -1, *cond.shape[2:]) cond = torch.cat((cond, text_emb), dim=1) return cond.detach() def p_losses(self, x_start, t, cond=None, text=None, noise=None, pre_img_sim=None, pre_mask_sim=None, post_img_sim=None, post_mask_sim=None, text_sim=None, **kwargs): b, c, f, h, w, device = *x_start.shape, x_start.device noise = default(noise, lambda: torch.randn_like(x_start)) x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise) if is_list_str(cond): cond = bert_embed(tokenize(cond), return_cls_repr=self.text_use_bert_cls).to(device) x_recon = self.denoise_fn(x_noisy, t, cond=cond, text=text, **kwargs) if self.loss_type == 'l1': loss = F.l1_loss(noise, x_recon) elif self.loss_type == 'l2': loss = F.mse_loss(noise, x_recon) else: raise NotImplementedError() cond_sim = None if pre_img_sim is not None and pre_mask_sim is not None and post_img_sim is not None and post_mask_sim is not None and text_sim is not None: cond_sim = self.get_cond(pre_img_sim, pre_mask_sim, post_img_sim, post_mask_sim, text_sim, device) text2 = self.get_another_report(text) if text2 is not None: # get text2 text embedding inputs2 = self.denoise_fn.tokenizer(text2, return_tensors="pt", padding=True, truncation=True).to(device) text_embeddings2 = self.denoise_fn.clip_model.get_text_features(**inputs2) text_proj = nn.Linear(text_embeddings2.shape[-1], cond.shape[1]).to(device) text_embeddings2 = text_proj(text_embeddings2) text_embeddings2 = text_embeddings2.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1) text_embeddings2 = text_embeddings2.expand(-1, -1, cond.shape[2], cond.shape[3], cond.shape[4]) cond2 = cond.clone() cond2[:, -text_embeddings2.shape[1]:] = text_embeddings2 # replace the last text embedding part img1 = self.p_sample_loop(x_start.shape, cond=cond, text=text) img2 = self.p_sample_loop(x_start.shape, cond=cond2, text=text2) contrastive_loss_dissim = self.contrastive_loss_3d(img1, img2, temperature=self.contrastive_temp) else: contrastive_loss_dissim = 0 contrastive_loss_sim = 0 if cond_sim is not None: img3 = self.p_sample_loop(x_start.shape, cond=cond_sim, text=text_sim) contrastive_loss_sim = self.contrastive_loss_3d(img1, img3, temperature=self.contrastive_temp) # print(text_sim) # print(text2) # print(text) total_loss = loss + self.contrastive_weight * (contrastive_loss_dissim - contrastive_loss_sim) return total_loss def forward(self, x, cond=None, text=None, return_cond=False, *args, **kwargs): pre_img, pre_mask, post_img, post_mask = x bs = pre_img.shape[0] # select processing mode based on vascular angiography description def select_occlusion_mode(text): """Parse text description to determine processing intensity""" text_lower = text[0].lower() # assume text is the same description in the batch if 'occlude' in text_lower: return 'partial' # occlusion of the feeding artery - partial shrinkage elif 'disappear' in text_lower: return 'complete' # completely disappear elif 'reduced' or 'improve' in text_lower: return 'reduced' # significantly reduced else: return 'baseline' # baseline processing # generate dynamic gaussian kernel (adjust parameters based on processing mode) def get_adaptive_gaussian_kernel3d(mask, mode): """Adjust blur parameters based on processing mode""" voxel_ratio = mask.sum() / mask.numel() # different mode parameters configuration params = { 'complete': {'base_sigma': 8.0, 'max_sigma': 12.0, 'exponent': 0.3}, 'partial': {'base_sigma': 4.0, 'max_sigma': 8.0, 'exponent': 0.5}, 'reduced': {'base_sigma': 6.0, 'max_sigma': 10.0, 'exponent': 0.4}, 'baseline':{'base_sigma': 2.0, 'max_sigma': 5.0, 'exponent': 0.7} }[mode] sigma = params['base_sigma'] + (params['max_sigma'] - params['base_sigma']) * (1 - voxel_ratio) return sigma, params['exponent'] # dynamic morphological preprocessing def preprocess_mask_3d(mask, mode): """ 3D morphological processing function Args: mask: 3D tumor mask [B, 1, D, H, W], value range {0, 1} mode: processing mode ('complete', 'partial', 'reduced', 'baseline') Returns: processed_mask: processed 3D mask [B, 1, D, H, W] """ import cv2 import numpy as np # get batch size batch_size = mask.shape[0] # create output tensor processed = torch.zeros_like(mask) # process each batch separately for b in range(batch_size): # get single sample and remove channel dimension mask_np = mask[b, 0].cpu().numpy() # [D, H, W] # define 3D structure element def get_3d_kernel(size): z, y, x = np.ogrid[-size//2:size//2+1, -size//2:size//2+1, -size//2:size//2+1] kernel = (x**2 + y**2 + z**2) <= (size//2)**2 return kernel.astype(np.uint8) # select processing mode kernel_size = max(3, int(np.cbrt(mask_np.sum()) * 0.1)) # dynamic kernel size kernel = get_3d_kernel(kernel_size) # process each depth slice processed_slices = np.zeros_like(mask_np) for z in range(mask_np.shape[0]): slice_2d = mask_np[z] # [H, W] if mode == 'complete': processed_slices[z] = cv2.erode(slice_2d.astype(np.float32), kernel[kernel_size//2], iterations=2) elif mode == 'partial': processed_slices[z] = cv2.erode(slice_2d.astype(np.float32), kernel[kernel_size//2], iterations=1) elif mode == 'reduced': eroded = cv2.erode(slice_2d.astype(np.float32), kernel[kernel_size//2]) processed_slices[z] = cv2.dilate(eroded, kernel[kernel_size//2]) else: # baseline processed_slices[z] = slice_2d # put the processed result back to tensor processed[b, 0] = torch.tensor(processed_slices, device=mask.device) return processed # generate dynamic gaussian kernel def get_gaussian_kernel3d(kernel_size=7, sigma=2.0, device=None): # create isotropic gaussian kernel (three-dimensional same sigma) kernel_size = [kernel_size] * 3 sigma = [sigma] * 3 # keep isotropic x = torch.linspace(-kernel_size[0]//2, kernel_size[0]//2, kernel_size[0], device=device) y = torch.linspace(-kernel_size[1]//2, kernel_size[1]//2, kernel_size[1], device=device) z = torch.linspace(-kernel_size[2]//2, kernel_size[2]//2, kernel_size[2], device=device) grid_x, grid_y, grid_z = torch.meshgrid(x, y, z, indexing='ij') # calculate gaussian value (keep isotropic) gaussian = torch.exp(-(grid_x**2 + grid_y**2 + grid_z**2) / (2*(sigma[0]**2))) gaussian = gaussian / gaussian.sum() return gaussian.view(1, 1, *gaussian.shape) # step 1: determine processing mode mode = select_occlusion_mode(text) # step 2: morphological preprocessing processed_mask = preprocess_mask_3d(pre_mask, mode) # step 3: dynamic blur processing sigma, exponent = get_adaptive_gaussian_kernel3d(processed_mask, mode) gaussian_kernel = get_gaussian_kernel3d(kernel_size=11, sigma=sigma, device=pre_img.device) # keep spatial size padding padding = 11 // 2 # apply gaussian blur mask_blur = F.conv3d(processed_mask.view(-1, 1, *processed_mask.shape[2:])+1e-10, gaussian_kernel, padding=padding, groups=1).view_as(processed_mask) # enhance center retention effect mask_blur = torch.pow(mask_blur, exponent) # generate masked image (adjust decay intensity based on mode) # decay_factor = {'complete': 0.1, 'partial': 0.3, 'reduced': 0.5, 'baseline': 0.7}[mode] masked_img = pre_img * (1 - mask_blur) + pre_img * mask_blur # create reverse mask (bbox area is 0, other areas are 1) # mask_ = (1 - bbox_mask).detach() # masked_img = (pre_img * mask_).detach() masked_img = masked_img.permute(0, 1, -1, -3, -2) pre_img = pre_img.permute(0, 1, -1, -3, -2) pre_mask = pre_mask.permute(0, 1, -1, -3, -2) post_img = post_img.permute(0, 1, -1, -3, -2) post_mask = post_mask.permute(0, 1, -1, -3, -2) if isinstance(self.vqgan, VQGAN): with torch.no_grad(): img = self.vqgan.encode(post_img, quantize=False, include_embeddings=True) img = ((img - self.vqgan.codebook.embeddings.min()) / (self.vqgan.codebook.embeddings.max() - self.vqgan.codebook.embeddings.min())) * 2.0 - 1.0 masked_img = self.vqgan.encode(masked_img, quantize=False, include_embeddings=True) masked_img = ((masked_img - self.vqgan.codebook.embeddings.min()) / (self.vqgan.codebook.embeddings.max() - self.vqgan.codebook.embeddings.min())) * 2.0 - 1.0 else: img = normalize_img(post_img) masked_img = normalize_img(masked_img) mask = pre_mask * 2.0 - 1.0 cc = torch.nn.functional.interpolate(mask, size=masked_img.shape[-3:]) cond = torch.cat((masked_img, cc), dim=1) # ==== improved text processing ==== if text is not None: # batch process all texts text_emb = self.med_text_encoder(text) # [B, 512] # use fixed projection layer text_emb = self.text_proj(text_emb) # [B, cond_dim] # dimension adjustment and concatenation text_emb = text_emb.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1) text_emb = text_emb.expand(-1, -1, *cond.shape[2:]) cond = torch.cat((cond, text_emb), dim=1) # print("img.shape", img.shape) b, device, img_size = img.shape[0], img.device, self.image_size t = torch.randint(0, self.num_timesteps, (b,), device=device).long() if return_cond: return cond return self.p_losses(img, t, cond=cond, text=text, *args, **kwargs) def identity(t, *args, **kwargs): return t def normalize_img(t): return t * 2 - 1 def unnormalize_img(t): return (t + 1) * 0.5 # trainer clas # trainer clas from tensorboardX import SummaryWriter import os import matplotlib.pyplot as plt from tensorboardX import SummaryWriter import os import matplotlib.pyplot as plt import torch import torch.nn as nn import copy from torch.optim import Adam from torch.cuda.amp import GradScaler, autocast from pathlib import Path from itertools import cycle class Trainer(object): def __init__( self, diffusion_model, cfg, folder=None, dataset=None, *, ema_decay=0.995, num_frames=16, train_batch_size=32, train_lr=1e-4, train_num_steps=100000, gradient_accumulate_every=2, amp=False, step_start_ema=2000, update_ema_every=10, save_and_sample_every=1000, results_folder='/home/yyang303/project/Synthesis/outputs/', num_sample_rows=1, max_grad_norm=None, num_workers=20, ): super().__init__() self.model = diffusion_model self.ema = EMA(ema_decay) self.ema_model = copy.deepcopy(self.model) self.update_ema_every = update_ema_every self.step_start_ema = step_start_ema self.save_and_sample_every = save_and_sample_every self.batch_size = train_batch_size self.image_size = diffusion_model.image_size self.gradient_accumulate_every = gradient_accumulate_every self.train_num_steps = train_num_steps self.cfg = cfg dl = dataset self.len_dataloader = len(dl) self.dl = cycle(dl) self.opt = Adam(diffusion_model.parameters(), lr=train_lr) self.step = 0 # Ensure self.step is initialized here self.amp = amp self.scaler = GradScaler(enabled=amp) self.max_grad_norm = max_grad_norm self.num_sample_rows = num_sample_rows self.results_folder = Path(results_folder) self.results_folder.mkdir(exist_ok=True, parents=True) if not os.path.exists(str(self.results_folder) + '/logs'): os.makedirs(str(self.results_folder) + '/logs') self.writer = SummaryWriter(str(self.results_folder) + '/logs') # Add a list to store loss values self.losses = [] self.reset_parameters() def reset_parameters(self): self.ema_model.load_state_dict(self.model.state_dict()) def step_ema(self): """ Update EMA, ensuring it starts at step_start_ema """ if self.step == self.step_start_ema: model_dict = self.model.state_dict() ema_model_dict = self.ema_model.state_dict() missing_in_ema = [k for k in model_dict if k not in ema_model_dict] missing_in_model = [k for k in ema_model_dict if k not in model_dict] if missing_in_ema: print(f"Keys in model but not in ema_model: {missing_in_ema}") if missing_in_model: print(f"Keys in ema_model but not in model: {missing_in_model}") self.ema_model.load_state_dict(self.model.state_dict(), strict=False) elif self.step >= self.step_start_ema: self.ema.update_model_average(self.ema_model, self.model) def save(self, milestone): data = { 'step': self.step, 'model': self.model.state_dict(), 'ema': self.ema_model.state_dict(), 'scaler': self.scaler.state_dict(), } torch.save(data, self.results_folder / f'{milestone}.pt') def load(self, milestone, map_location=None, **kwargs): if milestone == -1: milestones = [int(p.stem.split('-')[-1]) for p in self.results_folder.glob('**/*.pt')] milestone = max(milestones) if milestones else None if milestone is not None: data = torch.load(self.results_folder / f'{milestone}.pt', map_location=map_location) self.step = data['step'] self.model.load_state_dict(data['model'], **kwargs) self.ema_model.load_state_dict(data['ema'], **kwargs) self.scaler.load_state_dict(data['scaler']) def get_similar(self, current_name, text): if not text: return None, None, None, None, None attempts = 0 while attempts < self.len_dataloader: item = next(self.dl) attempts += 1 # skip current case if item['name'][0] == current_name: continue # get text data text_data = item.get('text', []) if not isinstance(text_data, list): continue # check if there is an exact text match if text in text_data: # process image and mask data pre_image = item['image.pre'].cuda() if isinstance(item['image.pre'], torch.Tensor) else torch.tensor(item['image.pre']).float().cuda() pre_mask = item['label.pre'].cuda() if isinstance(item['label.pre'], torch.Tensor) else torch.tensor(item['label.pre']).float().cuda() pre_mask[pre_mask == 1] = 0 pre_mask[pre_mask >= 2] = 1 post_image = item['image.post'].cuda() if isinstance(item['image.post'], torch.Tensor) else torch.tensor(item['image.post']).float().cuda() post_mask = item['label.post'].cuda() if isinstance(item['label.post'], torch.Tensor) else torch.tensor(item['label.post']).float().cuda() post_mask[post_mask == 1] = 0 post_mask[post_mask >= 2] = 1 print(f"Found exact text match for {current_name}") return pre_image, pre_mask, post_image, post_mask, item['text'] print(f"No exact text match found for {current_name}") return None, None, None, None, None def train(self, prob_focus_present=0., focus_present_mask=None, log_fn=lambda x: x): best_train_loss = float('inf') while self.step < self.train_num_steps: for i in range(self.gradient_accumulate_every): data = next(self.dl) # add checkpoint # print("\nDataloader output check:") # print(f"image.pre shape: {data['image.pre'].shape}") # print(f"label.pre shape: {data['label.pre'].shape}") # print(f"image.post shape: {data['image.post'].shape}") # print(f"label.post shape: {data['label.post'].shape}") image = data['image.pre'].cuda() mask = data['label.pre'].cuda() post_image = data['image.post'].cuda() post_mask = data['label.post'].cuda() text = data.get('text', None) name = data.get('name', None) print(name) name = name[0] mask[mask == 1] = 0 mask[mask >= 2] = 1 post_mask[post_mask == 1] = 0 post_mask[post_mask >= 2] = 1 # input_data = torch.cat([image, mask, post_image, post_mask], dim=0) input_data = [image, mask, post_image, post_mask] keyword = [] keywords = [ "Raltitrexed", "Epirubicin", "Oxaliplatin", "Lobaplatin", "Idarubicin", "Cisplatin", "THP", "Mitomycin", "Doxorubicin", "Hydroxycamptothecin", "LC beads", "Nedaplatin", "Pirarubicin", "Lipiodol", "PVA", "KMG", "Absolute Alcohol", "NBCA", "Gelatin Sponge" ] if text is not None and len(text) > 0: # print(text) chosen_text_line = random.choice(text) for kw in keywords: if kw in chosen_text_line: keyword.append(kw) # break pre_img_sim, pre_mask_sim, post_img_sim, post_mask_sim, text_sim_line = self.get_similar(name, random.choice(text)) with autocast(enabled=self.amp): loss = self.model( input_data, prob_focus_present=prob_focus_present, focus_present_mask=focus_present_mask, text=text, pre_img_sim=pre_img_sim, pre_mask_sim=pre_mask_sim, post_img_sim=post_img_sim, post_mask_sim=post_mask_sim, text_sim=text_sim_line, ) self.scaler.scale(loss / self.gradient_accumulate_every).backward() print(f'Step {self.step}: Loss = {loss.item()}') log = {'loss': loss.item()} if self.max_grad_norm: self.scaler.unscale_(self.opt) nn.utils.clip_grad_norm_(self.model.parameters(), self.max_grad_norm) self.scaler.step(self.opt) self.scaler.update() self.opt.zero_grad() self.writer.add_scalar('Train_Loss', loss.item(), self.step) self.writer.add_scalar('Learning_rate', self.opt.param_groups[0]['lr'], self.step) if self.step % self.update_ema_every == 0: self.step_ema() if loss.item() < best_train_loss: best_train_loss = loss.item() self.save('best_model') if self.step % self.save_and_sample_every == 0: self.save(self.step // self.save_and_sample_every) log_fn(log) self.step += 1 print('Training completed') class Tester(object): def __init__( self, diffusion_model, ): super().__init__() self.model = diffusion_model self.ema_model = copy.deepcopy(self.model) self.step=0 self.image_size = diffusion_model.image_size self.reset_parameters() def reset_parameters(self): self.ema_model.load_state_dict(self.model.state_dict()) def load(self, milestone, map_location=None, **kwargs): if milestone == -1: all_milestones = [int(p.stem.split('-')[-1]) for p in Path(self.results_folder).glob('**/*.pt')] assert len( all_milestones) > 0, 'need to have at least one milestone to load from latest checkpoint (milestone == -1)' milestone = max(all_milestones) if map_location: data = torch.load(milestone, map_location=map_location) else: data = torch.load(milestone) self.step = data['step'] self.model.load_state_dict(data['model'], **kwargs) self.ema_model.load_state_dict(data['ema'], **kwargs) def get_bbox_from_mask(mask): """get the bbox coordinates of the mask""" # find the indices of the non-zero elements indices = torch.nonzero(mask) if indices.shape[0] == 0: return None # get the bbox coordinates min_d = indices[:, 2].min() max_d = indices[:, 2].max() min_h = indices[:, 3].min() max_h = indices[:, 3].max() min_w = indices[:, 4].min() max_w = indices[:, 4].max() return min_d, max_d, min_h, max_h, min_w, max_w def create_bbox_mask(mask_shape, bbox_coords): """create bbox mask""" device = bbox_coords[0].device # get device information from coordinates mask = torch.zeros(mask_shape, device=device) min_d, max_d, min_h, max_h, min_w, max_w = bbox_coords mask[:, :, min_d:max_d+1, min_h:max_h+1, min_w:max_w+1] = 1 return mask