anchor.diff:  
   == Introduction
   
  -Both of the above problems can be stated in the mathematical framework of inverse problems. In inverse problem we seek to find (reconstruct) some parameters given indirect observations. Mathematically this can be stated as finding some parameters stem:[f] that are connected to measured data stem:[g] through the _forward model_ stem:[\mathcal{T}]:
  +These problems are called the deblurring and radon inversion problems respectively, and are both examples of _inverse problems_. In inverse problem we seek to find (reconstruct) some parameters given indirect observations. Mathematically this can be stated as finding some parameters stem:[f] that are connected to measured data stem:[g] through the _forward model_ stem:[\mathcal{T}]:
   
   [stem]
   +++++++++++++++++
   g = \mathcal{T}(f) + noise
   +++++++++++++++++
   
  -Several classical image processing problems such as denoising, inpainting, deblurring and superresolution can be cast into this form, but it is also a good model for more complicated problems such as Computed Tomography (CT), Magnetic Resonance Imaging (MRI), etc.
  +Several classical image processing problems such as denoising, inpainting, deblurring and superresolution can be cast into this form, but it is also a good model for more complicated problems such as Magnetic Resonance Imaging (MRI) and Computed Tomography (CT).
   
   == Machine learning for inverse problems
   
  -If stem:[\mathcal{T}] maps images to images, such as the convolution above, finding the unknown parameters from data using machine learning is at least on a conceptual level straightforward, and any standard convolutional architecture could be used to learn a transformation from stem:[g] to stem:[f]. Simply give the neural network stem:[g] as input and train it to find stem:[f].
  +If the forward model maps images to images, such as the blurring above, finding the unknown parameters from data using machine learning is at least on a conceptual level straightforward, and any standard convolutional architecture could be used to learn a transformation from data to parameters. Simply use known pairs stem:[g, f_{\text{true}}] and train a neural network to map stem:[g] to stem:[f_{\text{true}].
   
   But what happens when stem:[\mathcal{T}] is more complicated? 
  -We'll focus on CT, where the forward model is given by the https://en.wikipedia.org/wiki/Radon_transform[Radon transform] which computes all line integrals of the image:
  +In Computed Tomography, the forward model is given by the https://en.wikipedia.org/wiki/Radon_transform[Radon transform] which computes all line integrals of the image:
   
   [stem]
   +++++++++++++++++
   \mathcal{T}(f)(\ell) = \int_{\ell} f(x) dx  \quad \ell \text{ is a line in } \mathbb{R}^2
   +++++++++++++++++
   
  -If we compare this to the deblurring problem, we see that while the blurring problem has a local relationship between parameters and data, the radon transform has a global relationship. Here two widely separated points can both influence a point in data as long as they lie on the same line. And since the forward model is global, so is the inverse problem. This means that classical local machine-learning approaches based on convolutions will not work.
  +If we compare this to the deblurring problem, we see that while the deblurring problem has a local relationship between parameters and data, the radon transform has a global relationship. Here two points on opposite sides of the image can still influence the same datapoint as long as they lie on the same line. And since the forward model is global, so is the inverse problem. This means that classical local machine-learning approaches based on convolutions will not work.
   
  -One way to solve this would be to use fully-connected layers instead of convolutions, but this quickly becomes infeasible. For example, in the example a single fully connected layer between data and signal would require a staggering stem:[2.6 \cdot 10^{11}] weights. Storing these in single precision would require one terabyte of data. For a single layer. 
  +One way to solve this would be to use fully-connected layers instead of convolutions, but this quickly becomes infeasible. For example, in the example above, a single fully connected layer between data and signal would require a staggering stem:[2.6 \cdot 10^{11}] weights. Storing these in single precision would require one terabyte of data. For a single layer. 
   
   This is obviously not a workable solution.
   
   == Learned denoisers
   
  -One of the most obvious solutions to this problem is to somehow re-cast the problem back into a image-to-image problem. The most popular way of doing this is to first do some initial reconstruction, e.g. https://en.wikipedia.org/wiki/Radon_transform#Radon_inversion_formula[Filtered Back-Projection] (FBP):
  +One of the most obvious solutions to this is to somehow re-cast the problem into an image-to-image problem. The most popular way of doing this is to first perform some initial reconstruction, e.g. https://en.wikipedia.org/wiki/Radon_transform#Radon_inversion_formula[Filtered Back-Projection] (FBP):
   
   video::mayo_fbp_animation.mp4[mayo_fbp_animation, height=309, width=700, options="autoplay,loop"]
   
  
positive.code: 
  == Learned Primal-Dual
  
  This observation leads to a painful conclusion: in order to get a reconstruction that contains more information than current reconstruction methods, we _need_ to work directly from raw data. But as we noted above, fully learning how to do this is practically impossible.
  
  The solution is to take a middle way, to incorporate enough a-priori information  to make the problem tractable and then learn the rest.
  
  
negative.code: 
  image:mayo_phantom.png[mayo_phantom, height=300, width=300]
  
  But what about if you instead got the line integrals of the image:
  
  image:mayo_data.png[mayo_data, height=300, width=300]
  
  