import torch import pytorch_lightning as pl import torch.nn as nn from torch import optim import numpy as np import wandb import matplotlib.pyplot as plt from models.basics_model import get_grid2D,FC_nn from scipy.io import loadmat import os class LpLoss(object): def __init__(self, d=2, p=2, size_average=True, reduction=True): super(LpLoss, self).__init__() assert d > 0 and p > 0 self.d = d self.p = p self.reduction = reduction self.size_average = size_average def abs(self, x, y): num_examples = x.size()[0] h = 1.0 / (x.size()[1] - 1.0) all_norms = (h**(self.d/self.p))*torch.norm(x.view(num_examples,-1) - y.view(num_examples,-1), self.p, 1) if self.reduction: if self.size_average: return torch.mean(all_norms) else: return torch.sum(all_norms) return all_norms def rel(self, x, y): num_examples = x.size()[0] diff_norms = torch.norm(x.reshape(num_examples,-1) - y.reshape(num_examples,-1), self.p, 1) y_norms = torch.norm(y.reshape(num_examples,-1), self.p, 1) if self.reduction: if self.size_average: return torch.mean(diff_norms/y_norms) else: return torch.sum(diff_norms/y_norms) return diff_norms/y_norms def __call__(self, x, y): return self.rel(x, y) class RRMSE(object): def __init__(self, ): super(RRMSE, self).__init__() def __call__(self, x, y): num_examples = x.size()[0] norm = torch.norm(x.view(num_examples,-1) - y.view(num_examples,-1), 2 , 1)**2 normy = torch.norm( y.view(num_examples,-1), 2 , 1)**2 mean_norm = torch.mean((norm/normy)**(1/2)) return mean_norm def get_unet_model(in_ch=1, out_ch=1, scales=5, skip=4, channels=(32, 32, 64, 64, 128, 128), use_sigmoid=True, use_norm=True): #assert (1 <= scales <= 6) skip_channels = [skip] * (scales) return UNet_module(in_ch=in_ch, out_ch=out_ch, channels=channels[:scales], skip_channels=skip_channels, use_sigmoid=use_sigmoid, use_norm=use_norm) class DownBlock(nn.Module): ''' Down sampling ''' def __init__(self, in_ch, out_ch, kernel_size=3, num_groups=4, use_norm=True): super(DownBlock, self).__init__() to_pad = int((kernel_size - 1) / 2) if use_norm: self.conv = nn.Sequential( nn.Conv2d(in_ch, out_ch, kernel_size, stride=2, padding=to_pad), nn.GroupNorm(num_channels=out_ch, num_groups=num_groups), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(out_ch, out_ch, kernel_size, stride=1, padding=to_pad), nn.GroupNorm(num_channels=out_ch, num_groups=num_groups), nn.LeakyReLU(0.2, inplace=True)) else: self.conv = nn.Sequential( nn.Conv2d(in_ch, out_ch, kernel_size, stride=2, padding=to_pad), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(out_ch, out_ch, kernel_size, stride=1, padding=to_pad), nn.LeakyReLU(0.2, inplace=True)) def forward(self, x): x = self.conv(x) return x class InBlock(nn.Module): def __init__(self, in_ch, out_ch, kernel_size=3, num_groups=2, use_norm=True): super(InBlock, self).__init__() to_pad = int((kernel_size - 1) / 2) if use_norm: self.conv = nn.Sequential( nn.Conv2d(in_ch, out_ch, kernel_size, stride=1, padding=to_pad), nn.GroupNorm(num_channels=out_ch, num_groups=num_groups), nn.LeakyReLU(0.2, inplace=True)) else: self.conv = nn.Sequential( nn.Conv2d(in_ch, out_ch, kernel_size, stride=1, padding=to_pad), nn.LeakyReLU(0.2, inplace=True)) def forward(self, x): x = self.conv(x) return x class UpBlock(nn.Module): def __init__(self, in_ch, out_ch, skip_ch=4, kernel_size=3, num_groups=2, use_norm=True): super(UpBlock, self).__init__() to_pad = int((kernel_size - 1) / 2) self.skip = skip_ch > 0 if skip_ch == 0: skip_ch = 1 if use_norm: self.conv = nn.Sequential( nn.GroupNorm(num_channels=in_ch + skip_ch, num_groups=1), #LayerNorm nn.Conv2d(in_ch + skip_ch, out_ch, kernel_size, stride=1, padding=to_pad), nn.GroupNorm(num_channels=out_ch, num_groups=num_groups), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(out_ch, out_ch, kernel_size, stride=1, padding=to_pad), nn.GroupNorm(num_channels=out_ch, num_groups=num_groups), nn.LeakyReLU(0.2, inplace=True)) else: self.conv = nn.Sequential( nn.Conv2d(in_ch + skip_ch, out_ch, kernel_size, stride=1, padding=to_pad), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(out_ch, out_ch, kernel_size, stride=1, padding=to_pad), nn.LeakyReLU(0.2, inplace=True)) if use_norm: self.skip_conv = nn.Sequential( nn.Conv2d(out_ch, skip_ch, kernel_size=1, stride=1), nn.GroupNorm(num_channels=skip_ch, num_groups=1), #LayerNorm nn.LeakyReLU(0.2, inplace=True)) else: self.skip_conv = nn.Sequential( nn.Conv2d(out_ch, skip_ch, kernel_size=1, stride=1), nn.LeakyReLU(0.2, inplace=True)) self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True) self.concat = Concat() def forward(self, x1, x2): x1 = self.up(x1) x2 = self.skip_conv(x2) if not self.skip: x2 = x2 * 0 x = self.concat(x1, x2) x = self.conv(x) return x class Concat(nn.Module): def __init__(self): super(Concat, self).__init__() def forward(self, *inputs): inputs_shapes2 = [x.shape[2] for x in inputs] inputs_shapes3 = [x.shape[3] for x in inputs] if (np.all(np.array(inputs_shapes2) == min(inputs_shapes2)) and np.all(np.array(inputs_shapes3) == min(inputs_shapes3))): inputs_ = inputs else: target_shape2 = min(inputs_shapes2) target_shape3 = min(inputs_shapes3) inputs_ = [] for inp in inputs: diff2 = (inp.size(2) - target_shape2) // 2 diff3 = (inp.size(3) - target_shape3) // 2 inputs_.append(inp[:, :, diff2: diff2 + target_shape2, diff3:diff3 + target_shape3]) return torch.cat(inputs_, dim=1) class OutBlock(nn.Module): def __init__(self, in_ch, out_ch): super(OutBlock, self).__init__() self.conv = nn.Conv2d(in_ch, out_ch, kernel_size=1, stride=1) def forward(self, x): x = self.conv(x) return x def __len__(self): return len(self._modules) class UNet_module(nn.Module): def __init__(self, in_ch, out_ch, channels, skip_channels, use_sigmoid=True, use_norm=True): super(UNet_module, self).__init__() assert (len(channels) == len(skip_channels)) self.scales = len(channels) self.use_sigmoid = use_sigmoid self.down = nn.ModuleList() self.up = nn.ModuleList() self.inc = InBlock(in_ch, channels[0], use_norm=use_norm) for i in range(1, self.scales): self.down.append(DownBlock(in_ch=channels[i - 1], out_ch=channels[i], use_norm=use_norm)) for i in range(1, self.scales): self.up.append(UpBlock(in_ch=channels[-i], out_ch=channels[-i - 1], skip_ch=skip_channels[-i], use_norm=use_norm)) self.outc = OutBlock(in_ch=channels[0], out_ch=out_ch) def forward(self, x0): xs = [self.inc(x0), ] for i in range(self.scales - 1): xs.append(self.down[i](xs[-1])) x = xs[-1] for i in range(self.scales - 1): x = self.up[i](x, xs[-2 - i]) return torch.sigmoid(self.outc(x)) if self.use_sigmoid else self.outc(x) class UNet_pretrain(pl.LightningModule): """ """ def __init__(self, in_ch=1, out_ch=2, scales=16, skip=4, source_type = 'theta', channels=[60,60,60,60,120,120,120,120,240, 240, 240,240,480, 480,480, 480], use_sigmoid=False, use_norm=True, learning_rate=0.001, step_size = 5, gamma = 0.5, weight_decay = 0.00001, eta_min = 5e-4, loss = 'rel_l2', F_feature = False, add_term = False, val_exp = False, src_path_breast = '', gt_path_breast = '', src_path_arm = '', gt_path_arm = '', src_path_limb = '', gt_path_limb = '' ): super().__init__() self.in_ch = in_ch self.with_grid = True if self.with_grid == True: self.in_ch +=2 self.source_type = source_type if self.source_type == 'source': self.in_ch +=2 elif self.source_type == 'theta': self.in_ch +=2 self.out_ch = out_ch self.channels = channels self.skip = skip self.use_sigmoid = use_sigmoid self.use_norm = use_norm self.scales = scales self.unet = self.build_unet() self.save_hyperparameters() self.learning_rate = learning_rate self.step_size = step_size self.gamma = gamma self.weight_decay = weight_decay self.F_feature = F_feature self.add_term = add_term self.eta_min = eta_min if loss == 'l1': self.criterion = nn.L1Loss() self.criterion_val = RRMSE() elif loss == 'l2': self.criterion = nn.MSELoss() self.criterion_val = RRMSE() # self.criterion1 = LpLoss() elif loss == 'smooth_l1': self.criterion = nn.SmoothL1Loss() self.criterion_val = RRMSE() elif loss == "rel_l2": self.criterion =LpLoss() self.criterion_val = RRMSE() self.F_feature = F_feature self.add_term = add_term self.val_iter = 0 def forward(self, sos,src): if self.source_type == 'theta': src_input = src[:,:,:,:] elif self.source_type == 'source': src_input = src[:,:,:,0:2] x = sos field = src[...,:2].clone() if self.with_grid == True: grid = get_grid2D(x.shape, x.device) x = torch.cat((x,grid,src_input), dim=-1) # 100,960,960,4 x = self.unet(x.permute(0,3,1,2)).contiguous() x = x.permute(0,2,3,1).contiguous() #print(x.shape,field.shape) if self.add_term == True: x = torch.view_as_real(torch.view_as_complex(field)*(1+torch.view_as_complex(x))) return x def get_grid(self, shape, device): batchsize, size_x, size_y = shape[0], shape[1], shape[2] gridx = torch.tensor(np.linspace(0, 1, size_x), dtype=torch.float) gridx = gridx.reshape(1, size_x, 1, 1).repeat([batchsize, 1, size_y, 1]) gridy = torch.tensor(np.linspace(0, 1, size_y), dtype=torch.float) gridy = gridy.reshape(1, 1, size_y, 1).repeat([batchsize, size_x, 1, 1]) feature = [] gridxy = torch.cat((gridx,gridy), dim=-1).to(device) feature.append(gridxy) if self.F_feature == True: for i in range(1,3): feature.append(torch.sin(10**(-i)*gridxy)) return torch.cat(feature, dim=-1).to(device) def build_unet(self): """ Build UNet with group normalization Parameters ---------- Returns ------- torch.nn module UNet model """ return get_unet_model(in_ch=self.in_ch, out_ch=self.out_ch, scales=self.scales, skip=self.skip, channels=self.channels, use_sigmoid=self.use_sigmoid, use_norm=self.use_norm) def training_step(self, batch: torch.Tensor, batch_idx): # training_step defines the train loop. # it is independent of forward sos,src,y, index = batch batch_size = sos.shape[0] out = self(sos,src) loss = self.criterion(out.view(batch_size,-1), y.view(batch_size,-1)) self.log("loss", loss, on_epoch=True, prog_bar=True, logger=True) wandb.log({"loss": loss.item()}) return loss def validation_step(self, val_batch: torch.Tensor, batch_idx): sos, src, y, index = val_batch split_index = (index[-1] + index[0])//2 batch_size = sos.shape[0] out = self(sos, src) val_loss = self.criterion_val(out.view(batch_size, -1), y.view(batch_size, -1)) return val_loss # def on_validation_epoch_end(self): # error = self.validation_exp_breast(device = self.device) # #self.log('exp_loss_breast', error.item(), on_epoch=True, prog_bar=True, logger=True) # error = self.validation_exp_arm(device = self.device) # #self.log('exp_loss_arm', error.item(), on_epoch=True, prog_bar=True, logger=True) # error = self.validation_exp_limb(device = self.device) # #self.log('exp_loss_limb', error.item(), on_epoch=True, prog_bar=True, logger=True) def configure_optimizers(self, optimizer=None, scheduler=None): if optimizer is None: optimizer = optim.AdamW(self.parameters(), lr=self.learning_rate, weight_decay=self.weight_decay) if scheduler is None: #scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer,T_max = self.step_size, eta_min= self.eta_min) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size = 6, gamma = 0.1)# 6 0.5 return { "optimizer": optimizer, "lr_scheduler": { "scheduler": scheduler }, }