Upload 16 files

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+result/S2NO_small_limb_36_with_box.pdf filter=lfs diff=lfs merge=lfs -text

FNO_pretrain.py

@@ -0,0 +1,319 @@
+import pytorch_lightning as pl
+import torch
+import wandb
+import numpy as np
+import math
+import matplotlib.pyplot as plt
+import torch.nn as nn
+from torch import optim
+import torch.nn.functional as F
+
+from models.basics_model import get_grid2D,FC_nn
+from scipy.io import loadmat
+import os
+##################
+#fourier convolution 2d block
+
+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
+    
+
+class fourier_conv_2d(nn.Module):
+    def __init__(self, in_, out_, wavenumber1, wavenumber2):
+        super(fourier_conv_2d, self).__init__()
+        self.out_ = out_
+        self.wavenumber1 = wavenumber1
+        self.wavenumber2 = wavenumber2
+        scale = (1 / (in_ * out_))
+        self.weights1 = nn.Parameter(scale * torch.rand(in_, out_, wavenumber1, wavenumber2, 2 , dtype=torch.float32))
+        self.weights2 = nn.Parameter(scale * torch.rand(in_, out_, wavenumber1, wavenumber2, 2 , dtype=torch.float32))
+        # Complex multiplication
+    def compl_mul2d(self, input, weights):
+        # (batch, in_channel, x,y ,2), (in_channel, out_channel, x,y,2) -> (batch, out_channel, x,y)
+        return torch.einsum("bixyz,ioxyz->boxyz", input, weights)
+    def forward(self, x):
+        #input: batch,channel,x,y
+        #out: batch,channel,x,y
+        batchsize = x.shape[0]
+        #Compute Fourier coeffcients up to factor of e^(- something constant)
+        x_ft = torch.view_as_real(torch.fft.rfft2(x))#input: batch,channel,x,y->batch,channel,x,y,2
+        # Multiply relevant Fourier modes
+        out_ft = torch.zeros(batchsize, self.out_,  x.size(-2), x.size(-1)//2 + 1,2, dtype=torch.float32, device=x.device)
+        out_ft[:, :, :self.wavenumber1, :self.wavenumber2,:] = \
+            self.compl_mul2d(x_ft[:, :, :self.wavenumber1, :self.wavenumber2,:], self.weights1)
+        out_ft[:, :, -self.wavenumber1:, :self.wavenumber2,:] = \
+            self.compl_mul2d(x_ft[:, :, -self.wavenumber1:, :self.wavenumber2,:], self.weights2)
+        #Return to physical space
+        x = torch.fft.irfft2(torch.view_as_complex(out_ft), s=(x.size(-2), x.size(-1)))
+        return x
+    
+
+######################################################
+#fourier convolution layer using fourier conv block and conv2d block
+class Fourier_layer(nn.Module):
+    def __init__(self,  features_, wavenumber, activation = 'relu', is_last = False):
+        super(Fourier_layer, self).__init__()
+        self.W =  nn.Conv2d(features_, features_, 1)
+        self.fourier_conv = fourier_conv_2d(features_, features_ , *wavenumber)
+        if is_last== False: 
+            self.act = F.relu
+        else: 
+            self.act = nn.Identity()
+    def forward(self, x):
+        x1 = self.fourier_conv(x)
+        x2 = self.W(x)
+        return self.act(x1 + x2) 
+    
+######################################################
+#fourier neural operator implementation
+class FNO_pretrain(pl.LightningModule):
+    def __init__(self,     
+                    wavenumber=[128,128,128,128,128,128,128], features_=40, 
+                    padding = 6, 
+                    activation= 'relu',
+                    lifting = None, 
+                    proj =  None, 
+                    dim_input = 1,
+                    source_type = 'theta',  
+                    add_term = False, 
+                    loss = "rel_l2",
+                    learning_rate = 1e-3, 
+                    step_size= 100,
+                    gamma= 0.5,
+                    weight_decay= 1e-5,
+                    eta_min = 5e-4,
+                    val_exp = False,
+                    src_path_breast = '',
+                    gt_path_breast = '',
+                    src_path_arm = '',
+                    gt_path_arm = '',
+                    src_path_limb = '',
+                    gt_path_limb = ''   
+                    ):
+        super(FNO_pretrain, self).__init__()
+        self.with_grid = True
+        if self.with_grid == True: 
+            dim_input +=2
+        self.source_type = source_type
+        if self.source_type == 'source':
+            dim_input +=2
+        elif self.source_type == 'theta':
+            dim_input +=2
+        self.padding = padding   
+        self.layers = len(wavenumber)
+        self.learning_rate = learning_rate
+        self.step_size = step_size
+        self.gamma = gamma
+        self.weight_decay = weight_decay
+        self.eta_min = eta_min
+        self.add_term = add_term
+        if loss == 'l1':
+            self.criterion = nn.L1Loss()
+            self.criterion_val = LpLoss()
+        elif loss == 'l2':
+            self.criterion = nn.MSELoss()
+            self.criterion_val = LpLoss()
+        elif loss == 'smooth_l1':
+            self.criterion = nn.SmoothL1Loss()
+            self.criterion_val = LpLoss()
+        elif loss == "rel_l2":
+            self.criterion = LpLoss()
+            self.criterion_val = RRMSE()
+        
+        if lifting is None:
+            self.lifting = FC_nn([dim_input, features_//2, features_], 
+                                    activation = "relu",
+                                    outermost_norm=False
+                                    )
+        else: 
+            self.lifting = lifting
+        if  proj is None: 
+            self.proj =  FC_nn([features_, features_//2, 2], 
+                                activation = "relu",
+                                outermost_norm=False
+                                    )
+        else: 
+            self.proj = proj
+        self.fno = []
+        for l in range(self.layers-1):
+            self.fno.append(Fourier_layer(features_ = features_, 
+                                        wavenumber=[wavenumber[l]]*2, 
+                                        activation = activation))
+        
+        self.fno.append(Fourier_layer(features_=features_, 
+                                        wavenumber=[wavenumber[-1]]*2, 
+                                        activation = activation,
+                                        is_last= True))
+        self.fno =nn.Sequential(*self.fno)
+        self.val_iter = 0
+        
+        self.val_exp = val_exp
+        self.save_path = None
+        self.exp_name = None
+        self.src_path_breast = src_path_breast
+        self.gt_path_breast = gt_path_breast
+        self.src_path_arm = src_path_arm
+        self.src_path_limb = src_path_limb
+        self.gt_path_arm = gt_path_arm
+        self.gt_path_limb = gt_path_limb
+
+
+
+        if self.val_exp:
+            data = loadmat('/gpfs/share/home/2401112587/neuralFWI/resources/exp_speed/breast0718.mat')['image']
+            data = (1500/data-1)*30
+            sos = torch.tensor(data,dtype=torch.float).view(1,480,480,1)
+            sos = sos.repeat(64,1,1,1)
+            self.sos_exp_breast = sos
+            index_2 = np.arange(0,64).reshape(64,1,1,1)
+            src = np.load(self.src_path_breast)[:,:,:]*2e-3
+            src = np.concatenate((np.real(src)[:,:,:,np.newaxis],np.imag(src)[:,:,:,np.newaxis]),axis = -1)
+            self.src_exp_breast =  torch.tensor(src,dtype=torch.float).view(64,480,480,2)
+            gt_np = loadmat(self.gt_path_breast)['u_all_single']
+            gt = torch.view_as_real(torch.tensor(gt_np))
+            self.gt_breast = torch.tensor(gt)
+
+            data = loadmat('/gpfs/share/home/2401112587/neuralFWI/resources/exp_speed/armcbs1022.mat')['speed']
+            data = (1500/data-1)*30
+            sos = torch.tensor(data,dtype=torch.float).view(1,480,480,1)
+            sos = sos.repeat(64,1,1,1)
+            self.sos_exp_arm = sos
+            index_2 = np.arange(0,64).reshape(64,1,1,1)
+            src = np.load(self.src_path_arm)[:,:,:]*2e-3
+            #theta = (index_2/64*2*np.pi)*np.ones((1,480,480,1))
+            src = np.concatenate((np.real(src)[:,:,:,np.newaxis],np.imag(src)[:,:,:,np.newaxis]),axis = -1)
+            self.src_exp_arm =  torch.tensor(src,dtype=torch.float).view(64,480,480,2)
+            gt_np = loadmat(self.gt_path_arm)['u_all_single']
+            gt = torch.view_as_real(torch.tensor(gt_np))
+            self.gt_arm = torch.tensor(gt)
+
+            data = loadmat('/gpfs/share/home/2401112587/neuralFWI/resources/exp_speed/limb0718.mat')['image']
+            data = (1500/data-1)*30
+            sos = torch.tensor(data,dtype=torch.float).view(1,480,480,1)
+            sos = sos.repeat(64,1,1,1)
+            self.sos_exp_limb = sos
+            index_2 = np.arange(0,64).reshape(64,1,1,1)
+            src = np.load(self.src_path_limb)[:,:,:]*2e-3
+            #theta = (index_2/64*2*np.pi)*np.ones((1,480,480,1))
+            src = np.concatenate((np.real(src)[:,:,:,np.newaxis],np.imag(src)[:,:,:,np.newaxis]),axis = -1)
+            self.src_exp_limb =  torch.tensor(src,dtype=torch.float).view(64,480,480,2)
+            gt_np = loadmat(self.gt_path_limb)['u_all_single']
+            gt = torch.view_as_real(torch.tensor(gt_np))
+            self.gt_limb = torch.tensor(gt)
+            
+
+    def forward(self, sos,src):
+        # 100,960,960,2
+        #x = torch.cat((sos, src), dim=-1)
+        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.lifting(x)  # 100,960,960,feature_
+        x = x.permute(0, 3, 1, 2)# batch,feature,x,y:   100,feature_,960,960
+        x = nn.functional.pad(x, [0,self.padding, 0,self.padding]) 
+        x = self.fno(x)# batch,feature,x,y:   100,feature_,960+pad,960+pad
+        x = x[..., :-self.padding, :-self.padding] # batch,feature,x,y:   100,feature_,960,960
+        x = x.permute(0, 2, 3, 1 )
+        x =self.proj(x)  # batch,x,y,2:   100,960,960 ,2
+        if self.add_term == True:
+            
+            x = torch.view_as_real(torch.view_as_complex(field.to(x.device))*(1+torch.view_as_complex(x)))
+        return x
+    
+    def training_step(self, batch: torch.Tensor, batch_idx):      
+        sos,src,y,index = batch
+        batch_size = sos.shape[0]
+        out = self(sos,src)
+        loss = self.criterion(out, y) 
+        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
+        },
+    }
+
+
+
+
+

S2NO_pretrain.py

@@ -0,0 +1,391 @@
+import numpy as np
+import torch
+import pytorch_lightning as pl
+from torch import optim, nn
+import torch.nn.functional as F
+
+import wandb
+import matplotlib.pyplot as plt
+import math
+import os
+from scipy.io import loadmat
+
+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
+    
+
+class SpectralConv2d_born(nn.Module):
+    '''
+    Input:
+    x: batch,in, x,y
+    x_eps: batch,in,x,y
+    Output: batch,out,x,y
+    '''
+    def __init__(self, in_channels, out_channels, modes1, modes2):
+        super(SpectralConv2d_born, self).__init__()
+
+        """
+        2D Fourier layer. It does FFT, linear transform, and Inverse FFT.
+        """
+
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.modes1 = modes1  # Number of Fourier modes to multiply, at most floor(N/2) + 1
+        self.modes2 = modes2
+        self.scale = 1 / (in_channels * out_channels)
+        self.weights1 = nn.Parameter(
+            self.scale * torch.rand(in_channels, out_channels, self.modes1, self.modes2,2, dtype=torch.float32)
+        )
+        self.weights2 = nn.Parameter(
+            self.scale * torch.rand(in_channels, out_channels, self.modes1, self.modes2,2, dtype=torch.float32)
+        )
+    def compl_mul2d(self,input, weights):
+        #print(input.shape,weights.shape)
+        real = torch.einsum('bixy,ioxy->boxy',input[...,0],weights[...,0])-torch.einsum('bixy,ioxy->boxy',input[...,1],weights[...,1])
+        comp = torch.einsum('bixy,ioxy->boxy',input[...,0],weights[...,1])+torch.einsum('bixy,ioxy->boxy',input[...,1],weights[...,0])
+        output = torch.cat((real.unsqueeze(-1),comp.unsqueeze(-1)),dim = -1)
+        
+        return output
+    # Complex multiplication
+    # def compl_mul2d(self, input, weights):
+    #     # (batch, in_channel, x,y ), (in_channel, out_channel, x,y) -> (batch, out_channel, x,y)
+    #     return torch.einsum("bixyz,ioxyz->boxyz", input, weights)
+
+    def forward(self, x, x_eps):
+        batchsize = x.shape[0]
+        # Compute Fourier coeffcients up to factor of e^(- something constant)
+        x_ft = torch.view_as_real(torch.fft.rfft2(x * x_eps))
+        # Multiply relevant Fourier modes
+        out_ft = torch.zeros(
+            batchsize, self.out_channels, x.size(-2), x.size(-1) // 2 + 1,2, dtype=torch.float32, device=x.device
+        )
+        
+        out_ft[:, :, : self.modes1, : self.modes2] = self.compl_mul2d(
+            x_ft[:, :, : self.modes1, : self.modes2,:], self.weights1
+        )
+        out_ft[:, :, -self.modes1 :, : self.modes2] = self.compl_mul2d(
+            x_ft[:, :, -self.modes1 :, : self.modes2,:], self.weights2
+        )
+        # Return to physical space
+        x = torch.fft.irfft2(torch.view_as_complex(out_ft), s=(x.size(-2), x.size(-1)))
+        return x
+
+
+class FNO_step(nn.Module):
+    def __init__(self, width, modes1, modes2 ):
+        super(FNO_step, self).__init__()
+        self.modes1 = modes1 # Truncate mode of FT in x
+        self.modes2 = modes2 # Truncate mode of FT in y
+        self.width = width #image size 
+        self.conv0 = SpectralConv2d_born(self.width, self.width, self.modes1, self.modes2)
+        self.w0 = nn.Conv2d(self.width, self.width, 1)
+        self.w1 = nn.Conv2d(self.width, self.width, 1)
+        self.bn = nn.BatchNorm2d(self.width, eps=0, momentum=0.5, affine=True)
+        #self.coef = nn.Parameter(torch.ones(1)).cuda()
+    def forward(self,input):
+        # Qin Jiu Shao version
+        x,v_v,v_q,x_0, v_mq= input
+        x_n = x.clone()
+        x = self.conv0(x, v_v)
+        x = x * v_mq+ v_q * x_n 
+        x = self.w1(F.leaky_relu(self.w0(x)))
+        x = F.leaky_relu(x)
+        x = x + x_0
+        x = self.bn(x)
+        return [x,v_v,v_q,x_0,v_mq]
+
+class S2NO_step_wrap(nn.Module):
+    def __init__(self, model,width):
+        super(S2NO_step_wrap, self).__init__()
+        self.model  = model
+        #self.DC = DC1(self.width, 8, self.width, 3)
+        self.bn = nn.BatchNorm2d(width, eps=0, momentum=0.5, affine=True)
+        #self.ln = torch.nn.LayerNorm(489, eps=1e-05, elementwise_affine=True)
+        
+    def forward(self,input):
+        # Qin Jiu Shao version
+        #x = self.DC(x)
+        [x,v_v,v_q,x_0] = self.model(input)
+        x = self.bn(x)
+        return [x,v_v,v_q,x_0]
+
+
+class S2NO_pretrain(pl.LightningModule):
+    def __init__(self,width=40,
+                    modes1=128,
+                    modes2=128, 
+                    layer_num=7,
+                    padding = 6,
+                    dim_input = 1, 
+                    source_type = 'theta', 
+                    loss = "rel_l2",
+                    learning_rate = 1e-2, 
+                    step_size= 100,
+                    gamma= 0.5,
+                    weight_decay= 1e-5,
+                    F_feature = False,
+                    add_term = False,
+                    eta_min = 2e-4,
+                    val_exp = False,
+                    src_path_breast = '',
+                    gt_path_breast = '',
+                    src_path_arm = '',
+                    gt_path_arm = '',
+                    src_path_limb = '',
+                    gt_path_limb = ''                    
+                    ):
+        super().__init__()
+        self.with_grid = True
+        if self.with_grid == True: 
+            dim_input +=2
+        self.source_type = source_type
+        if self.source_type == 'source':
+            dim_input +=2
+        elif self.source_type == 'theta':
+            dim_input +=2
+        self.padding = padding   
+        self.learning_rate = learning_rate
+        self.step_size = step_size
+        self.gamma = gamma
+        self.weight_decay = weight_decay
+        self.eta_min = eta_min
+        if loss == 'l1':
+            self.criterion = nn.L1Loss()
+        elif loss == 'l2':
+            self.criterion = nn.MSELoss()
+            self.criterion_val = LpLoss()
+        elif loss == "rel_l2":
+            self.criterion =LpLoss()
+            self.criterion_val = RRMSE()
+
+
+        
+        self.modes1 = modes1 # Truncate mode of FT in x
+        self.modes2 = modes2 # Truncate mode of FT in y
+        self.width = width #image size 
+        self.padding = padding  # pad the domain if input is non-periodic
+        self.fc_c1 = nn.Linear(3, self.width)  # input channel is 3: (c(x, y), x, y)
+        self.fc_c2 = nn.Linear(self.width, self.width)
+        self.fc_c3 = nn.Linear(3, self.width)  # input channel is 3: (c(x, y), x, y)
+        self.fc_c4 = nn.Linear(self.width, self.width)
+        self.fc_0 = nn.Linear(dim_input, self.width)  # input channel is 4: (s(x,y),c(x, y), x, y)
+        self.layer_num = layer_num
+        self.fno_step = []
+
+        for i in range(layer_num):
+            self.fno_step.append(FNO_step(self.width,self.modes1,self.modes2).to(self.device))
+        self.net =nn.Sequential(*self.fno_step)
+        self.F_feature = F_feature
+        self.add_term = add_term
+        self.fc1 = nn.Linear(self.width, 256)
+        self.fc2 = nn.Linear(256, 2)
+        self.val_iter = 0
+        self.bn = nn.BatchNorm2d(self.width, eps=0, momentum=0.5, affine=True, track_running_stats=True)
+        #self.field = torch.tensor(np.load('/root/Fine-tuning-NOs-master/models/field.npy'))
+        self.val_exp = val_exp
+        self.save_path = None
+        self.exp_name = None
+        self.src_path_breast = src_path_breast
+        self.gt_path_breast = gt_path_breast
+        self.src_path_arm = src_path_arm
+        self.src_path_limb = src_path_limb
+        self.gt_path_arm = gt_path_arm
+        self.gt_path_limb = gt_path_limb
+        if self.val_exp:
+            data = loadmat('/gpfs/share/home/2201213309/neuralFWI/breast_generator0822/exp_matcode/breast0718.mat')['image']
+            data = (1500/data-1)*30
+            sos = torch.tensor(data,dtype=torch.float).view(1,480,480,1)
+            sos = sos.repeat(64,1,1,1)
+            self.sos_exp_breast = sos
+            index_2 = np.arange(0,64).reshape(64,1,1,1)
+            src = np.load(self.src_path_breast)[:,:,:]*2e-3
+            src = np.concatenate((np.real(src)[:,:,:,np.newaxis],np.imag(src)[:,:,:,np.newaxis]),axis = -1)
+            self.src_exp_breast =  torch.tensor(src,dtype=torch.float).view(64,480,480,2)
+            gt_np = loadmat(self.gt_path_breast)['u_all_single']
+            gt = torch.view_as_real(torch.tensor(gt_np))
+            self.gt_breast = torch.tensor(gt)
+
+            #data = loadmat('/gpfs/share/home/2201213309/neuralFWI/arm_generator1020/code1020/arm450.mat')['data']
+            data = loadmat('/gpfs/share/home/2201213309/neuralFWI/arm_generator1020/code1020/armcbs1022.mat')['speed']
+            data = (1500/data-1)*30
+            sos = torch.tensor(data,dtype=torch.float).view(1,480,480,1)
+            sos = sos.repeat(64,1,1,1)
+            self.sos_exp_arm = sos
+            index_2 = np.arange(0,64).reshape(64,1,1,1)
+            src = np.load(self.src_path_arm)[:,:,:]*2e-3
+            #theta = (index_2/64*2*np.pi)*np.ones((1,480,480,1))
+            src = np.concatenate((np.real(src)[:,:,:,np.newaxis],np.imag(src)[:,:,:,np.newaxis]),axis = -1)
+            self.src_exp_arm =  torch.tensor(src,dtype=torch.float).view(64,480,480,2)
+            gt_np = loadmat(self.gt_path_arm)['u_all_single']
+            gt = torch.view_as_real(torch.tensor(gt_np))
+            self.gt_arm = torch.tensor(gt)
+
+            #data = loadmat('/gpfs/share/home/2201213309/neuralFWI/limb_generata0703/code0703/limb0718.mat')['image']
+            data = loadmat('/gpfs/share/home/2201213309/neuralFWI/limb_regenerator_1031/code1031/limb0718.mat')['image']
+            data = (1500/data-1)*30
+            sos = torch.tensor(data,dtype=torch.float).view(1,480,480,1)
+            sos = sos.repeat(64,1,1,1)
+            self.sos_exp_limb = sos
+            index_2 = np.arange(0,64).reshape(64,1,1,1)
+            src = np.load(self.src_path_limb)[:,:,:]*2e-3
+            #theta = (index_2/64*2*np.pi)*np.ones((1,480,480,1))
+            src = np.concatenate((np.real(src)[:,:,:,np.newaxis],np.imag(src)[:,:,:,np.newaxis]),axis = -1)
+            self.src_exp_limb =  torch.tensor(src,dtype=torch.float).view(64,480,480,2)
+            gt_np = loadmat(self.gt_path_limb)['u_all_single']
+            gt = torch.view_as_real(torch.tensor(gt_np))
+            self.gt_limb = torch.tensor(gt)
+            
+
+    
+    def forward(self,sos,src):
+        '''
+        x: batch,x,y,channel=3 (c(x),s(x))
+        '''
+        if self.source_type == 'theta':
+            src_input = src[:,:,:,:]    
+        elif self.source_type == 'source':
+            src_input = src[:,:,:,0:2]     
+        # x = torch.cat((sos, src_input), dim=-1)
+        x_1 = sos
+        field = src[...,0:2].clone()
+        
+        grid = self.get_grid(x_1.shape, x_1.device, field)
+
+        x_0 = torch.cat((x_1, grid,src_input), dim=-1)
+        x_c = torch.cat((x_1, grid), dim=-1)
+        
+        v_0 = self.fc_0(x_0)
+        v_0 = v_0.permute(0, 3, 1, 2)
+        if self.padding >=1:
+            v_0 = F.pad(v_0, [0, self.padding, 0, self.padding])
+
+        v_v = self.fc_c2(F.tanh(self.fc_c1(x_c)))
+        v_v = v_v.permute(0, 3, 1, 2)
+        if self.padding >=1:
+            v_v = F.pad(v_v, [0, self.padding, 0, self.padding])
+        v_q = self.fc_c4(F.tanh(self.fc_c3(x_c)))
+        v_q = v_q.permute(0, 3, 1, 2)
+        if self.padding >=1:
+            v_q = F.pad(v_q, [0, self.padding, 0, self.padding])
+        v_mq = 1 - v_q
+        x_1 = v_0
+        x_out = x_1.clone()
+        #for i in range(self.layer_num):
+        [x_out,v_v,v_q,x_1,v_mq] = self.net([x_out,v_v,v_q,x_1, v_mq])
+        if self.padding >=1:
+            x_out = x_out[..., : -self.padding, : -self.padding]
+        x_out = x_out.permute(0, 2, 3, 1)
+        x_out = self.fc1(x_out)
+        x_out = F.leaky_relu(x_out)
+        x_out = self.fc2(x_out)#* self.field.to(x_out.device)
+        if self.add_term == True:
+            #x_out = x_out + field
+            x_out = torch.view_as_real(torch.view_as_complex(field.to(x_out.device))*(1+torch.view_as_complex(x_out)))
+        return x_out 
+
+    def get_grid(self, shape, device,field):
+        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(-3,4):
+        #         feature.append(torch.sin(2**(-i)*gridxy))
+        #         feature.append(torch.cos(2**(-i)*gridxy))
+        #feature.append(field)
+        return gridxy
+    
+    def training_step(self, batch: torch.Tensor, batch_idx):      
+        sos,src,y,index = batch
+        batch_size = sos.shape[0]
+        out = self(sos,src)
+        loss = self.criterion(out, y) 
+        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
+        },
+    }
+
+
+
+
+

UNet_pretrain.py

@@ -0,0 +1,415 @@
+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
+        },
+    }
+
+
+
+
+

homo/homo_250k.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76b6e85d0c470688132d91f59f85562b7a58a3ef802b65d592698ec26602edd5
+size 117964928

homo/homo_300k.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad848793b15e23d4d1bf4489c2fc6cabd20850371f983256dd34129e9623a516
+size 117964928

homo/homo_350k.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bbdfe530d63c1299cadd4e4eb054ff8899928aafca9fc0ae8db581cef972ab9
+size 117964928

homo/homo_400k.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:175184f037731587ef524947edc46835b798a3a4e10a50c68cfaba689daf31f1
+size 117964928

homo/homo_450k.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2eace32059c2fc1006f3795b29c2ec45af4ee71a47a77700daad3cfcc69530c
+size 117964928

homo/homo_500k.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:318ce9c418eabe3cdf3d0147bffd5320b80a41db2bbe41d8dfa41cdfad71cb93
+size 117964928

homo/homo_550k.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb054e3922a0f8f46c616b30fce67574c7057bc230764e33960f3bca56137550
+size 117964928

homo/homo_600k.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac7513b7535530ae76237eda83df46447585f86a87898a37b443d1e765f18bc6
+size 117964928

limb_wavefield.py

@@ -0,0 +1,154 @@
+import os
+import torch
+import numpy as np
+from torch.utils.data import Dataset, DataLoader
+from collections import OrderedDict
+import matplotlib.pyplot as plt
+import torch.nn as nn
+from torch import optim
+import torch.nn.functional as F
+# import sys
+# import random
+from matplotlib.patches import Rectangle
+import argparse
+torch.set_float32_matmul_precision("medium")
+def main(model_name):
+    
+    if model_name == 'S2NO_big':
+        from S2NO_pretrain import S2NO_pretrain
+        model = S2NO_pretrain().cuda()
+        PATH = './S2NO/big/600k.ckpt'
+    if model_name == 'S2NO_small':
+        from S2NO_pretrain import S2NO_pretrain
+        model = S2NO_pretrain(width = 20).cuda()
+        PATH = './S2NO/small/600k.ckpt'
+        # PATH = '/gpfs/share/home/2401112587/neuralFWI/NCBSO_ckpt/NCBSO_20width_mq_lr01_final/600k_model-epoch=007-val_loss=0.0856-val_loss_breast=0.0772-val_loss_arm=0.0773-val_loss_limb=0.1391.ckpt'
+    if model_name == 'FNO_big':
+        from FNO_pretrain import FNO_pretrain
+        model = FNO_pretrain(features_ = 40).cuda()
+        PATH = './FNO/big/600k.ckpt'
+    if model_name == 'FNO_small':
+        from FNO_pretrain import FNO_pretrain
+        model = FNO_pretrain(features_ = 20).cuda()
+        PATH = './FNO/small/600k.ckpt'
+    if model_name == 'UNet':
+        from UNet_pretrain import UNet_pretrain
+        model =UNet_pretrain().cuda()
+        PATH = './UNet/600k.ckpt'
+    checkpoint = torch.load(PATH, map_location=lambda storage, loc: storage)
+    model.load_state_dict(checkpoint['state_dict'])
+
+    homo = np.load('./homo/homo_600k.npy')[0:1,:,:]
+    field_real = torch.tensor(np.real(homo))
+    field_imag = torch.tensor(np.imag(homo))
+    model.eval()
+
+    def inference(data, field_real, field_imag):
+        data = (1500/data - 1)*30
+        data = torch.tensor(data, dtype=torch.float).cuda()
+        batchsize = field_real.shape[0]
+        sos = data.reshape(1,480, 480, 1).repeat(batchsize,1,1,1).cuda()
+        field = torch.concat([field_real.unsqueeze(-1), field_imag.unsqueeze(-1)], dim=-1).cuda() * 2e-3
+        src = field    
+        pred = model(sos, src)
+        pred = pred * 500
+        pred = pred[...,0] + 1j*pred[...,1]
+        return pred
+
+    # 这里定义两块子图的行列范围（row_start:row_end, col_start:col_end）
+    sub1_row_start, sub1_row_end = 323, 343
+    sub1_col_start, sub1_col_end = 230, 250
+    sub2_row_start, sub2_row_end = 234, 254
+    sub2_col_start, sub2_col_end = 184, 204
+
+    index = [36]
+    for i in range(len(index)):
+        path = f'./speed/test_{index[i]}.npy'
+        data = np.load(path)
+        # 推理得到 pred
+        pred = inference(data, field_real, field_imag)
+        pred_np = pred.detach().cpu().numpy()
+        pred_real = np.real(pred_np)
+        
+        # 分别画出两个子图并保存
+        # 子图1
+        fig, ax = plt.subplots(figsize=(5,5), dpi=300)
+        ax.imshow(np.squeeze(pred_real)[
+                sub1_row_start:sub1_row_end,
+                sub1_col_start:sub1_col_end],
+                cmap='seismic',
+                vmin=-2000, vmax=2000)
+        ax.spines['top'].set_visible(False)
+        ax.spines['right'].set_visible(False)
+        ax.spines['bottom'].set_visible(False)
+        ax.spines['left'].set_visible(False)
+        ax.get_xaxis().set_visible(False)
+        ax.get_yaxis().set_visible(False)
+        plt.savefig(f'./result/{model_name}_limb_{index[i]}_small1.pdf',
+                    bbox_inches='tight', pad_inches=0)
+        plt.close()
+
+        # 子图2
+        fig, ax = plt.subplots(figsize=(5,5), dpi=300)
+        ax.imshow(np.squeeze(pred_real)[
+                sub2_row_start:sub2_row_end,
+                sub2_col_start:sub2_col_end],
+                cmap='seismic',
+                vmin=-2000, vmax=2000)
+        ax.spines['top'].set_visible(False)
+        ax.spines['right'].set_visible(False)
+        ax.spines['bottom'].set_visible(False)
+        ax.spines['left'].set_visible(False)
+        ax.get_xaxis().set_visible(False)
+        ax.get_yaxis().set_visible(False)
+        plt.savefig(f'./result/{model_name}_limb_{index[i]}_small2.pdf',
+                    bbox_inches='tight', pad_inches=0)
+        plt.close()
+
+        # 在大图上两个子图相应位置标注出方框
+        # 注意：matplotlib 中默认 (x, y) 是 (列索引, 行索引)，
+        # 因此填入 Rectangle 的时候，需要 (col_start, row_start, width, height)
+        # 画大图 + 标注方框
+        fig, ax = plt.subplots(figsize=(5,5), dpi=300)
+        ax.imshow(np.squeeze(pred_real),
+                cmap='seismic',
+                vmin=-2000, vmax=2000)
+
+        # 第一个方框
+        rect1 = Rectangle((sub1_col_start, sub1_row_start),
+                      sub1_col_end - sub1_col_start,  # width
+                      sub1_row_end - sub1_row_start,  # height
+                      fill=False,
+                      edgecolor='#8CA5D3',
+                      linewidth=2)
+        ax.add_patch(rect1)
+
+        # 第二个方框
+        rect2 = Rectangle((sub2_col_start, sub2_row_start),
+                        sub2_col_end - sub2_col_start,
+                        sub2_row_end - sub2_row_start,
+                        fill=False,
+                        edgecolor='#EDAD81',
+                        linewidth=2)
+        ax.add_patch(rect2)
+
+        ax.spines['top'].set_visible(False)
+        ax.spines['right'].set_visible(False)
+        ax.spines['bottom'].set_visible(False)
+        ax.spines['left'].set_visible(False)
+        ax.get_xaxis().set_visible(False)
+        ax.get_yaxis().set_visible(False)
+
+        # 保存带方框的大图
+        plt.savefig(f'./result/{model_name}_limb_{index[i]}_with_box.pdf',
+                    bbox_inches='tight', pad_inches=0)
+        plt.close()
+if __name__ == '__main__':
+    # 解析命令行参数
+    parser = argparse.ArgumentParser(description='Run model inference with specified model.')
+    parser.add_argument('--model_name', type=str, required=True, 
+                        choices=['S2NO_big', 'S2NO_small', 'FNO_big', 'FNO_small','UNet'],
+                        help='Name of the model to use (e.g., S2NO_small)')
+    args = parser.parse_args()
+    # 调用主函数
+    main(args.model_name)

result/S2NO_small_limb_36_with_box.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1cfce843e4898e73f30b60a38fa2c93a66511bb8cb8d6db4252124d8dae1b72f
+size 783284

speed/test_36.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c77570ff75b1d128adb1cf48d4dd4db5744529fcbfbbb79ef8cadbe2bd9da42
+size 921728