Hi, congratulations on this great work! I am trying to train the score network as you/your reference described in the paper, but I am running into out of memory issues (I am using a Quadro RTX 8000 with 45GB of memory). My dataset is 2D image slices of shape (208,240). The only way I can fit the training on memory is to reduce the ngf of the configuration file to 30 from 128 (I believe this is related to the number of channels of the convolutions in the blocks of the network?). I was hoping maybe you could shed some light on this/how you trained your network. Best regards, Thomas Yu

I noticed in the config file there is a langevin_config called fast_fid. Is there code implemented in this repository to compute FID? If I am missing something obvious, I apologize. Also, do you know approximately how long it takes to generate those 1000 samples for a given set of measurements?

Hi, I am writing to consult you on the computation of likelihood score $\nabla_{x_{t}}\log\mu(y\mid x_{t})=\frac{A^{H}(y-Ax_{t})}{\gamma_{t}^{2}+\sigma^{2}}$ in eq. (4) of the corresponding paper.

Specifically, in the code part, I do not understand how you implement $\nabla_{x_{t}}\log\mu(y\mid x_{t})=\frac{A^{H}(y-Ax_{t})}{\gamma_{t}^{2}+\sigma^{2}}$. I guess the code for this is lines 136-152 in main.py, which I copy as follows for reference

                # get measurements for current estimate
                meas = forward_operator(normalize(samples, estimated_mvue))
                # compute gradient, i.e., gradient = A_adjoint * ( y - Ax_hat )
                # here A_adjoint also involves the sensitivity maps, hence the pointwise multiplication
                # also convert to real value since the ``complex'' image is a real-valued two channel image
                meas_grad = torch.view_as_real(torch.sum(self._ifft(meas-ref) * torch.conj(maps), axis=1)).permute(0,3,1,2)
                # re-normalize, since measuremenets are from a normalized estimate
                meas_grad = unnormalize(meas_grad, estimated_mvue)
                # convert to float incase it somehow became double
                meas_grad = meas_grad.type(torch.cuda.FloatTensor)
                meas_grad /= torch.norm( meas_grad )
                meas_grad *= torch.norm( p_grad )
                meas_grad *= self.config['mse']

                # combine measurement gradient, prior gradient and noise
                samples = samples + step_size * (p_grad - meas_grad) + noise

However, from the above code, I do not quite understand the correspondence between meas_grad with the formula $\nabla_{x_{t}}\log\mu(y\mid x_{t})=\frac{A^{H}(y-Ax_{t})}{\gamma_{t}^{2}+\sigma^{2}}$. For example, it seems that only the FFT matrix is considered in A, and I do not see the values of $\sigma^2$, and in particular the value of $\gamma_{t}^2$. Why there is operations like meas_grad /= torch.norm( meas_grad ) and meas_grad *= torch.norm( p_grad ), and something like meas_grad = unnormalize(meas_grad, estimated_mvue)?

I find it difficult to understand the code. I tried to write the code on my own as eq (4) but it does not work. The resultant $\nabla_{x_{t}}\log\mu(y\mid x_{t})=\frac{A^{H}(y-Ax_{t})}{\gamma_{t}^{2}+\sigma^{2}}$ is really big even if I choose a large $\gamma_{t}^{2}$ at the very beginning.

Could you please add some explanations on how you realize eq. (4) step by step in your code? It would be really appreciated if you can use some mathematical equations to illustrate it.

Thank you very much.

Best
Meng

Hi

Can you please provide the script to compute PSNR and SSIM scores from the pre-trained model?
Specifically, how do you do inference (say from Brain T2 - 1.5GB trained model) by taking sparse images (compressed MRI) and then reconstructing them and finally calculating SSIM/PSNR scores? How exactly do you do this?

Thanks.

Hello Dear team,
I was looking at your code and tried to implement on my dataset with fewer samples. But, I couldn't find the checkpoint_100000.pth weights in order to train my model. Did I make a mistake or you didn't provide the weights for public?

Thanks in advance,
Mahdi

Hi, it's a nice job!!, but I don't understand "Invariance to image shapes".
In other words, I don't understand that the model is trianed on T2W image, which size is 384x384, but it can sample knees data like size is 320x320. I don't find the answer in your code.
Can you explain this？
Thanks a lot.