# UPDNet-knee-af8
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- fastMRI
---

This model was used to achieve the 9th highest submission in terms of PSNR on the fastMRI dataset (see https://fastmri.org/leaderboards/) (0.2dB behind the 2nd submission).
It is a base model for acceleration factor 8.
The model uses 25 iterations and a medium-ca-prelu U-net, and a medium sensitivity maps refiner.

## Model description
For more details, see https://arxiv.org/abs/2010.07290.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct knee data from Siemens scanner at acceleration factor 8.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
import tensorflow as tf

from fastmri_recon.models.subclassed_models.updnet import UPDNet

model = UPDNet(
    multicoil=True,
    n_dual=1,
    primal_only=True,
    n_layers=4,
    n_iter=25,
    channel_attention_kwargs={'dense': True},
    refine_smaps=True,
    non_linearity='prelu',
    layers_n_channels=[16 * 2**i for i in range(4)],
)
kspace_size = [1, 1, 320, 320]
inputs = [
    tf.zeros(kspace_size + [1], dtype=tf.complex64),  # kspace
    tf.zeros(kspace_size, dtype=tf.complex64),  # mask
    tf.zeros(kspace_size, dtype=tf.complex64),  # smaps
]
model(inputs)
model.load_weights('model_weights.h5')
```

Using the model is then as simple as:
```python
model([
    kspace,  # shape: [n_slices, n_coils, n_rows, n_cols, 1]
    mask,  # shape: [n_slices, n_coils, n_rows, n_cols]
    smaps,  # shape: [n_slices, n_coils, n_rows, n_cols]
])
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [fastMRI dataset](https://fastmri.org/dataset/).

## Training procedure
The training procedure is described in https://arxiv.org/abs/2010.07290.
This section is WIP.

## Evaluation results
No evaluation available outside the one from the fastMRI leaderboard (id: `updnet_v3`).

## Bibtex entry
```
@inproceedings{Ramzi2020d,
archivePrefix = {arXiv},
arxivId = {2010.07290},
author = {Ramzi, Zaccharie and Ciuciu, Philippe and Starck, Jean-Luc},
booktitle = {ISMRM},
eprint = {2010.07290},
pages = {1--4},
title = {{XPDNet for MRI Reconstruction: an application to the 2020 fastMRI challenge}},
url = {http://arxiv.org/abs/2010.07290},
year = {2021}
}
```


# XPDNet-brain-af8
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- fastMRI
---

This model was used to achieve the 2nd highest submission in terms of PSNR on the fastMRI dataset (see https://fastmri.org/leaderboards/).
It is a base model for acceleration factor 8.
The model uses 25 iterations and a medium MWCNN, and a big sensitivity maps refiner.

## Model description
For more details, see https://arxiv.org/abs/2010.07290.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct brain data from Siemens scanner at acceleration factor 8.
It was shown [here](https://arxiv.org/abs/2106.00753), that it can generalize well, although further tests are required.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
import tensorflow as tf

from fastmri_recon.models.subclassed_models.denoisers.proposed_params import get_model_specs
from fastmri_recon.models.subclassed_models.xpdnet import XPDNet

n_primal = 5
model_fun, model_kwargs, n_scales, res = [
        (model_fun, kwargs, n_scales, res)
        for m_name, m_size, model_fun, kwargs, _, n_scales, res in get_model_specs(n_primal=n_primal, force_res=False)
        if m_name == 'MWCNN' and m_size == 'medium'
][0]
model_kwargs['use_bias'] = False
run_params = dict(
    n_primal=n_primal,
    multicoil=True,
    n_scales=n_scales,
    refine_smaps=True,
    refine_big=True,
    res=res,
    output_shape_spec=True,
    n_iter=25,
)
model = XPDNet(model_fun, model_kwargs, **run_params)
kspace_size = [1, 1, 320, 320]
inputs = [
    tf.zeros(kspace_size + [1], dtype=tf.complex64),  # kspace
    tf.zeros(kspace_size, dtype=tf.complex64),  # mask
    tf.zeros(kspace_size, dtype=tf.complex64),  # smaps
    tf.constant([[320, 320]]),  # shape
]
model(inputs)
model.load_weights('model_weights.h5')
```

Using the model is then as simple as:
```python
model([
    kspace,  # shape: [n_slices, n_coils, n_rows, n_cols, 1]
    mask,  # shape: [n_slices, n_coils, n_rows, n_cols]
    smaps,  # shape: [n_slices, n_coils, n_rows, n_cols]
    shape,  # shape: [n_slices, 2]
])
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [fastMRI dataset](https://fastmri.org/dataset/).

## Training procedure
The training procedure is described in https://arxiv.org/abs/2010.07290.
This section is WIP.

## Evaluation results
On the fastMRI validation dataset, the same model with a smaller sensitivity maps refiner gives the following results for 30 validation volumes per contrast:

| Contrast | T1     | T2     | FLAIR  | T1-POST |
|----------|--------|--------|--------|---------|
| PSNR     | 38.57  | 37.41  |  36.81  | 38.90   |
| SSIM     | 0.9348 | 0.9404 |  0.9086 | 0.9517  |

Further results can be seen on the fastMRI leaderboards for the test and challenge dataset: https://fastmri.org/leaderboards/

## Bibtex entry
```
@inproceedings{Ramzi2020d,
archivePrefix = {arXiv},
arxivId = {2010.07290},
author = {Ramzi, Zaccharie and Ciuciu, Philippe and Starck, Jean-Luc},
booktitle = {ISMRM},
eprint = {2010.07290},
pages = {1--4},
title = {{XPDNet for MRI Reconstruction: an application to the 2020 fastMRI challenge}},
url = {http://arxiv.org/abs/2010.07290},
year = {2021}
}
```


# PDNet-OASIS
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- OASIS
---

This model can be used to reconstruct single coil OASIS data with an acceleration factor of 4.

## Model description
For more details, see https://www.mdpi.com/2076-3417/10/5/1816.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct single coil brain retrospective data from the OASIS database at acceleration factor 4.
It cannot be used on multi-coil data.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
from fastmri_recon.models.functional_models.pdnet import pdnet

model = pdnet()
model.load_weights('model_weights.h5')
```

Using the model is then as simple as:
```python
model([
    kspace,  # shape: [n_slices, n_rows, n_cols, 1]
    mask,  # shape: [n_slices, n_rows, n_cols]
])
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [OASIS dataset](https://www.oasis-brains.org/).

## Training procedure
The training procedure is described in https://www.mdpi.com/2076-3417/10/5/1816 for brain data.
This section is WIP.

## Evaluation results
This model was evaluated using the [OASIS dataset](https://www.oasis-brains.org/).

- PSNR: 33.22
- SSIM: 0.910

## Bibtex entry
```
@article{ramzi2020benchmarking,
  title={Benchmarking MRI reconstruction neural networks on large public datasets},
  author={Ramzi, Zaccharie and Ciuciu, Philippe and Starck, Jean-Luc},
  journal={Applied Sciences},
  volume={10},
  number={5},
  pages={1816},
  year={2020},
  publisher={Multidisciplinary Digital Publishing Institute}
}
```


# CascadeNet-fastmri
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- fastMRI
---

This model can be used to reconstruct single coil fastMRI data with an acceleration factor of 4.

## Model description
For more details, see https://www.mdpi.com/2076-3417/10/5/1816.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct single coil knee data from Siemens scanner at acceleration factor 4.
It cannot be used on multi-coil data.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
from fastmri_recon.models.functional_models.cascading import cascade_net

model = cascade_net()
model.load_weights('model_weights.h5')
```

Using the model is then as simple as:
```python
model([
    kspace,  # shape: [n_slices, n_rows, n_cols, 1]
    mask,  # shape: [n_slices, n_rows, n_cols]
])
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [fastMRI dataset](https://fastmri.org/dataset/).

## Training procedure
The training procedure is described in https://www.mdpi.com/2076-3417/10/5/1816 for brain data.
This section is WIP.

## Evaluation results
This model was evaluated using the [fastMRI dataset](https://fastmri.org/dataset/).

| Contrast | PD    | PDFS   |
|----------|-------|--------|
| PSNR     | 33.98  | 29.88  |
| SSIM     | 0.811 | 0.6251 |

## Bibtex entry
```
@article{ramzi2020benchmarking,
  title={Benchmarking MRI reconstruction neural networks on large public datasets},
  author={Ramzi, Zaccharie and Ciuciu, Philippe and Starck, Jean-Luc},
  journal={Applied Sciences},
  volume={10},
  number={5},
  pages={1816},
  year={2020},
  publisher={Multidisciplinary Digital Publishing Institute}
}
```


# UNet-fastmri
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- fastMRI
---

This model can be used to reconstruct single coil fastMRI data with an acceleration factor of 4.

## Model description
For more details, see https://www.mdpi.com/2076-3417/10/5/1816.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct single coil knee data from Siemens scanner at acceleration factor 4.
It cannot be used on multi-coil data.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
from fastmri_recon.models.functional_models.unet import unet

model = unet(n_layers=4, layers_n_channels=[16, 32, 64, 128], layers_n_non_lins=2,)
model.load_weights('UNet-fastmri/model_weights.h5')

```

Using the model is then as simple as:
```python
model(zero_filled_recon)
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [fastMRI dataset](https://fastmri.org/dataset/).

## Training procedure
The training procedure is described in https://www.mdpi.com/2076-3417/10/5/1816 for brain data.
This section is WIP.

## Evaluation results
This model was evaluated using the [fastMRI dataset](https://fastmri.org/dataset/).

| Contrast | PD    | PDFS   |
|----------|-------|--------|
| PSNR     | 33.64  | 29.89  |
| SSIM     | 0.807 | 0.6334 |

## Bibtex entry
```
@article{ramzi2020benchmarking,
  title={Benchmarking MRI reconstruction neural networks on large public datasets},
  author={Ramzi, Zaccharie and Ciuciu, Philippe and Starck, Jean-Luc},
  journal={Applied Sciences},
  volume={10},
  number={5},
  pages={1816},
  year={2020},
  publisher={Multidisciplinary Digital Publishing Institute}
}
```


# UNet-OASIS
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- OASIS
---

This model can be used to reconstruct single coil OASIS data with an acceleration factor of 4.

## Model description
For more details, see https://www.mdpi.com/2076-3417/10/5/1816.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct single coil brain retrospective data from the OASIS database at acceleration factor 4.
It cannot be used on multi-coil data.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
from fastmri_recon.models.functional_models.unet import unet

model = unet(n_layers=4, layers_n_channels=[16, 32, 64, 128], layers_n_non_lins=2,)
model.load_weights('UNet-fastmri/model_weights.h5')

```

Using the model is then as simple as:
```python
model(zero_filled_recon)
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [OASIS dataset](https://www.oasis-brains.org/).

## Training procedure
The training procedure is described in https://www.mdpi.com/2076-3417/10/5/1816 for brain data.
This section is WIP.

## Evaluation results
This model was evaluated using the [OASIS dataset](https://www.oasis-brains.org/).

- PSNR: 29.8
- SSIM: 0.847

## Bibtex entry
```
@article{ramzi2020benchmarking,
  title={Benchmarking MRI reconstruction neural networks on large public datasets},
  author={Ramzi, Zaccharie and Ciuciu, Philippe and Starck, Jean-Luc},
  journal={Applied Sciences},
  volume={10},
  number={5},
  pages={1816},
  year={2020},
  publisher={Multidisciplinary Digital Publishing Institute}
}
```


# UPDNet-knee-singlecoil-af4
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- fastMRI
---

This model can be used to reconstruct single coil fastMRI data with an acceleration factor of 4.

## Model description
For more details, see https://arxiv.org/abs/2010.07290.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct single coil knee data from Siemens scanner at acceleration factor 4.
It cannot be used on multi-coil data.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
import tensorflow as tf

from fastmri_recon.models.subclassed_models.updnet import UPDNet

model = UPDNet(
    n_dual=1,
    primal_only=True,
    layers_n_channels=[16 * 2**i for i in range(3)],
)
kspace_size = [1, 320, 320]
inputs = [
    tf.zeros(kspace_size + [1], dtype=tf.complex64),  # kspace
    tf.zeros(kspace_size, dtype=tf.complex64),  # mask
]
model(inputs)
model.load_weights('model_weights.h5')
```

Using the model is then as simple as:
```python
model([
    kspace,  # shape: [n_slices, n_rows, n_cols, 1]
    mask,  # shape: [n_slices, n_rows, n_cols]
])
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [fastMRI dataset](https://fastmri.org/dataset/).

## Training procedure
The training procedure is described in https://arxiv.org/abs/2010.07290 for brain data.
This section is WIP.

## Evaluation results
Not available

## Bibtex entry
```
@inproceedings{Ramzi2020d,
archivePrefix = {arXiv},
arxivId = {2010.07290},
author = {Ramzi, Zaccharie and Ciuciu, Philippe and Starck, Jean-Luc},
booktitle = {ISMRM},
eprint = {2010.07290},
pages = {1--4},
title = {{XPDNet for MRI Reconstruction: an application to the 2020 fastMRI challenge}},
url = {http://arxiv.org/abs/2010.07290},
year = {2021}
}
```


# NCPDNet-3D
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- OASIS
---

This is a non-Cartesian 3D MRI reconstruction model for radial trajectories at acceleration factor 4.
The model uses 10 iterations and a small vanilla CNN.

## Model description
For more details, see https://hal.inria.fr/hal-03188997.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct 3D brain data obtained retrospectively from magnitude scanners of the OASIS database at acceleration factor 4 in a fully radial acquisition setting.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
import tensorflow as tf

from fastmri_recon.models.subclassed_models.ncpdnet import NCPDNet

model = NCPDNet(
    three_d=True,
    n_iter=6,
    n_filters=16,
    im_size=(176, 256, 256),
    dcomp=True,
    fastmri=False,
)
kspace_shape = 1
inputs = [
    tf.zeros([1, 1, kspace_shape, 1], dtype=tf.complex64),
    tf.zeros([1, 3, kspace_shape], dtype=tf.float32),
    (tf.constant([(176, 256, 256)]), tf.ones([1, kspace_shape], dtype=tf.float32)),
]
model(inputs)
model.load_weights('model_weights.h5')
```

Using the model is then as simple as:
```python
model([
    kspace,  # shape: [n_batch, 1, n_kspace_samples, 1]
    traj,  # shape: [n_batch, 1, 3, n_kspace_samples]
    (
        output_shape,  # shape: [n_batch, 3]
        dcomp,  # shape: [n_batch, n_kspace_samples]
    )
])
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [OASIS dataset](https://www.oasis-brains.org/).

## Training procedure
The training procedure is described in https://hal.inria.fr/hal-03188997.
This section is WIP.

## Evaluation results
On the OASIS validation dataset:
- PSNR: 33.76

## Bibtex entry
```
@unpublished{ramzi:hal-03188997,
  TITLE = {{NC-PDNet: a Density-Compensated Unrolled Network for 2D and 3D non-Cartesian MRI Reconstruction}},
  AUTHOR = {Ramzi, Zaccharie and G R, Chaithya and Starck, Jean-Luc and Ciuciu, Philippe},
  YEAR = {2021},
  MONTH = Sep,
}
```


# NCPDNet-singlecoil-radial
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- fastMRI
---

This is a non-Cartesian MRI reconstruction model for radial trajectories at acceleration factor 4.
The model uses 10 iterations and a small vanilla CNN.

## Model description
For more details, see https://hal.inria.fr/hal-03188997.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct knee data from Siemens scanner at acceleration factor 4 in a radial acquisition setting.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
import tensorflow as tf

from fastmri_recon.models.subclassed_models.ncpdnet import NCPDNet

model = NCPDNet(
    im_size=(640, 400),
    dcomp=True,
)
kspace_shape = 1
inputs = [
    tf.zeros([1, 1, kspace_shape, 1], dtype=tf.complex64),
    tf.zeros([1, 2, kspace_shape], dtype=tf.float32),
    (tf.constant([320]), tf.ones([1, kspace_shape], dtype=tf.float32)),
]
model(inputs)
model.load_weights('model_weights.h5')
```

Using the model is then as simple as:
```python
model([
    kspace,  # shape: [n_slices, 1, n_kspace_samples, 1]
    traj,  # shape: [n_slices, 1, 2, n_kspace_samples]
    (
        output_shape,  # shape: [n_slices, 1]
        dcomp,  # shape: [n_slices, n_kspace_samples]
    )
])
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [fastMRI dataset](https://fastmri.org/dataset/).

## Training procedure
The training procedure is described in https://hal.inria.fr/hal-03188997.
This section is WIP.

## Evaluation results
On the fastMRI validation dataset:
- PSNR: 32.66
- SSIM: 0.7327

## Bibtex entry
```
@unpublished{ramzi:hal-03188997,
  TITLE = {{NC-PDNet: a Density-Compensated Unrolled Network for 2D and 3D non-Cartesian MRI Reconstruction}},
  AUTHOR = {Ramzi, Zaccharie and G R, Chaithya and Starck, Jean-Luc and Ciuciu, Philippe},
  YEAR = {2021},
  MONTH = Sep,
}
```


# PDNet-fastmri
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- fastMRI
---

This model can be used to reconstruct single coil fastMRI data with an acceleration factor of 4.

## Model description
For more details, see https://www.mdpi.com/2076-3417/10/5/1816.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct single coil knee data from Siemens scanner at acceleration factor 4.
It cannot be used on multi-coil data.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
from fastmri_recon.models.functional_models.pdnet import pdnet

model = pdnet()
model.load_weights('model_weights.h5')
```

Using the model is then as simple as:
```python
model([
    kspace,  # shape: [n_slices, n_rows, n_cols, 1]
    mask,  # shape: [n_slices, n_rows, n_cols]
])
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [fastMRI dataset](https://fastmri.org/dataset/).

## Training procedure
The training procedure is described in https://www.mdpi.com/2076-3417/10/5/1816 for brain data.
This section is WIP.

## Evaluation results
This model was evaluated using the [fastMRI dataset](https://fastmri.org/dataset/).

| Contrast | PD    | PDFS   |
|----------|-------|--------|
| PSNR     | 34.2  | 30.06  |
| SSIM     | 0.818 | 0.9554 |

## Bibtex entry
```
@article{ramzi2020benchmarking,
  title={Benchmarking MRI reconstruction neural networks on large public datasets},
  author={Ramzi, Zaccharie and Ciuciu, Philippe and Starck, Jean-Luc},
  journal={Applied Sciences},
  volume={10},
  number={5},
  pages={1816},
  year={2020},
  publisher={Multidisciplinary Digital Publishing Institute}
}
```


# NCPDNet-singlecoil-spiral
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- fastMRI
---

This is a non-Cartesian MRI reconstruction model for spiral trajectories at acceleration factor 4.
The model uses 10 iterations and a small vanilla CNN.

## Model description
For more details, see https://hal.inria.fr/hal-03188997.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct knee data from Siemens scanner at acceleration factor 4 in a spiral acquisition setting.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
import tensorflow as tf

from fastmri_recon.models.subclassed_models.ncpdnet import NCPDNet

model = NCPDNet(
    im_size=(640, 400),
    dcomp=True,
)
kspace_shape = 1
inputs = [
    tf.zeros([1, 1, kspace_shape, 1], dtype=tf.complex64),
    tf.zeros([1, 2, kspace_shape], dtype=tf.float32),
    (tf.constant([320]), tf.ones([1, kspace_shape], dtype=tf.float32)),
]
model(inputs)
model.load_weights('model_weights.h5')
```

Using the model is then as simple as:
```python
model([
    kspace,  # shape: [n_slices, 1, n_kspace_samples, 1]
    traj,  # shape: [n_slices, 1, 2, n_kspace_samples]
    (
        output_shape,  # shape: [n_slices, 1]
        dcomp,  # shape: [n_slices, n_kspace_samples]
    )
])
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [fastMRI dataset](https://fastmri.org/dataset/).

## Training procedure
The training procedure is described in https://hal.inria.fr/hal-03188997.
This section is WIP.

## Evaluation results
On the fastMRI validation dataset:
- PSNR: 33.08
- SSIM: 0.7534

## Bibtex entry
```
@unpublished{ramzi:hal-03188997,
  TITLE = {{NC-PDNet: a Density-Compensated Unrolled Network for 2D and 3D non-Cartesian MRI Reconstruction}},
  AUTHOR = {Ramzi, Zaccharie and G R, Chaithya and Starck, Jean-Luc and Ciuciu, Philippe},
  YEAR = {2021},
  MONTH = Sep,
}
```


# KIKI-net-fastmri
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- fastMRI
---

This model can be used to reconstruct single coil fastMRI data with an acceleration factor of 4.

## Model description
For more details, see https://www.mdpi.com/2076-3417/10/5/1816.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct single coil knee data from Siemens scanner at acceleration factor 4.
It cannot be used on multi-coil data.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
from fastmri_recon.models.functional_models.kiki_sep import full_kiki_net
from fastmri_recon.models.utils.non_linearities import lrelu

model = full_kiki_net(n_convs=16, n_filters=48, activation=lrelu)
model.load_weights('model_weights.h5')
```

Using the model is then as simple as:
```python
model([
    kspace,  # shape: [n_slices, n_rows, n_cols, 1]
    mask,  # shape: [n_slices, n_rows, n_cols]
])
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [fastMRI dataset](https://fastmri.org/dataset/).

## Training procedure
The training procedure is described in https://www.mdpi.com/2076-3417/10/5/1816 for brain data.
This section is WIP.

## Evaluation results
This model was evaluated using the [fastMRI dataset](https://fastmri.org/dataset/).

| Contrast | PD    | PDFS   |
|----------|-------|--------|
| PSNR     | 32.86  | 29.57  |
| SSIM     | 0.797 | 0.6271 |

## Bibtex entry
```
@article{ramzi2020benchmarking,
  title={Benchmarking MRI reconstruction neural networks on large public datasets},
  author={Ramzi, Zaccharie and Ciuciu, Philippe and Starck, Jean-Luc},
  journal={Applied Sciences},
  volume={10},
  number={5},
  pages={1816},
  year={2020},
  publisher={Multidisciplinary Digital Publishing Institute}
}
```


# KIKI-net-OASIS
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- OASIS
---

This model can be used to reconstruct single coil OASIS data with an acceleration factor of 4.

## Model description
For more details, see https://www.mdpi.com/2076-3417/10/5/1816.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct single coil brain retrospective data from the OASIS database at acceleration factor 4.
It cannot be used on multi-coil data.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
from fastmri_recon.models.functional_models.kiki_sep import full_kiki_net
from fastmri_recon.models.utils.non_linearities import lrelu

model = full_kiki_net(n_convs=16, n_filters=48, activation=lrelu)
model.load_weights('model_weights.h5')

```

Using the model is then as simple as:
```python
model([
    kspace,  # shape: [n_slices, n_rows, n_cols, 1]
    mask,  # shape: [n_slices, n_rows, n_cols]
])
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [OASIS dataset](https://www.oasis-brains.org/).

## Training procedure
The training procedure is described in https://www.mdpi.com/2076-3417/10/5/1816 for brain data.
This section is WIP.

## Evaluation results
This model was evaluated using the [OASIS dataset](https://www.oasis-brains.org/).

- PSNR: 30.08
- SSIM: 0.853

## Bibtex entry
```
@article{ramzi2020benchmarking,
  title={Benchmarking MRI reconstruction neural networks on large public datasets},
  author={Ramzi, Zaccharie and Ciuciu, Philippe and Starck, Jean-Luc},
  journal={Applied Sciences},
  volume={10},
  number={5},
  pages={1816},
  year={2020},
  publisher={Multidisciplinary Digital Publishing Institute}
}
```


# NCPDNet-multicoil-spiral
---
tags:
- TensorFlow
- MRI reconstruction
- MRI
datasets:
- fastMRI
---

This is a non-Cartesian multicoil MRI reconstruction model for spiral trajectories at acceleration factor 4.
The model uses 10 iterations and a small vanilla CNN.

## Model description
For more details, see https://hal.inria.fr/hal-03188997.
This section is WIP.

## Intended uses and limitations
This model can be used to reconstruct multicoil knee data from Siemens scanner at acceleration factor 4 in a spiral acquisition setting.

## How to use
This model can be loaded using the following repo: https://github.com/zaccharieramzi/fastmri-reproducible-benchmark.
After cloning the repo, `git clone https://github.com/zaccharieramzi/fastmri-reproducible-benchmark`, you can install the package via `pip install fastmri-reproducible-benchmark`.
The framework is TensorFlow.

You can initialize and load the model weights as follows:
```python
import tensorflow as tf

from fastmri_recon.models.subclassed_models.ncpdnet import NCPDNet

model = NCPDNet(
    multicoil=True,
    im_size=(640, 400),
    dcomp=True,
    refine_smaps=True,
)
kspace_shape = 1
inputs = [
    tf.zeros([1, 1, kspace_shape, 1], dtype=tf.complex64),
    tf.zeros([1, 2, kspace_shape], dtype=tf.float32),
    tf.zeros([1, 1, 640, 320], dtype=tf.complex64),
    (tf.constant([320]), tf.ones([1, kspace_shape], dtype=tf.float32)),
]
model(inputs)
model.load_weights('model_weights.h5')
```

Using the model is then as simple as:
```python
model([
    kspace,  # shape: [n_slices, n_coils, n_kspace_samples, 1]
    traj,  # shape: [n_slices, n_coils, 2, n_kspace_samples]
    smaps,  # shape: [n_slices, n_coils, n_kspace_samples, n_coils]
    (
        output_shape,  # shape: [n_slices, 1]
        dcomp,  # shape: [n_slices, n_kspace_samples]
    )
])
```

## Limitations and bias
The limitations and bias of this model have not been properly investigated.

## Training data
This model was trained using the [fastMRI dataset](https://fastmri.org/dataset/).

## Training procedure
The training procedure is described in https://hal.inria.fr/hal-03188997.
This section is WIP.

## Evaluation results
On the fastMRI validation dataset:
- PSNR: 40.68
- SSIM: 0.9255

## Bibtex entry
```
@unpublished{ramzi:hal-03188997,
  TITLE = {{NC-PDNet: a Density-Compensated Unrolled Network for 2D and 3D non-Cartesian MRI Reconstruction}},
  AUTHOR = {Ramzi, Zaccharie and G R, Chaithya and Starck, Jean-Luc and Ciuciu, Philippe},
  YEAR = {2021},
  MONTH = Sep,
}
```


---
license: apache-2.0
tags:
- generated_from_trainer
datasets:
- conll2003
metrics:
- precision
- recall
- f1
- accuracy
model_index:
- name: distilbert-base-uncased-finetuned-ner
  results:
  - task:
      name: Token Classification
      type: token-classification
    dataset:
      name: conll2003
      type: conll2003
      args: conll2003
    metric:
      name: Accuracy
      type: accuracy
      value: 0.9850826886110537
---

<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->

# distilbert-base-uncased-finetuned-ner

This model is a fine-tuned version of [distilbert-base-uncased](https://huggingface.co/distilbert-base-uncased) on the conll2003 dataset.
It achieves the following results on the evaluation set:
- Loss: 0.0746
- Precision: 0.9347
- Recall: 0.9426
- F1: 0.9386
- Accuracy: 0.9851

## Model description

More information needed

## Intended uses & limitations

More information needed

## Training and evaluation data

More information needed

## Training procedure

### Training hyperparameters

The following hyperparameters were used during training:
- learning_rate: 2e-05
- train_batch_size: 4
- eval_batch_size: 4
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 3

### Training results

| Training Loss | Epoch | Step  | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:-----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.0832        | 1.0   | 3511  | 0.0701          | 0.9317    | 0.9249 | 0.9283 | 0.9827   |
| 0.0384        | 2.0   | 7022  | 0.0701          | 0.9282    | 0.9410 | 0.9346 | 0.9845   |
| 0.0222        | 3.0   | 10533 | 0.0746          | 0.9347    | 0.9426 | 0.9386 | 0.9851   |

### Framework versions

- Transformers 4.10.0.dev0
- Pytorch 1.8.1
- Datasets 1.11.0
- Tokenizers 0.10.3


---
license: apache-2.0
tags:
- generated_from_trainer
datasets:
- glue
metrics:
- matthews_correlation
model_index:
- name: distilbert-base-uncased-finetuned-cola
  results:
  - task:
      name: Text Classification
      type: text-classification
    dataset:
      name: glue
      type: glue
      args: cola
    metric:
      name: Matthews Correlation
      type: matthews_correlation
      value: 0.5332198659134496
---

<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->

# distilbert-base-uncased-finetuned-cola

This model is a fine-tuned version of [distilbert-base-uncased](https://huggingface.co/distilbert-base-uncased) on the glue dataset.
It achieves the following results on the evaluation set:
- Loss: 0.8549
- Matthews Correlation: 0.5332

## Model description

More information needed

## Intended uses & limitations

More information needed

## Training and evaluation data

More information needed

## Training procedure

### Training hyperparameters

The following hyperparameters were used during training:
- learning_rate: 2e-05
- train_batch_size: 16
- eval_batch_size: 16
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 5

### Training results

| Training Loss | Epoch | Step | Validation Loss | Matthews Correlation |
|:-------------:|:-----:|:----:|:---------------:|:--------------------:|
| 0.5213        | 1.0   | 535  | 0.5163          | 0.4183               |
| 0.3479        | 2.0   | 1070 | 0.5351          | 0.5182               |
| 0.231         | 3.0   | 1605 | 0.6271          | 0.5291               |
| 0.166         | 4.0   | 2140 | 0.7531          | 0.5279               |
| 0.1313        | 5.0   | 2675 | 0.8549          | 0.5332               |

### Framework versions

- Transformers 4.10.0.dev0
- Pytorch 1.8.1
- Datasets 1.11.0
- Tokenizers 0.10.3