radio - GitLite

KO | EN

gitlite — search

#hacktoberfest #typescript #golang #machine-learning #rust #macos #nodejs #windows #awesome #cli #kubernetes #awesome-list #security #mcp

radio

(★ 228)

RadIO is a library for data science research of computed tomography imaging

File Explorer

Download Latest Version (.zip)

- - .gitignore
- - api.rst
  - ct_batch.rst
  - dense_nodule_net.rst
  - dilated_nodule_net.rst
  - keras_3dunet.rst
  - keras_loss.rst
  - keras_models.rst
  - keras_nodule_vgg.rst
  - keras_res_nodule_net.rst
  - loss_functions.rst
  - masked_batch.rst
  - models.rst
  - pipelines.rst
  - res_nodule_net.rst
  - tf_loss.rst
  - tf_models.rst
  - unpackers.rst
- - models.rst
  - pipelines.rst
  - preprocessing.rst
- conf.py
- index.rst
- make.bat
- Makefile
- 1_Running_preprocessing.ipynb
- 2_Advanced_nodules_sampling.ipynb
- Actions_chaining.ipynb
- Augmentation.ipynb
- DealingWithAnnotation.ipynb
- Notebook_how_to_easily_train_3d_unet.ipynb
- plotting_tools.py
- research_mip.py
- split_dump_npcmr.py
- Using_masked_batch.ipynb
- - __init__.py
  - doctor_confidence.py
  - nodule_confidence.py
  - nodules_merger.py
  - parser.py
- - __init__.py
  - utils.py
- - __init__.py
  - pipelines.py
- - __init__.py
  - augmented_batch.py
  - crop.py
  - ct_batch.py
  - ct_masked_batch.py
  - dump.py
  - flip.py
  - histo.py
  - mask.py
  - mip.py
  - patches.py
  - resize.py
  - rotate.py
  - segment.py
- __init__.py
- batchflow
- - flow.png
  - flow_with_sn.png
- PyData.ipynb
- RadIO.I.ipynb
- RadIO.II.ipynb
- RadIO.III.ipynb
- RadIO.IV.ipynb
- utils.py
.gitattributes
.gitignore
.gitmodules
LICENSE
MANIFEST.in
pylintrc
README.md
requirements.txt
setup.py
shippable.yml

# Installation Guide

1. Get the code

git clone https://github.com/analysiscenter/radio

Downloads the entire project code from GitHub to your computer.

cd radio

Moves into the project folder you just downloaded.

2. Official Install Script

Easy Recommended

Prerequisites

Python 3 Python is required to use pip.

pip3 install git+https://github.com/analysiscenter/radio.git

Installs the package published on PyPI directly — no need to clone the source.

✅ After installing, open a new terminal and run the program's version command (e.g. --version) to confirm it worked.

Pulled directly from this repo's README.

3. Python

Easy

Prerequisites

Git Needed to download the project code from GitHub.
Python 3 On Windows, be sure to check 'Add Python to PATH' during installation.

pip3 install git+https://github.com/analysiscenter/radio.git

Installs the package published on PyPI directly — no need to clone the source.

✅ If it runs without errors and prints output in the terminal, it worked.

Pulled directly from this repo's README.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# RadIO

**RadIO** is a framework for data science research of computed tomography (CT) imaging.

Main features:
- Asynchronously load **DICOM** and **MetaImage** (mhd/raw) files
- Dump files to [blosc](http://blosc.org/) to compress datasets and thus accelerate loading
- Transform and augment CT-scans in parallel for faster preprocessing
- Create concise chainable workflows with `actions` or use tailored [pipelines](https://analysiscenter.github.io/radio/intro/pipelines.html) for preprocessing or model training
- Train with ease a zoo of state-of-the-art neural networks for classification or semantic segmentation
- Sample crops of any size from CT-scans for comprehensive training
- Customize distribution of crop [locations](https://analysiscenter.github.io/radio/intro/preprocessing.html?highlight=histogram#sample-crops-from-scan) for improved training
- Predict [on the whole scan](https://analysiscenter.github.io/radio/api/masked_batch.html#radio.preprocessing.ct_masked_batch.CTImagesMaskedBatch.predict_on_scan)

[The documentation](https://analysiscenter.github.io/radio) contains a comprehensive review of RadIO's capabilities. While [tutorials](https://github.com/analysiscenter/radio/tree/master/tutorials) provide ready-to-use code blocks and a practical demonstration of the most important RadIO features.

## Tutorials

There are four tutorials available:

- In the [first](https://github.com/analysiscenter/radio/tree/master/tutorials/RadIO.I.ipynb) one you can learn how to set up a dataset of CT-scans and define a basic preprocessing workflow.
- The [second tutorial](https://github.com/analysiscenter/radio/tree/master/tutorials/RadIO.II.ipynb) contains in-depth discussion of preprocessing and augmentation actions.
- The [third tutorial](https://github.com/analysiscenter/radio/tree/master/tutorials/RadIO.III.ipynb) explains how to generate batches to train a neural network.
- The [fourth tutorial](https://github.com/analysiscenter/radio/tree/master/tutorials/RadIO.IV.ipynb)
will help you configure and train a neural network to detect cancer.

## Preprocess scans with chained actions

Preprocessing-module contains a set of [actions](https://github.com/analysiscenter/batchflow) to efficiently prepare a dataset of CT-scans for neural networks training.

Say, you have a bunch of **DICOM** scans with varying shapes.
First, you create an index and define a dataset:
```python
from radio import CTImagesBatch
from radio.batchflow import FilesIndex, Dataset

dicom_ix = FilesIndex(path='path/to/dicom/*', dirs=True)            # set up the index
dicom_dataset = Dataset(index=dicom_ix, batch_class=CTImagesBatch) # init the dataset of dicom files
```

You may want to resize the scans to equal shape **[128, 256, 256]**,
normalize voxel densities to range **[0, 255]** and dump transformed
scans. This preprocessing can be easily performed with the following
pipeline:

```python
pipeline = (
    dicom_dataset.p
    .load(fmt='dicom')
    .resize(shape=(128, 256, 256))
    .normalize_hu()
    .dump('/path/to/preprocessed/scans/')
)
pipeline.run(batch_size=20)
```

See the [documentation](https://analysiscenter.github.io/radio/intro/preprocessing.html) for the description of
preprocessing actions implemented in the module.

## Preprocess scans using a pre-defined workflow

Pipelines module contains ready-to-use workflows for most frequent tasks.
For instance, if you want to preprocess a dataset of scans named ``dicom_dataset`` and
prepare data for training a neural network, you can simply execute the following
pipeline creator (without spending much time on thinking what actions to choose for
a workflow):

```python
from radio.pipelines import get_crops

nodata_pipeline = get_crops(fmt='raw', shape=(128, 256, 256),
                            nodules=nodules, batch_size=20,
                            share=0.6, nodule_shape=(32, 64, 64))

dicom_pipeline = dicom_dataset >> nodata_pipeline

for batch in dicom_pipeline.gen_batch(batch_size=12, shuffle=True):
    # ...
    # train a model here
```
See [pipelines section](https://analysiscenter.github.io/radio/intro/pipelines.html) for more information about
ready-to-use workflows.

## Adding a neural network to a workflow

`RadIO` contains proven architectures for classification, segmentation and detection, including neural networks designed specifically
for cancer detection (e.g. `DenseNoduleNet` inspired by the state-of-the-art DenseNet, but well suited for 3D CT scans):

```python
from radio.preprocessing import CTImagesMaskedBatch as CTIMB
from radio.models import DenseNoduleNet
from radio.batchflow import F

training_pipeline = (
    dicom_dataset.p
      .load(fmt='raw')
      .fetch_nodules_info(nodules_df)
      .create_mask()
      .sample_nodules(nodule_size=(32, 64, 64), batch_size=20)
      .init_model('static', DenseNoduleNet, 'net')
      .train_model('net', feed_dict={
          'images': F(CTIMB.unpack, component='images'),
          'labels': F(CTIMB.unpack, component='classification_targets')
      })
)

training_pipeline.run(batch_size=10, shuffle=True)
```
The [models documentation](https://analysiscenter.github.io/radio/intro/models.html) contains more information about implemented
architectures and their application to cancer detection.

## Installation

> `RadIO` module is in the beta stage. Your suggestions and improvements are very welcome.

> `RadIO` supports python 3.5 or higher.

### Installation as a python package

With [pipenv](https://docs.pipenv.org/):

pipenv install git+https://github.com/analysiscenter/radio.git#egg=radio

With [pip](https://pip.pypa.io/en/stable/):

pip3 install git+https://github.com/analysiscenter/radio.git

After that just import `radio`:
```python
import radio
```

### Installation as a project repository:

When cloning repo from GitHub use flag ``--recursive`` to make sure that ``BatchFlow`` submodule is also cloned.

git clone --recursive https://github.com/analysiscenter/radio.git

## Citing RadIO

Please cite RadIO in your publications if it helps your research.

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.1156363.svg)](https://doi.org/10.5281/zenodo.1156363)

Khudorozhkov R., Emelyanov K., Koryagin A., Kozhevin A. RadIO library for data science research of CT images. 2017.

```
@misc{radio_2017_1156363,
  author = {Khudorozhkov R., Emelyanov K., Koryagin A., Kozhevin A.},
  title  = {RadIO library for data science research of CT images},
  year   = 2017,
  doi    = {10.5281/zenodo.1156363},
  url    = {https://doi.org/10.5281/zenodo.1156363}
}
```