Upload 26 files

All files as in
https://github.com/lsprietog/dMRI-IVIM-ML-Toolkit

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/CFIN/__DTI_AX_ep2d_2_5_iso_33d_20141015095334_4.nii filter=lfs diff=lfs merge=lfs -text
+data/CFIN/T1.nii filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,59 +1,96 @@
----
-library_name: sklearn
-tags:
-- medical-imaging
-- mri
-- diffusion-mri
-- ivim
-- dki
-- physics
-license: mit
-language:
-- en
----
-
-# dMRI-IVIM-ML-Toolkit: Fast Diffusion MRI Analysis
-
-This is the official model repository for the paper:
-**"Exploring the Potential of Machine Learning Algorithms to Improve Diffusion Nuclear Magnetic Resonance Imaging Models Analysis"** (Journal of Medical Physics, 2024).
-
-## Model Description
-
-These are pre-trained Machine Learning models (Random Forest, Extra Trees) designed to estimate **IVIM** (Intravoxel Incoherent Motion) and **DKI** (Diffusion Kurtosis Imaging) parameters from diffusion-weighted MRI signals.
-
-- **Input:** Normalized MRI signal attenuation curve (multi-b-value).
-- **Output:** Diffusion ($D$), Pseudo-diffusion ($D^*$), Perfusion fraction ($f$), and Kurtosis ($K$).
-- **Speedup:** ~230x faster than standard non-linear least squares fitting.
-
-## How to Use
-
-You can load these models using `joblib` and `scikit-learn` in Python.
-
-```python
-import joblib
-import numpy as np
-
-# Load the pre-trained model
-model = joblib.load("ivim_dki_extratrees.joblib")
-
-# Example signal (normalized)
-# Shape: (n_samples, n_b_values)
-signal = np.array([[1.0, 0.8, 0.5, ...]]) 
-
-# Predict parameters [D, f, D*, K]
-params = model.predict(signal)
-
-```
-
-## Citation 
-```
-@article{PrietoGonzalez2024,
-  title={Exploring the Potential of Machine Learning Algorithms to Improve Diffusion Nuclear Magnetic Resonance Imaging Models Analysis},
-  author={Prieto-González, Leonar Steven and Agulles-Pedrós, Luis},
-  journal={Journal of Medical Physics},
-  volume={49},
-  issue={2},
-  pages={189--202},
-  year={2024}
-}
-```
+# dMRI-IVIM-ML-Toolkit: Machine Learning for Diffusion MRI Analysis
+
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/lsprietog/public_release/blob/main/demo_colab.ipynb)
+[![Run on Your Data](https://img.shields.io/badge/Colab-Run%20on%20Your%20Data-orange?logo=google-colab)](https://colab.research.google.com/github/lsprietog/public_release/blob/main/inference_colab.ipynb)
+
+This repository hosts the source code and implementation details for the paper:
+
+**"Exploring the Potential of Machine Learning Algorithms to Improve Diffusion Nuclear Magnetic Resonance Imaging Models Analysis"**  
+*Prieto-González LS, Agulles-Pedrós L.*  
+*Journal of Medical Physics, 2024.*
+
+[Read the full paper here](https://pmc.ncbi.nlm.nih.gov/articles/PMC11309135/)
+
+## Project Overview
+
+Diffusion MRI analysis, particularly Intravoxel Incoherent Motion (IVIM) and Diffusion Kurtosis Imaging (DKI), often relies on non-linear least squares fitting. While standard, this approach can be computationally expensive and sensitive to noise, especially for parameters like pseudo-diffusion ($D^*$) and perfusion fraction ($f$).
+
+This project introduces a **Python-based Machine Learning framework** (utilizing Random Forest, Extra Trees, and MLP) to estimate these parameters directly from the signal attenuation curve. It serves as a comprehensive toolkit for researchers looking to implement **IVIM Machine Learning** workflows in their **Python** pipelines.
+
+### Key Findings
+
+*   **Computational Efficiency:** The ML approach reduces processing time significantly—from approximately 75 minutes to under 20 seconds for 100,000 voxels (a ~230x speedup).
+*   **Noise Robustness:** The algorithms demonstrate improved stability in parameter estimation across varying SNR levels compared to conventional fitting.
+*   **Versatility:** Validated across different anatomical regions (Prostate, Brain, Head & Neck) and species.
+
+![Parameter Map Comparison](image_p10_6.png)
+
+*Figure: Visual comparison of parameter maps derived from standard fitting versus the proposed ML estimation.*
+
+## Installation
+
+To set up the environment, clone this repository and install the required dependencies:
+
+```bash
+git clone https://github.com/lsprietog/public_release.git
+cd public_release
+pip install -r requirements.txt
+```
+
+## Usage Example
+
+We provide a demonstration script `demo.py` that generates synthetic IVIM-DKI data to train and validate the model.
+
+To run the demo locally:
+```bash
+python demo.py
+```
+
+### Integration with NIfTI Data
+
+The `IVIMRegressor` class is designed to work with standard numpy arrays derived from NIfTI files.
+
+```python
+from src.ml_models import IVIMRegressor
+import nibabel as nib
+import numpy as np
+
+# Example workflow
+# 1. Prepare your data: Shape should be (n_voxels, n_b_values)
+# X_train, y_train = load_your_data(...)
+
+# 2. Initialize the regressor (e.g., Extra Trees)
+model = IVIMRegressor(model_type='extra_trees')
+
+# 3. Train the model
+model.train(X_train, y_train)
+
+# 4. Predict on new data
+# X_new shape: (n_voxels_in_volume, n_b_values)
+estimated_parameters = model.predict(X_new)
+```
+
+## Citation
+
+If you find this repository useful for your research, please consider citing our work:
+
+```bibtex
+@article{PrietoGonzalez2024,
+  title={Exploring the Potential of Machine Learning Algorithms to Improve Diffusion Nuclear Magnetic Resonance Imaging Models Analysis},
+  author={Prieto-González, Leonar Steven and Agulles-Pedrós, Luis},
+  journal={Journal of Medical Physics},
+  volume={49},
+  issue={2},
+  pages={189--202},
+  year={2024},
+  publisher={Wolters Kluwer - Medknow},
+  doi={10.4103/jmp.jmp_10_24},
+  url={https://pmc.ncbi.nlm.nih.gov/articles/PMC11309135/}
+}
+```
+
+## Contact
+
+For inquiries regarding the code or the paper, please open an issue in this repository.

data/CFIN/T1.nii

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

data/CFIN/__DTI_AX_ep2d_2_5_iso_33d_20141015095334_4.bval

@@ -0,0 +1 @@
+0	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	200	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	400	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	600	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	800	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1000	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1200	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1400	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1600	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	1800	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2000	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2200	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2400	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2600	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	2800	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000	3000

data/CFIN/__DTI_AX_ep2d_2_5_iso_33d_20141015095334_4.bvec

@@ -0,0 +1,3 @@
+0	0.869998	0.862033	0.886199	0.845792	-0.842594	-0.883964	-0.874659	-0.862782	0.274032	-0.228233	-0.406856	0.451853	-0.304319	0.258413	0.386145	-0.438481	0.402851	-0.460287	0.225337	-0.283958	0.445394	-0.386941	0.308325	-0.249216	0.999031	-0.00301848	0.0426293	0.0281464	0.686742	0.733299	-0.0329733	0.722998	0.682772	0.868609	0.862082	0.886767	0.84412	-0.843462	-0.88419	-0.873846	-0.860751	0.277475	-0.227707	-0.406385	0.452442	-0.302973	0.256404	0.387865	-0.436367	0.4031	-0.459668	0.226396	-0.284435	0.445449	-0.387672	0.306581	-0.251255	0.999063	-0.0032341	0.0426443	0.0279856	0.685897	0.732337	-0.0328328	0.723756	0.684843	0.869043	0.862209	0.886762	0.84444	-0.843832	-0.884912	-0.873285	-0.860649	0.277058	-0.228109	-0.405898	0.453508	-0.30252	0.255814	0.388255	-0.436928	0.402642	-0.458564	0.227076	-0.283684	0.444405	-0.387382	0.306567	-0.250513	0.999026	-0.00323519	0.0426492	0.0278783	0.685009	0.731455	-0.0328325	0.723945	0.68484	0.86879	0.861894	0.886678	0.844687	-0.843767	-0.884847	-0.873076	-0.86003	0.276576	-0.228562	-0.40632	0.453606	-0.304136	0.256152	0.388526	-0.436484	0.402144	-0.45892	0.226444	-0.283991	0.444432	-0.387457	0.306338	-0.250892	0.999005	-0.00328869	0.042654	0.027865	0.685053	0.731432	-0.0328324	0.724515	0.684903	0.868812	0.862226	0.886728	0.844533	-0.843926	-0.884783	-0.873031	-0.860055	0.276504	-0.228222	-0.406552	0.453468	-0.303632	0.255631	0.388021	-0.436647	0.402408	-0.458632	0.226643	-0.283631	0.443994	-0.386756	0.306568	-0.250521	0.999054	-0.0033213	0.0426587	0.0278245	0.685033	0.731083	-0.0328044	0.724472	0.685303	0.868521	0.862181	0.886677	0.844604	-0.84405	-0.88501	-0.872778	-0.85997	0.276513	-0.228176	-0.406744	0.453394	-0.303433	0.256291	0.388374	-0.436755	0.402442	-0.45873	0.226468	-0.283897	0.444081	-0.386501	0.30609	-0.24997	0.999062	-0.00334263	0.0426587	0.0278246	0.684753	0.730831	-0.0328089	0.724731	0.685528	0.868707	0.862171	0.886571	0.844403	-0.844073	-0.885146	-0.872722	-0.859958	0.276315	-0.228166	-0.406732	0.45345	-0.303749	0.256318	0.388261	-0.436695	0.401949	-0.458533	0.226786	-0.283298	0.444255	-0.386544	0.306465	-0.249712	0.999044	-0.00335817	0.0426601	0.0278014	0.684814	0.73091	-0.0327923	0.724946	0.685465	0.868597	0.862248	0.886553	0.844487	-0.84428	-0.885194	-0.872614	-0.859621	0.276457	-0.22826	-0.406723	0.453595	-0.303481	0.256193	0.388197	-0.436908	0.402117	-0.458278	0.226867	-0.283383	0.443796	-0.386713	0.306364	-0.250044	0.999069	-0.00336957	0.0426622	0.0278043	0.684603	0.730743	-0.0327799	0.724866	0.685645	0.868652	0.86216	0.886705	0.84441	-0.844323	-0.885217	-0.872679	-0.859842	0.276503	-0.228135	-0.406716	0.453708	-0.303565	0.25602	0.388731	-0.43676	0.402081	-0.458467	0.226501	-0.28345	0.443876	-0.38694	0.306488	-0.249933	0.999054	-0.00337865	0.0426629	0.0277886	0.684463	0.730625	-0.0327856	0.724995	0.685783	0.868589	0.862248	0.886637	0.844405	-0.844348	-0.885146	-0.872668	-0.859694	0.276334	-0.228007	-0.406711	0.453716	-0.303471	0.256066	0.388704	-0.43689	0.402135	-0.458302	0.226594	-0.283325	0.443845	-0.386819	0.306587	-0.250033	0.999058	-0.00338572	0.0426643	0.0277922	0.684534	0.73052	-0.0327763	0.724926	0.6857	0.868683	0.862221	0.886527	0.84446	-0.844276	-0.885238	-0.872461	-0.859611	0.276224	-0.228344	-0.406631	0.453901	-0.303729	0.255921	0.388762	-0.43677	0.402104	-0.458303	0.226503	-0.283413	0.443787	-0.386772	0.306411	-0.249944	0.999075	-0.00340143	0.0426647	0.0277804	0.684593	0.730591	-0.0327687	0.725044	0.685799	0.868548	0.862282	0.886584	0.84438	-0.844369	-0.885224	-0.872577	-0.859778	0.276681	-0.22822	-0.406633	0.453892	-0.303846	0.256071	0.38873	-0.436814	0.401983	-0.4583	0.226581	-0.283416	0.443913	-0.386789	0.306422	-0.250041	0.999063	-0.00340543	0.0426642	0.0277705	0.684326	0.730513	-0.0327739	0.725126	0.685891	0.86859	0.862296	0.886597	0.844487	-0.844392	-0.885316	-0.872494	-0.859669	0.276537	-0.22837	-0.406564	0.454014	-0.303846	0.256026	0.388777	-0.436909	0.402032	-0.45837	0.226602	-0.283459	0.443826	-0.386641	0.306474	-0.249964	0.999065	-0.00340894	0.0426652	0.0277747	0.684384	0.730441	-0.0327677	0.725062	0.685829	0.868554	0.862282	0.88664	0.844308	-0.844404	-0.885239	-0.872478	-0.859644	0.276561	-0.228336	-0.406571	0.453935	-0.303745	0.255915	0.388875	-0.436814	0.402015	-0.458372	0.22668	-0.283369	0.443732	-0.386602	0.306474	-0.250123	0.999067	-0.00341194	0.0426654	0.0277667	0.68431	0.730386	-0.0327624	0.725131	0.685906	0.868567	0.862255	0.886626	0.844405	-0.844472	-0.885317	-0.872507	-0.859559	0.276548	-0.228255	-0.406522	0.454039	-0.303791	0.256272	0.388788	-0.43692	0.402047	-0.458131	0.226541	-0.283431	0.443656	-0.38657	0.30642	-0.249979	0.999069	-0.00341445	0.0426662	0.0277597	0.684245	0.730332	-0.032767	0.725205	0.685971
+0	0.341143	-0.399649	0.324281	-0.380884	0.503055	-0.445372	0.21603	-0.157769	0.768125	0.942991	0.81819	0.889336	-0.925614	-0.782487	-0.917988	-0.789843	0.0867398	-0.426497	-0.602671	0.265468	-0.113151	0.454092	0.582292	-0.245856	-0.041406	0.566266	0.837505	0.983158	-0.171119	0.123454	-0.204304	0.675742	-0.722869	0.340777	-0.39728	0.321034	-0.379686	0.50076	-0.443126	0.214949	-0.157922	0.7637	0.942725	0.816926	0.888715	-0.92493	-0.781602	-0.916851	-0.788332	0.0847424	-0.423712	-0.598072	0.262329	-0.114041	0.450737	0.5802	-0.243463	-0.0394278	0.562101	0.835455	0.982252	-0.167679	0.120106	-0.199286	0.674226	-0.719927	0.33893	-0.396422	0.319276	-0.378614	0.49929	-0.441362	0.213629	-0.154977	0.762988	0.941989	0.815686	0.888047	-0.924697	-0.780322	-0.916546	-0.786533	0.0838246	-0.421525	-0.597007	0.260313	-0.112892	0.44923	0.579487	-0.2418	-0.039094	0.56208	0.834769	0.981637	-0.16664	0.119142	-0.199277	0.673268	-0.71993	0.337944	-0.396053	0.318957	-0.37694	0.499022	-0.441212	0.212986	-0.155296	0.762239	0.941791	0.814583	0.887901	-0.924051	-0.779552	-0.916279	-0.78681	0.0834505	-0.420498	-0.596564	0.260039	-0.111318	0.448965	0.578358	-0.241654	-0.0389205	0.561045	0.834081	0.98156	-0.165178	0.118547	-0.199273	0.672676	-0.719599	0.337499	-0.395514	0.318297	-0.377104	0.498483	-0.440875	0.212708	-0.154312	0.762102	0.941594	0.814454	0.887926	-0.924086	-0.779456	-0.916426	-0.786294	0.0830519	-0.420443	-0.595948	0.259291	-0.111793	0.448633	0.577796	-0.24102	-0.037643	0.560412	0.833398	0.981325	-0.165695	0.118276	-0.198275	0.672414	-0.719065	0.33757	-0.395095	0.318249	-0.376051	0.498026	-0.44029	0.211806	-0.154083	0.761373	0.941529	0.814115	0.887951	-0.923914	-0.779075	-0.916174	-0.78595	0.0822424	-0.419482	-0.595419	0.258967	-0.110929	0.448148	0.577525	-0.240921	-0.0369534	0.559999	0.833397	0.981325	-0.164929	0.117513	-0.198436	0.671936	-0.718934	0.336743	-0.394665	0.317822	-0.375912	0.498173	-0.440037	0.212144	-0.153924	0.761175	0.941383	0.813888	0.887873	-0.923676	-0.778734	-0.916179	-0.785625	0.0820889	-0.419759	-0.595118	0.258682	-0.1106	0.447871	0.577207	-0.240997	-0.0371612	0.559698	0.833199	0.98119	-0.164339	0.11741	-0.197847	0.671787	-0.718885	0.336792	-0.394239	0.317846	-0.375984	0.497725	-0.439748	0.211769	-0.153707	0.761182	0.941272	0.813818	0.887785	-0.923744	-0.778678	-0.916191	-0.785618	0.082389	-0.419284	-0.594914	0.258521	-0.110603	0.447275	0.576927	-0.240553	-0.0365826	0.559477	0.832878	0.981207	-0.164802	0.116945	-0.197404	0.671731	-0.71864	0.336433	-0.394508	0.317453	-0.375548	0.497505	-0.439587	0.211612	-0.15336	0.760918	0.941266	0.813674	0.887716	-0.923574	-0.778575	-0.915921	-0.785549	0.0821574	-0.419077	-0.594796	0.258397	-0.11016	0.44699	0.576773	-0.240324	-0.0367873	0.559301	0.832781	0.981115	-0.16439	0.116974	-0.197608	0.671488	-0.71845	0.336288	-0.394222	0.317296	-0.375374	0.497385	-0.439656	0.211115	-0.15317	0.760717	0.941219	0.813559	0.887685	-0.923561	-0.778387	-0.91594	-0.785284	0.0817623	-0.418765	-0.594665	0.258187	-0.11001	0.447259	0.576651	-0.240238	-0.0364577	0.559163	0.832568	0.981137	-0.16403	0.116646	-0.197277	0.671472	-0.718533	0.336074	-0.39411	0.317483	-0.375261	0.497462	-0.439379	0.211312	-0.153218	0.760651	0.941152	0.813409	0.8876	-0.923463	-0.77823	-0.915897	-0.785258	0.0816302	-0.418717	-0.594493	0.257946	-0.110159	0.446805	0.576377	-0.24008	-0.0361007	0.558859	0.832517	0.981067	-0.163737	0.116343	-0.197007	0.671421	-0.718447	0.336228	-0.393797	0.317085	-0.37529	0.49723	-0.439408	0.211206	-0.152998	0.760577	0.941122	0.813335	0.887583	-0.923397	-0.778082	-0.915876	-0.785172	0.0816879	-0.418646	-0.594409	0.257806	-0.110032	0.446658	0.576519	-0.239872	-0.0362944	0.558781	0.83259	0.981009	-0.163829	0.116413	-0.197193	0.671264	-0.71832	0.336023	-0.393865	0.316983	-0.374938	0.497115	-0.439185	0.210905	-0.15288	0.760448	0.941051	0.813432	0.887543	-0.923372	-0.778181	-0.915844	-0.784997	0.0814204	-0.418342	-0.59427	0.257775	-0.109772	0.446557	0.57626	-0.239766	-0.0360789	0.558713	0.832439	0.981034	-0.163865	0.116205	-0.196972	0.671269	-0.718341	0.335884	-0.393739	0.3168	-0.375113	0.497057	-0.439271	0.210755	-0.152662	0.760331	0.94107	0.813367	0.887578	-0.923349	-0.778072	-0.915777	-0.784997	0.0813411	-0.418224	-0.594103	0.25767	-0.109738	0.446614	0.576114	-0.239735	-0.0358951	0.558654	0.83241	0.980987	-0.163666	0.116276	-0.196782	0.671145	-0.718239	0.335704	-0.393791	0.316881	-0.374819	0.496986	-0.439086	0.210604	-0.152582	0.760287	0.94108	0.81327	0.887508	-0.923299	-0.777868	-0.915805	-0.785035	0.0812193	-0.418443	-0.593922	0.257527	-0.109618	0.446401	0.576037	-0.239535	-0.0357358	0.558606	0.832291	0.980946	-0.163495	0.116104	-0.196946	0.671129	-0.718152
+0	-0.355986	0.311738	0.330897	-0.373582	0.192276	-0.142307	-0.43394	0.48033	-0.578697	0.242233	-0.406244	0.0700702	-0.225009	0.566514	-0.090495	0.428815	-0.911146	-0.778612	-0.765514	-0.921355	0.888156	0.802544	0.752244	0.936721	-0.0149107	-0.824217	0.544764	-0.180579	-0.706473	0.668605	-0.978352	-0.143692	0.106225	-0.359708	0.314616	0.332537	-0.37855	0.19445	-0.147809	-0.436108	0.48391	-0.582898	0.243761	-0.409246	0.0740399	-0.229592	0.568643	-0.0945752	0.433724	-0.911224	-0.780496	-0.768801	-0.922106	0.888015	0.804081	0.75457	0.936801	-0.0178329	-0.827062	0.547902	-0.185466	-0.708116	0.670266	-0.979391	-0.146962	0.112675	-0.360405	0.315348	0.334241	-0.37891	0.196617	-0.148764	-0.437877	0.485042	-0.584027	0.246217	-0.412193	0.07552	-0.231122	0.570663	-0.0959281	0.436418	-0.911511	-0.782327	-0.769428	-0.922909	0.888684	0.805064	0.755124	0.93743	-0.0204492	-0.827076	0.548946	-0.188711	-0.70922	0.6714	-0.979393	-0.150381	0.112669	-0.361936	0.316671	0.334767	-0.380025	0.197572	-0.149593	-0.438606	0.486037	-0.585234	0.246553	-0.413955	0.0766337	-0.231585	0.571563	-0.0973683	0.436363	-0.911765	-0.782671	-0.769958	-0.922892	0.888869	0.805176	0.756081	0.937367	-0.0217651	-0.827779	0.54999	-0.189113	-0.70952	0.671531	-0.979394	-0.15028	0.114388	-0.362298	0.31644	0.335263	-0.380207	0.198251	-0.150962	-0.438831	0.486305	-0.585446	0.247619	-0.41398	0.0771662	-0.232105	0.571928	-0.0979983	0.437128	-0.911685	-0.782869	-0.770376	-0.923213	0.889028	0.805698	0.756418	0.937629	-0.0217622	-0.828207	0.551025	-0.190335	-0.709419	0.671959	-0.979597	-0.151657	0.115346	-0.36293	0.317088	0.335442	-0.381089	0.198868	-0.151333	-0.439769	0.486528	-0.586388	0.247909	-0.41446	0.0773119	-0.233047	0.572152	-0.0989466	0.437639	-0.911744	-0.783327	-0.770836	-0.923222	0.889093	0.80609	0.756818	0.937802	-0.0225799	-0.828487	0.551026	-0.190333	-0.709868	0.672366	-0.979565	-0.152533	0.114831	-0.363252	0.317649	0.336127	-0.381672	0.198405	-0.151272	-0.439717	0.4866	-0.586739	0.24847	-0.414916	0.0778734	-0.233581	0.572603	-0.0993457	0.438282	-0.911975	-0.783294	-0.770975	-0.923486	0.889047	0.806223	0.756909	0.937851	-0.0230269	-0.82869	0.551325	-0.191032	-0.709945	0.672299	-0.979684	-0.152168	0.115507	-0.36347	0.317968	0.336153	-0.381415	0.198647	-0.151834	-0.440112	0.487264	-0.586662	0.248804	-0.415063	0.0780367	-0.233656	0.572735	-0.0994888	0.438081	-0.911874	-0.783698	-0.771109	-0.923505	0.889276	0.806473	0.757164	0.937877	-0.0228675	-0.828839	0.55181	-0.190943	-0.710042	0.672562	-0.979774	-0.152797	0.115966	-0.36367	0.317875	0.336122	-0.382015	0.199015	-0.152161	-0.440058	0.486983	-0.586984	0.248943	-0.415352	0.0781637	-0.234222	0.572953	-0.099883	0.438353	-0.911911	-0.783698	-0.771307	-0.923519	0.889291	0.806522	0.75723	0.937965	-0.0231811	-0.828958	0.551956	-0.191417	-0.710272	0.672684	-0.979733	-0.153254	0.116322	-0.363956	0.317989	0.336449	-0.382198	0.199211	-0.152374	-0.440319	0.487304	-0.587324	0.249239	-0.415582	0.078472	-0.234391	0.573188	-0.0998183	0.438698	-0.911923	-0.783961	-0.771381	-0.923616	0.889325	0.806431	0.757284	0.93796	-0.0235317	-0.829051	0.552277	-0.191308	-0.710287	0.672856	-0.9798	-0.153649	0.1163	-0.363929	0.318202	0.336564	-0.382185	0.199321	-0.152644	-0.440635	0.487435	-0.587462	0.249184	-0.415953	0.0783589	-0.234446	0.573466	-0.0999905	0.438864	-0.911948	-0.783987	-0.77154	-0.923656	0.889336	0.806705	0.757563	0.938025	-0.02337	-0.829256	0.552354	-0.191664	-0.710298	0.672831	-0.979854	-0.153313	0.116247	-0.364108	0.318425	0.336787	-0.382334	0.199509	-0.152639	-0.440456	0.48721	-0.587342	0.24941	-0.416095	0.0785998	-0.234556	0.573599	-0.100303	0.438975	-0.911996	-0.784026	-0.771582	-0.923695	0.889289	0.806778	0.757451	0.938052	-0.0235634	-0.829308	0.552244	-0.191961	-0.710533	0.672903	-0.979817	-0.153614	0.116492	-0.364197	0.318302	0.33685	-0.382444	0.199697	-0.152751	-0.440764	0.487439	-0.587576	0.249539	-0.415973	0.0783514	-0.234651	0.573485	-0.100411	0.439193	-0.911999	-0.784147	-0.771683	-0.92369	0.889364	0.806905	0.757627	0.938099	-0.0238036	-0.829354	0.552471	-0.191834	-0.710469	0.673017	-0.979861	-0.15389	0.116729	-0.364412	0.318496	0.336908	-0.382668	0.199789	-0.15295	-0.440868	0.487551	-0.587717	0.249498	-0.416094	0.0784196	-0.234874	0.573682	-0.100646	0.439288	-0.912013	-0.784209	-0.771789	-0.923747	0.889415	0.806893	0.757737	0.938065	-0.0240084	-0.829394	0.552516	-0.192077	-0.710587	0.673065	-0.9799	-0.154106	0.116904	-0.364547	0.318505	0.336869	-0.382741	0.199677	-0.153026	-0.440883	0.487727	-0.58778	0.249536	-0.416331	0.0786	-0.235009	0.573799	-0.10072	0.439114	-0.91201	-0.784233	-0.771969	-0.923768	0.889468	0.807025	0.757818	0.938154	-0.0241859	-0.829426	0.552695	-0.192287	-0.710688	0.673153	-0.979867	-0.15383	0.117056

data/CFIN/__DTI_AX_ep2d_2_5_iso_33d_20141015095334_4.nii

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

debug_pixel.py

@@ -0,0 +1,77 @@
+import os
+import sys
+import numpy as np
+import nibabel as nib
+import matplotlib.pyplot as plt
+from scipy.optimize import curve_fit
+
+# Add src to path
+sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
+from ivim_model import calculate_ivim_params, _fit_pixel
+
+def func_qua(x, a0, a1, a2):
+    return a2 * (x ** 2) + a1 * x + a0
+
+def main():
+    print("=== Debugging Single Pixel Fit ===")
+    
+    # Load data
+    data_dir = os.path.join(os.path.dirname(__file__), 'data', 'CFIN')
+    nii_file = [f for f in os.listdir(data_dir) if f.endswith('.nii') and 'DTI' in f][0]
+    bval_file = [f for f in os.listdir(data_dir) if f.endswith('.bval')][0]
+    
+    img = nib.load(os.path.join(data_dir, nii_file))
+    data = img.get_fdata()
+    bvals = np.loadtxt(os.path.join(data_dir, bval_file))
+    
+    # Preprocess (Average)
+    unique_b = np.unique(np.round(bvals, -1))
+    avg_data_list = []
+    for b_val in unique_b:
+        idxs = np.where(np.abs(bvals - b_val) < 10)[0]
+        if len(idxs) > 0:
+            avg_data_list.append(np.mean(data[:, :, :, idxs], axis=3))
+    avg_data = np.stack(avg_data_list, axis=3)
+    
+    # Pick a pixel in the brain
+    # Slice 9, x=50, y=50 (approx center)
+    slice_idx = 9
+    x, y = 48, 48
+    
+    signal = avg_data[x, y, slice_idx, :]
+    print(f"Pixel ({x}, {y}, {slice_idx})")
+    print(f"b-values: {unique_b}")
+    print(f"Signal: {signal}")
+    
+    # Run IVIM calculation
+    print("\n--- Running calculate_ivim_params (Quadratic) ---")
+    r2, D, f, D_star, K = calculate_ivim_params(unique_b, signal, model_type='quadratic', gof=0.9)
+    print(f"Result: D={D}, f={f}, D*={D_star}, K={K}, R2={r2}")
+    
+    # Manual check of the fit
+    vec_b = unique_b
+    vec_S = signal / np.max(signal)
+    vec_S_log = np.log(vec_S + 1e-10)
+    
+    # Fit high b
+    limit_dif = 180
+    idx = np.where(vec_b >= limit_dif)[0][0]
+    b_high = vec_b[idx:]
+    S_high = vec_S_log[idx:]
+    
+    print(f"\nHigh-b data (b >= {limit_dif}):")
+    print(f"b: {b_high}")
+    print(f"log(S): {S_high}")
+    
+    # Try fit
+    bounds = ([-np.inf, -np.inf, 0], [np.inf, 0, np.inf])
+    try:
+        popt, _ = curve_fit(func_qua, b_high, S_high, bounds=bounds)
+        print(f"Manual Curve Fit params: a0={popt[0]}, a1={popt[1]}, a2={popt[2]}")
+        print(f"Implied D = {-popt[1]}")
+        print(f"Implied K = {popt[2] / popt[1]**2 * 6 if popt[1]!=0 else 0}")
+    except Exception as e:
+        print(f"Fit failed: {e}")
+
+if __name__ == "__main__":
+    main()

demo.py

@@ -0,0 +1,99 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import sys
+import os
+
+# Add src to path
+sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
+
+from ivim_model import calculate_ivim_params
+
+def generate_synthetic_signal(b_values, D, f, D_star, K=0, noise_level=0.02):
+    """
+    Generates synthetic IVIM-Kurtosis signal.
+    S(b) = S0 * [ f * exp(-b*D*) + (1-f) * exp(-b*D + 1/6 * b^2 * D^2 * K) ]
+    """
+    S0 = 1000
+    b = np.array(b_values)
+    
+    # Diffusion part with Kurtosis
+    # Note: Taylor expansion for Kurtosis is usually valid for b*D < 1 or similar.
+    # Standard DKI model: exp(-b*D + 1/6 * b^2 * D^2 * K)
+    
+    term_diff = np.exp(-b * D + (1/6) * (b**2) * (D**2) * K)
+    term_perf = np.exp(-b * D_star)
+    
+    signal = S0 * (f * term_perf + (1 - f) * term_diff)
+    
+    # Add Rician noise (approximated as Gaussian for high SNR)
+    noise = np.random.normal(0, noise_level * S0, size=len(b))
+    signal_noisy = signal + noise
+    signal_noisy[signal_noisy < 0] = 0 # Magnitude signal
+    
+    return signal_noisy
+
+def main():
+    print("=== IVIM-DKI Estimation Demo ===")
+    
+    # 1. Define Ground Truth Parameters
+    D_true = 0.001   # mm^2/s
+    f_true = 0.15    # fraction
+    D_star_true = 0.01 # mm^2/s
+    K_true = 0.8     # dimensionless
+    
+    print(f"Ground Truth: D={D_true}, f={f_true}, D*={D_star_true}, K={K_true}")
+    
+    # 2. Define b-values (typical clinical protocol)
+    b_values = [0, 10, 20, 30, 50, 80, 100, 200, 400, 800, 1000, 1500, 2000]
+    print(f"b-values: {b_values}")
+    
+    # 3. Generate Synthetic Data
+    signal = generate_synthetic_signal(b_values, D_true, f_true, D_star_true, K_true)
+    
+    # 4. Fit Model
+    print("\nFitting model...")
+    # We use gof=0.999 to force the segmented fit (since synthetic data is very clean)
+    # We use model_type='quadratic' to enable Kurtosis estimation
+    r2, D_est, f_est, D_star_est, K_est = calculate_ivim_params(b_values, signal, gof=0.999, model_type='quadratic')
+    
+    # 5. Show Results
+    print("\n--- Results ---")
+    print(f"Estimated D:  {D_est:.6f} (Error: {abs(D_est - D_true)/D_true*100:.2f}%)")
+    print(f"Estimated f:  {f_est:.6f} (Error: {abs(f_est - f_true)/f_true*100:.2f}%)")
+    print(f"Estimated D*: {D_star_est:.6f} (Error: {abs(D_star_est - D_star_true)/D_star_true*100:.2f}%)")
+    print(f"Estimated K:  {K_est:.6f} (Error: {abs(K_est - K_true)/K_true*100:.2f}%)")
+    print(f"Goodness of fit (R2): {r2:.4f}")
+    
+    # 6. Plot
+    plt.figure(figsize=(10, 6))
+    plt.plot(b_values, signal, 'o', label='Noisy Data')
+    
+    # Reconstruct fitted curve
+    # Note: The fitting function returns parameters, we need to reconstruct the curve to plot
+    # Ideally we would have a 'predict' function in ivim_model.py
+    # For now, we manually reconstruct using the same logic as generation
+    
+    # Reconstruct using estimated parameters
+    # Note: The fitting logic uses segmented approach, so the reconstruction might be slightly different 
+    # if we strictly follow the fitting steps, but for visualization, the full model is best.
+    
+    b_smooth = np.linspace(0, max(b_values), 100)
+    term_diff_est = np.exp(-b_smooth * D_est + (1/6) * (b_smooth**2) * (D_est**2) * K_est)
+    term_perf_est = np.exp(-b_smooth * D_star_est)
+    S0_est = np.max(signal) # Approximation used in fitting
+    signal_est = S0_est * (f_est * term_perf_est + (1 - f_est) * term_diff_est)
+    
+    plt.plot(b_smooth, signal_est, '-', label='Fitted Curve')
+    plt.xlabel('b-value (s/mm^2)')
+    plt.ylabel('Signal Intensity')
+    plt.title('IVIM-DKI Fit Demo')
+    plt.legend()
+    plt.grid(True)
+    
+    # Save plot
+    output_plot = 'demo_fit.png'
+    plt.savefig(output_plot)
+    print(f"\nPlot saved to {output_plot}")
+
+if __name__ == "__main__":
+    main()

demo_cfin.py

@@ -0,0 +1,169 @@
+import os
+import sys
+import numpy as np
+import nibabel as nib
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+
+# Add src to path
+sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
+
+from ivim_model import calculate_ivim_params, process_slice_parallel
+from utils import filtro_2D
+
+def load_cfin_data(data_dir):
+    """
+    Loads CFIN dataset files.
+    """
+    # Find files
+    nii_file = None
+    bval_file = None
+    
+    for f in os.listdir(data_dir):
+        if f.endswith('.nii') and 'DTI' in f:
+            nii_file = os.path.join(data_dir, f)
+        elif f.endswith('.bval'):
+            bval_file = os.path.join(data_dir, f)
+            
+    if not nii_file or not bval_file:
+        raise FileNotFoundError("Could not find required .nii or .bval files in data directory.")
+        
+    print(f"Loading NIfTI: {os.path.basename(nii_file)}")
+    img = nib.load(nii_file)
+    data = img.get_fdata()
+    
+    print(f"Loading b-values: {os.path.basename(bval_file)}")
+    bvals = np.loadtxt(bval_file)
+    
+    return data, bvals
+
+def preprocess_dwi_data(data, bvals):
+    """
+    Averages signals for unique b-values (Trace-weighted image).
+    This is necessary for DTI/DKI datasets with multiple directions per shell.
+    """
+    unique_b, inverse_indices = np.unique(np.round(bvals, -1), return_inverse=True) # Round to nearest 10 to group
+    
+    # Sort unique b-values
+    sorted_indices = np.argsort(unique_b)
+    unique_b = unique_b[sorted_indices]
+    
+    # Initialize averaged data
+    rows, cols, slices, _ = data.shape
+    avg_data = np.zeros((rows, cols, slices, len(unique_b)))
+    
+    print(f"Averaging {len(bvals)} volumes into {len(unique_b)} unique b-values: {unique_b}")
+    
+    for i, b_idx in enumerate(sorted_indices):
+        # Find all original indices corresponding to this unique b-value
+        # Note: inverse_indices maps original -> unique. 
+        # We need to find where inverse_indices == b_idx (before sorting)
+        # Actually, let's do it simpler.
+        pass
+
+    # Re-implementing loop for clarity
+    avg_data_list = []
+    for b_val in unique_b:
+        # Find indices in original bvals that are close to this b_val
+        # Using a tolerance of 10 s/mm2
+        idxs = np.where(np.abs(bvals - b_val) < 10)[0]
+        
+        if len(idxs) > 0:
+            # Average across the 4th dimension (volumes)
+            vol_avg = np.mean(data[:, :, :, idxs], axis=3)
+            avg_data_list.append(vol_avg)
+        else:
+            print(f"Warning: No volumes found for b={b_val}")
+            
+    # Stack along the 4th dimension
+    avg_data = np.stack(avg_data_list, axis=3)
+    
+    return avg_data, unique_b
+
+def main():
+    print("=== CFIN Dataset IVIM Demo ===")
+    
+    data_dir = os.path.join(os.path.dirname(__file__), 'data', 'CFIN')
+    
+    try:
+        data, bvals = load_cfin_data(data_dir)
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
+        print("Please run 'python download_data.py' first.")
+        return
+
+    print(f"Original Data shape: {data.shape}")
+    print(f"Original Number of b-values: {len(bvals)}")
+    
+    # Preprocess: Average shells
+    data, bvals = preprocess_dwi_data(data, bvals)
+    print(f"Processed Data shape: {data.shape}")
+    
+    # Select a middle slice for demonstration
+    slice_idx = data.shape[2] // 2
+    print(f"Processing slice {slice_idx}...")
+    
+    slice_data = data[:, :, slice_idx, :]
+    rows, cols, _ = slice_data.shape
+    
+    # Initialize parameter maps
+    map_D = np.zeros((rows, cols))
+    map_f = np.zeros((rows, cols))
+    map_D_star = np.zeros((rows, cols))
+    map_K = np.zeros((rows, cols))
+    map_R2 = np.zeros((rows, cols))
+    
+    # Simple mask to avoid background (threshold on b0)
+    b0_idx = np.argmin(bvals)
+    b0_img = slice_data[:, :, b0_idx]
+    mask = b0_img > np.mean(b0_img) * 0.2 # Simple threshold
+    
+    # DEMO OPTIMIZATION:
+    # We now use parallel processing and optimized outlier search.
+    # We can process the full slice much faster.
+    
+    print(f"\nProcessing full slice with parallel execution.")
+    
+    # Use parallel processing on the full mask
+    map_R2, map_D, map_f, map_D_star, map_K = process_slice_parallel(
+        bvals, slice_data, mask=mask, gof=0.90, model_type='quadratic', n_jobs=-1
+    )
+
+    # Apply filter to smooth results (optional, as in the paper)
+    # Note: The provided filtro_2D in utils.py appears to be a binary mask filter, 
+    # not a smoothing filter for continuous values. We skip it for parameter maps.
+    # print("Applying spatial filter...")
+    # map_D = filtro_2D(1, cols, rows, map_D)
+    
+    # Print statistics
+    print("\n--- Parameter Statistics ---")
+    print(f"D  : Mean={np.mean(map_D):.6f}, Max={np.max(map_D):.6f}, Min={np.min(map_D):.6f}")
+    print(f"f  : Mean={np.mean(map_f):.6f}, Max={np.max(map_f):.6f}, Min={np.min(map_f):.6f}")
+    print(f"D* : Mean={np.mean(map_D_star):.6f}, Max={np.max(map_D_star):.6f}, Min={np.min(map_D_star):.6f}")
+    print(f"K  : Mean={np.mean(map_K):.6f}, Max={np.max(map_K):.6f}, Min={np.min(map_K):.6f}")
+    
+    # Plot results
+    print("Plotting results...")
+    fig, axes = plt.subplots(1, 5, figsize=(20, 4))
+    
+    # Helper to rotate for better visualization (anatomical orientation)
+    def show_map(ax, data, title, vmin, vmax, cmap):
+        # Rotate 90 degrees to match anatomical view usually
+        im = ax.imshow(np.rot90(data), cmap=cmap, vmin=vmin, vmax=vmax)
+        ax.set_title(title)
+        plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
+        ax.axis('off')
+
+    # Adjust vmin/vmax based on typical physiological values
+    show_map(axes[0], map_R2, "Goodness of Fit (R2)", 0.5, 1.0, 'gray')
+    show_map(axes[1], map_D, "Diffusion (D)", 0, 0.003, 'viridis')
+    show_map(axes[2], map_f, "Perfusion Fraction (f)", 0, 0.3, 'viridis') # f is usually 0-0.3
+    show_map(axes[3], map_D_star, "Pseudo-Diffusion (D*)", 0, 0.1, 'viridis') # D* is usually high
+    show_map(axes[4], map_K, "Kurtosis (K)", 0, 2.0, 'viridis')
+
+    plt.tight_layout()
+    plt.savefig('cfin_demo_results.png')
+    print("Results saved to cfin_demo_results.png")
+
+if __name__ == "__main__":
+    main()

demo_colab.ipynb

@@ -0,0 +1,160 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/lsprietog/public_release/blob/main/demo_colab.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "\n",
+    "# \ud83c\udf93 IVIM-DKI Machine Learning Demo\n",
+    "\n",
+    "This notebook demonstrates how to train and evaluate Machine Learning models for Diffusion MRI analysis, as described in the paper **\"Exploring the Potential of Machine Learning Algorithms to Improve Diffusion Nuclear Magnetic Resonance Imaging Models Analysis\"**.\n",
+    "\n",
+    "**What you will learn:**\n",
+    "1. How to generate synthetic IVIM-DKI signal data.\n",
+    "2. How to train Random Forest and Extra Trees models.\n",
+    "3. How to compare ML performance against standard Least Squares fitting.\n",
+    "\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 1. Setup & Install\n",
+    "!git clone https://github.com/lsprietog/public_release.git\n",
+    "%cd public_release\n",
+    "!pip install -r requirements.txt\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor\n",
+    "from sklearn.metrics import mean_squared_error, r2_score\n",
+    "from scipy.optimize import curve_fit\n",
+    "import joblib\n",
+    "\n",
+    "# Define the IVIM-DKI model function\n",
+    "def ivim_dki_model(b, D, f, Dstar, K):\n",
+    "    return f * np.exp(-b * Dstar) + (1 - f) * np.exp(-b * D + (1/6) * (b**2) * (D**2) * K)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 2. Generate Synthetic Data\n",
+    "# Simulation parameters\n",
+    "n_samples = 5000\n",
+    "b_values = np.array([0, 10, 20, 30, 50, 80, 100, 150, 200, 400, 600, 800, 1000, 1500, 2000])\n",
+    "snr = 30\n",
+    "\n",
+    "# Random ground truth parameters\n",
+    "np.random.seed(42)\n",
+    "D_true = np.random.uniform(0.0005, 0.003, n_samples)\n",
+    "f_true = np.random.uniform(0.1, 0.4, n_samples)\n",
+    "Dstar_true = np.random.uniform(0.005, 0.1, n_samples)\n",
+    "K_true = np.random.uniform(0, 2.0, n_samples)\n",
+    "\n",
+    "Y_true = np.stack([D_true, f_true, Dstar_true, K_true], axis=1)\n",
+    "\n",
+    "# Generate signals\n",
+    "signals = []\n",
+    "for i in range(n_samples):\n",
+    "    sig = ivim_dki_model(b_values, D_true[i], f_true[i], Dstar_true[i], K_true[i])\n",
+    "    # Add Rician noise\n",
+    "    noise_r = np.random.normal(0, 1/snr, len(b_values))\n",
+    "    noise_i = np.random.normal(0, 1/snr, len(b_values))\n",
+    "    noisy_sig = np.sqrt((sig + noise_r)**2 + noise_i**2)\n",
+    "    signals.append(noisy_sig)\n",
+    "\n",
+    "X = np.array(signals)\n",
+    "print(f\"Generated {n_samples} synthetic signals with SNR={snr}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 3. Train Machine Learning Model\n",
+    "print(\"Training Extra Trees Regressor...\")\n",
+    "# Using optimized hyperparameters for speed/size balance\n",
+    "model = ExtraTreesRegressor(\n",
+    "    n_estimators=50,\n",
+    "    max_depth=15,\n",
+    "    min_samples_split=5,\n",
+    "    n_jobs=-1,\n",
+    "    random_state=42\n",
+    ")\n",
+    "\n",
+    "model.fit(X, Y_true)\n",
+    "print(\"Training complete!\")\n",
+    "\n",
+    "# Evaluate\n",
+    "Y_pred = model.predict(X)\n",
+    "r2 = r2_score(Y_true, Y_pred)\n",
+    "print(f\"Model R2 Score: {r2:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 4. Visualize Results\n",
+    "param_names = ['D', 'f', 'D*', 'K']\n",
+    "fig, axes = plt.subplots(1, 4, figsize=(20, 5))\n",
+    "\n",
+    "for i in range(4):\n",
+    "    axes[i].scatter(Y_true[:, i], Y_pred[:, i], alpha=0.1, s=5)\n",
+    "    axes[i].plot([Y_true[:, i].min(), Y_true[:, i].max()], \n",
+    "                 [Y_true[:, i].min(), Y_true[:, i].max()], 'r--')\n",
+    "    axes[i].set_xlabel('Ground Truth')\n",
+    "    axes[i].set_ylabel('Prediction')\n",
+    "    axes[i].set_title(f'{param_names[i]} (R2={r2_score(Y_true[:, i], Y_pred[:, i]):.2f})')\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 5. Save Model\n",
+    "joblib.dump(model, 'my_trained_model.joblib')\n",
+    "print(\"Model saved as 'my_trained_model.joblib'\")\n",
+    "files.download('my_trained_model.joblib')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

demo_dipy.py

@@ -0,0 +1,100 @@
+import os
+import sys
+import numpy as np
+import matplotlib.pyplot as plt
+from dipy.data import fetch_ivim
+from dipy.core.gradients import gradient_table
+import nibabel as nib
+from tempfile import TemporaryDirectory
+
+# Add src to path
+sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
+
+from ivim_model import process_slice_parallel
+from utils import filtro_2D
+
+def main():
+    print("=== DIPY IVIM Dataset Demo ===")
+    
+    # Fetch IVIM data
+    print("Fetching IVIM data from DIPY...")
+    # This downloads the data to the user's home directory by default (.dipy/ivim)
+    files, folder = fetch_ivim()
+    
+    # The fetch_ivim returns a dictionary or list of files depending on version, 
+    # but usually it downloads 'ivim_data.nii.gz' and 'ivim_bvals.txt'
+    # Let's find them in the folder
+    print(f"Data downloaded to: {folder}")
+    
+    nii_path = os.path.join(folder, 'ivim.nii.gz')
+    bval_path = os.path.join(folder, 'ivim.bval')
+    
+    if not os.path.exists(nii_path):
+        # Fallback for different dipy versions
+        nii_path = os.path.join(folder, 'ivim_data.nii.gz')
+        
+    print(f"Loading NIfTI: {nii_path}")
+    img = nib.load(nii_path)
+    data = img.get_fdata()
+    
+    print(f"Loading b-values: {bval_path}")
+    bvals = np.loadtxt(bval_path)
+    
+    print(f"Data shape: {data.shape}")
+    print(f"b-values: {bvals}")
+    
+    # Select slice 15 as requested
+    slice_idx = 15
+    if slice_idx >= data.shape[2]:
+        slice_idx = data.shape[2] // 2
+        
+    print(f"Processing slice {slice_idx}...")
+    
+    slice_data = data[:, :, slice_idx, :]
+    rows, cols, _ = slice_data.shape
+    
+    # Create a mask (simple thresholding on b0)
+    b0_idx = np.argmin(bvals)
+    b0_img = slice_data[:, :, b0_idx]
+    mask = b0_img > np.mean(b0_img) * 0.2
+    
+    print(f"Processing full slice with parallel execution.")
+    
+    # Use parallel processing
+    # Note: The original paper uses 'quadratic' (Kurtosis) model often, but for standard IVIM data 'linear' might be safer?
+    # Let's stick to 'quadratic' as it's the paper's main contribution.
+    map_R2, map_D, map_f, map_D_star, map_K = process_slice_parallel(
+        bvals, slice_data, mask=mask, gof=0.90, model_type='quadratic', n_jobs=-1
+    )
+
+    # Apply filter
+    # Note: filtro_2D is binary, skipping for parameter maps
+    # print("Applying spatial filter...")
+    # map_D = filtro_2D(1, cols, rows, map_D)
+    # map_f = filtro_2D(1, cols, rows, map_f)
+    # map_D_star = filtro_2D(1, cols, rows, map_D_star)
+    
+    # Plot results matching the style of Principal_IVIM.ipynb
+    print("Plotting results...")
+    fig, axes = plt.subplots(1, 5, figsize=(20, 4))
+    
+    def show_map(ax, data, title, vmin=None, vmax=None, cmap='gray'):
+        # Rotate to match typical orientation if needed
+        im = ax.imshow(np.rot90(data), cmap=cmap, vmin=vmin, vmax=vmax, interpolation='none')
+        ax.set_title(title)
+        plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
+        ax.axis('off')
+
+    # Ranges based on typical values or auto-scaled
+    show_map(axes[0], map_R2, "R2", 0.5, 1.0, 'gray')
+    show_map(axes[1], map_D, "D (Diffusion)", 0, 0.002, 'viridis') # Typical D in brain ~0.0007 - 0.001 mm2/s
+    show_map(axes[2], map_f, "f (Perfusion)", 0, 0.3, 'viridis')
+    show_map(axes[3], map_D_star, "D* (Pseudo-Diff)", 0, 0.05, 'viridis')
+    show_map(axes[4], map_K, "K (Kurtosis)", 0, 1.5, 'viridis')
+
+    plt.tight_layout()
+    plt.savefig('dipy_ivim_results.png')
+    print("Results saved to dipy_ivim_results.png")
+
+if __name__ == "__main__":
+    main()

inference_colab.ipynb

@@ -0,0 +1,206 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/lsprietog/public_release/blob/main/inference_colab.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
+    "\n",
+    "# \ud83e\udde0 Apply IVIM-DKI Machine Learning to Your Data\n",
+    "\n",
+    "This notebook allows you to use the pre-trained Machine Learning models from the paper **\"Exploring the Potential of Machine Learning Algorithms to Improve Diffusion Nuclear Magnetic Resonance Imaging Models Analysis\"** on your own NIfTI data.\n",
+    "\n",
+    "**What this tool does:**\n",
+    "1. Loads your Diffusion MRI data (NIfTI format).\n",
+    "2. Applies a pre-trained Extra Trees Regressor to estimate $D$, $f$, $D^*$, and $K$.\n",
+    "3. Generates and saves the parameter maps.\n",
+    "\n",
+    "**Note:** The pre-trained model included here was trained on a standard set of b-values: `[0, 10, 20, 30, 50, 80, 100, 150, 200, 400, 600, 800, 1000, 1500, 2000]`. For best results on your specific protocol, we recommend retraining the model using the `demo_colab.ipynb` notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 1. Setup & Install\n",
+    "!git clone https://github.com/lsprietog/public_release.git\n",
+    "%cd public_release\n",
+    "!pip install -r requirements.txt\n",
+    "\n",
+    "import numpy as np\n",
+    "import nibabel as nib\n",
+    "import joblib\n",
+    "import matplotlib.pyplot as plt\n",
+    "import os\n",
+    "from google.colab import files"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 2. Upload Your Data\n",
+    "print(\"Please upload your 4D DWI NIfTI file (.nii or .nii.gz)...\")\n",
+    "uploaded = files.upload()\n",
+    "if uploaded:\n",
+    "    dwi_filename = list(uploaded.keys())[0]\n",
+    "    print(f\"Uploaded: {dwi_filename}\")\n",
+    "else:\n",
+    "    print(\"No file uploaded.\")\n",
+    "\n",
+    "print(\"\\n(Optional) Upload a Mask file (binary mask). If none, press Cancel or skip.\")\n",
+    "try:\n",
+    "    uploaded_mask = files.upload()\n",
+    "    if uploaded_mask:\n",
+    "        mask_filename = list(uploaded_mask.keys())[0]\n",
+    "    else:\n",
+    "        mask_filename = None\n",
+    "except:\n",
+    "    mask_filename = None\n",
+    "    print(\"No mask provided. Processing entire volume (this might take longer).\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 3. Load Model & Data\n",
+    "# Load the pre-trained model\n",
+    "model_path = 'models/ivim_dki_extratrees.joblib'\n",
+    "if not os.path.exists(model_path):\n",
+    "    print(\"Downloading pre-trained model...\")\n",
+    "    # In a real scenario, you might fetch this from a release URL if it's not in the repo\n",
+    "    # But here we assume it's in the repo we cloned\n",
+    "    pass\n",
+    "\n",
+    "print(f\"Loading model from {model_path}...\")\n",
+    "model = joblib.load(model_path)\n",
+    "\n",
+    "# Load NIfTI\n",
+    "img = nib.load(dwi_filename)\n",
+    "data = img.get_fdata()\n",
+    "affine = img.affine\n",
+    "\n",
+    "if mask_filename:\n",
+    "    mask = nib.load(mask_filename).get_fdata() > 0\n",
+    "else:\n",
+    "    # Create a simple threshold mask to avoid background noise\n",
+    "    # Assuming b0 is the first volume\n",
+    "    mask = data[..., 0] > (np.mean(data[..., 0]) * 0.1)\n",
+    "\n",
+    "print(f\"Data shape: {data.shape}\")\n",
+    "print(f\"Mask voxels: {np.sum(mask)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 4. Run Prediction\n",
+    "print(\"Preprocessing data...\")\n",
+    "\n",
+    "# Reshape for prediction\n",
+    "n_x, n_y, n_z, n_b = data.shape\n",
+    "flat_data = data[mask]\n",
+    "\n",
+    "# Normalize signal (S/S0)\n",
+    "# Assuming the first volume is b=0\n",
+    "S0 = flat_data[:, 0][:, np.newaxis]\n",
+    "S0[S0 == 0] = 1 # Avoid division by zero\n",
+    "X_input = flat_data / S0\n",
+    "\n",
+    "# Check if b-values match (Basic check)\n",
+    "expected_b_len = 15 # Based on our training script\n",
+    "if n_b != expected_b_len:\n",
+    "    print(f\"WARNING: Your data has {n_b} volumes, but the model expects {expected_b_len}.\")\n",
+    "    print(\"We will try to interpolate or truncate, but results may be inaccurate.\")\n",
+    "    # Simple truncation or padding for demo purposes\n",
+    "    if n_b > expected_b_len:\n",
+    "        X_input = X_input[:, :expected_b_len]\n",
+    "    else:\n",
+    "        # Pad with zeros (Not ideal, but prevents crash)\n",
+    "        padding = np.zeros((X_input.shape[0], expected_b_len - n_b))\n",
+    "        X_input = np.hstack([X_input, padding])\n",
+    "\n",
+    "print(\"Predicting parameters (this is the fast part!)...\")\n",
+    "predictions = model.predict(X_input)\n",
+    "\n",
+    "# Reconstruct 3D maps\n",
+    "param_maps = np.zeros((n_x, n_y, n_z, 4)) # D, f, D*, K\n",
+    "param_maps[mask] = predictions\n",
+    "\n",
+    "print(\"Prediction complete!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 5. Visualize & Download\n",
+    "# Extract maps\n",
+    "D_map = param_maps[..., 0]\n",
+    "f_map = param_maps[..., 1]\n",
+    "Dstar_map = param_maps[..., 2]\n",
+    "K_map = param_maps[..., 3]\n",
+    "\n",
+    "# Plot middle slice\n",
+    "z_slice = n_z // 2\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 4, figsize=(20, 5))\n",
+    "axes[0].imshow(np.rot90(D_map[..., z_slice]), cmap='gray', vmin=0, vmax=0.003)\n",
+    "axes[0].set_title('Diffusion (D)')\n",
+    "axes[1].imshow(np.rot90(f_map[..., z_slice]), cmap='jet', vmin=0, vmax=0.5)\n",
+    "axes[1].set_title('Perfusion Fraction (f)')\n",
+    "axes[2].imshow(np.rot90(Dstar_map[..., z_slice]), cmap='hot', vmin=0, vmax=0.1)\n",
+    "axes[2].set_title('Pseudo-Diffusion (D*)')\n",
+    "axes[3].imshow(np.rot90(K_map[..., z_slice]), cmap='magma', vmin=0, vmax=2.0)\n",
+    "axes[3].set_title('Kurtosis (K)')\n",
+    "plt.show()\n",
+    "\n",
+    "# Save NIfTI files\n",
+    "print(\"Saving NIfTI files...\")\n",
+    "nib.save(nib.Nifti1Image(D_map, affine), 'map_D.nii.gz')\n",
+    "nib.save(nib.Nifti1Image(f_map, affine), 'map_f.nii.gz')\n",
+    "nib.save(nib.Nifti1Image(Dstar_map, affine), 'map_Dstar.nii.gz')\n",
+    "nib.save(nib.Nifti1Image(K_map, affine), 'map_K.nii.gz')\n",
+    "\n",
+    "print(\"Downloading maps...\")\n",
+    "files.download('map_D.nii.gz')\n",
+    "files.download('map_f.nii.gz')\n",
+    "files.download('map_Dstar.nii.gz')\n",
+    "files.download('map_K.nii.gz')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

ivim_dki_extratrees.joblib

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

models/b_values_config.npy

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

models/ivim_dki_extratrees.joblib

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

requirements.txt

@@ -0,0 +1,13 @@
+numpy
+scipy
+matplotlib
+pydicom
+nibabel
+tqdm
+ipywidgets
+pandas
+seaborn
+scikit-learn
+xgboost
+joblib
+joblib

setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="ivim-dwi",
+    version="1.0.0",
+    author="Leonar Steven Prieto-Gonzalez",
+    description="Robust IVIM and Kurtosis parameter estimation for DWI",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/ivim-robust",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: Scientific/Engineering :: Medical Science Apps.",
+    ],
+    python_requires='>=3.8',
+    install_requires=[
+        "numpy",
+        "scipy",
+        "matplotlib",
+        "pydicom",
+        "nibabel",
+        "tqdm",
+        "joblib",
+        "pandas",
+        "scikit-learn",
+        "xgboost"
+    ],
+)

src/ivim_model.py

@@ -0,0 +1,280 @@
+import numpy as np
+from scipy.optimize import curve_fit
+from joblib import Parallel, delayed
+import multiprocessing
+
+def func_lin(x, a0, a1):
+    """Linear function: a1*x + a0"""
+    return a1 * x + a0
+
+def func_qua(x, a0, a1, a2):
+    """Quadratic function: a2*x^2 + a1*x + a0"""
+    return a2 * (x ** 2) + a1 * x + a0
+
+def _fit_step(x_data, y_data, model_type):
+    """
+    Performs a single fitting step (linear or quadratic).
+    """
+    if model_type == 'linear':
+        # Constrain slope to be negative (decay)
+        bounds = (-np.inf, [np.inf, 0])
+        try:
+            popt, _ = curve_fit(func_lin, x_data, y_data, bounds=bounds)
+            residuals = np.sum((y_data - func_lin(x_data, *popt)) ** 2)
+            a2 = 0
+            a0, a1 = popt
+        except RuntimeError:
+            return 0, 0, 0, 0
+    else:
+        # Constrain quadratic term
+        bounds = ([-np.inf, -np.inf, 0], [np.inf, 0, np.inf])
+        try:
+            popt, _ = curve_fit(func_qua, x_data, y_data, bounds=bounds)
+            residuals = np.sum((y_data - func_qua(x_data, *popt)) ** 2)
+            a0, a1, a2 = popt
+        except RuntimeError:
+            return 0, 0, 0, 0
+    
+    y_mean = np.mean(y_data)
+    ss_tot = np.sum((y_data - y_mean) ** 2)
+    
+    r2 = 1 - residuals / ss_tot if ss_tot != 0 else 0
+    
+    return a0, a1, a2, r2
+
+def _fit_pixel(x, y, model_type='linear', gof_threshold=0.9):
+    """
+    Iterative fitting process. Removes outliers if R2 is below threshold.
+    """
+    a0, a1, a2, r2 = _fit_step(x, y, model_type)
+    
+    if r2 < gof_threshold:
+        best_r2 = 0
+        best_params = (a0, a1, a2)
+        best_data = (x, y)
+        
+        # Optimization: Only check points with high residuals if N is large
+        if len(x) > 20:
+            if model_type == 'linear':
+                y_pred = func_lin(x, a0, a1)
+            else:
+                y_pred = func_qua(x, a0, a1, a2)
+            
+            residuals = (y - y_pred)**2
+            # Check only the top 5 worst outliers for speed
+            n_check = min(len(x), 5)
+            indices_to_check = np.argsort(residuals)[-n_check:]
+        else:
+            indices_to_check = range(len(x))
+        
+        # Leave-one-out strategy on candidate points
+        for i in indices_to_check:
+            x_subset = np.delete(x, i)
+            y_subset = np.delete(y, i)
+            
+            curr_a0, curr_a1, curr_a2, curr_r2 = _fit_step(x_subset, y_subset, model_type)
+            
+            if curr_r2 > best_r2:
+                best_r2 = curr_r2
+                best_params = (curr_a0, curr_a1, curr_a2)
+                best_data = (x_subset, y_subset)
+        
+        return best_params, best_r2, best_data
+    
+    return (a0, a1, a2), r2, (x, y)
+
+def media(r1, r2, z=1):
+    """Calculates mean (geometric, harmonic, or arithmetic)."""
+    if r1 <= 0.01: r1 = 1E-3
+    if r2 <= 0.01: r2 = 1E-3
+    
+    if z == 1:    # Geometric
+        m = np.sqrt(r1 * r2)
+    elif z == 2:  # Harmonic
+        m = 2 / (1/r1 + 1/r2)
+    else:         # Arithmetic
+        m = (r1 + r2) / 2
+    return m
+
+def calculate_ivim_params(b_values, signal_values, gof=0.9, limit_dif=180, model_type='linear'):
+    """
+    Calculates IVIM and Kurtosis parameters (D, f, D*, K) for a single voxel using a segmented fitting approach.
+    
+    Args:
+        b_values: Array of b-values.
+        signal_values: Array of signal intensities corresponding to b-values.
+        gof: Goodness of fit threshold (R2) to trigger outlier removal.
+        limit_dif: b-value threshold separating perfusion (low b) and diffusion (high b) regimes.
+        model_type: 'linear' for Mono-exponential (IVIM), 'quadratic' for Kurtosis (IVIM-DKI).
+        
+    Returns:
+        r2_new: Combined R2 score.
+        D: Diffusion coefficient.
+        f: Perfusion fraction.
+        D_pse: Pseudo-diffusion coefficient (D*).
+        K: Kurtosis (0 if model_type is 'linear').
+    """
+    vec_b = np.array(b_values)
+    vec_S = np.array(signal_values)
+    
+    # Normalize signal
+    vec_S[np.isnan(vec_S)] = 0
+    S0 = np.max(vec_S)
+    if S0 == 0:
+        return 0, 0, 0, 0, 0
+        
+    vec_S = vec_S / S0
+    
+    # Avoid log(0) issues
+    vec_S[vec_S <= 0] = 1e-10
+    vec_S_log = np.log(vec_S)
+
+    # Split data into vascular (low b) and cellular (high b) regimes
+    try:
+        limite_dif_idx = np.where(vec_b >= limit_dif)[0][0]
+    except IndexError:
+        limite_dif_idx = len(vec_b)
+
+    vec_b_vas = vec_b[:limite_dif_idx + 1]
+    vec_b_cel = vec_b[limite_dif_idx:]
+    
+    vec_S_vas = vec_S[:limite_dif_idx + 1]
+    vec_S_cel = vec_S[limite_dif_idx:]
+    vec_S_cel_log = vec_S_log[limite_dif_idx:]
+
+    # 1. Fit Diffusion/Kurtosis (High b-values)
+    # Perform initial fit on the full dataset to check overall quality
+    a, r, data = _fit_pixel(vec_b, vec_S_log, model_type, gof_threshold=gof)
+    
+    if r < gof:
+        # If global fit is poor, proceed with Segmented Fitting
+        
+        # Step 1: Fit High-b values (Diffusion regime)
+        a, r, data = _fit_pixel(vec_b_cel, vec_S_cel_log, model_type, gof_threshold=gof) 
+        
+        # Calculate Diffusion (D) and Kurtosis (K) from high-b fit
+        D = -a[1]
+        if model_type == 'quadratic' and D != 0:
+            K = (a[2] / D**2) * 6
+        else:
+            K = 0
+            
+        # Calculate Perfusion Fraction (f) from intercept
+        # Intercept a[0] corresponds to ln(1-f)
+        uno_menos_f = np.exp(a[0])
+        f = 1 - uno_menos_f
+        
+        # Step 2: Extrapolate diffusion contribution to low-b values
+        # S_diff_extrapolated = exp(a2*b^2 + a1*b + a0)
+        if model_type == 'linear':
+             diffusion_contribution = np.exp(a[1]*vec_b_vas + a[0])
+        else:
+             diffusion_contribution = np.exp(a[2]*(vec_b_vas**2) + a[1]*vec_b_vas + a[0])
+             
+        # Step 3: Subtract Diffusion from Total Signal to isolate Perfusion
+        # S_perfusion = S_total - S_diffusion
+        y4 = vec_S_vas - diffusion_contribution
+
+        # Ensure residuals are positive for logarithmic fitting
+        if np.min(y4) < 0:
+             y4 = y4 + abs(np.min(y4))
+             
+        # Prepare for Perfusion fit (log of residuals)
+        y5 = np.zeros(len(y4))
+        valid_indices = []
+        for i in range(len(y4)):
+            if y4[i] > 0:
+                y5[i] = np.log(y4[i])
+                valid_indices.append(i)
+        
+        if len(valid_indices) > 2:
+            y5_clean = y5[valid_indices]
+            vec_b_vas_clean = vec_b_vas[valid_indices]
+            
+            # Step 4: Fit Perfusion (Pseudo-diffusion) using a linear model
+            A_param, R_param, _ = _fit_pixel(vec_b_vas_clean, y5_clean, 'linear', gof_threshold=gof)
+            
+            D_pse = -A_param[1]
+            r2_new = media(R_param, r, 1)
+        else:
+            # Fallback: Failed to isolate perfusion component (D*)
+            # But we keep D, f, K from the high-b fit
+            D_pse = 0
+            r2_new = r
+            
+    else:
+        # Good global fit: Assume Mono-exponential / Kurtosis model fits entire range
+        D = -a[1]
+        f = 0
+        if model_type == 'quadratic' and D != 0:
+            K = (a[2] / D**2) * 6
+        else:
+            K = 0
+        D_pse = 0
+        r2_new = r
+
+    return r2_new, D, f, D_pse, K
+
+def process_slice_parallel(b_values, slice_data, mask=None, gof=0.9, limit_dif=180, model_type='linear', n_jobs=-1):
+    """
+    Processes an entire 2D slice (Rows x Cols x b-values) in parallel to extract IVIM/DKI parameters.
+    
+    Args:
+        b_values: Array of b-values.
+        slice_data: 3D array (Rows, Cols, b-values) containing signal intensities.
+        mask: Binary mask (Rows, Cols) indicating pixels to process. If None, processes all.
+        gof: Goodness of fit threshold.
+        limit_dif: b-value threshold for segmentation.
+        model_type: 'linear' or 'quadratic'.
+        n_jobs: Number of parallel jobs. -1 uses all available CPUs.
+        
+    Returns:
+        Tuple of 2D maps: (R2, D, f, D*, K)
+    """
+    rows, cols, n_b = slice_data.shape
+    
+    if mask is None:
+        mask = np.ones((rows, cols), dtype=bool)
+        
+    # Prepare list of tasks for parallel execution
+    tasks = []
+    coords = []
+    
+    for i in range(rows):
+        for j in range(cols):
+            if mask[i, j]:
+                signal = slice_data[i, j, :]
+                tasks.append((b_values, signal, gof, limit_dif, model_type))
+                coords.append((i, j))
+                
+    if not tasks:
+        # Return empty maps if no pixels to process
+        return (np.zeros((rows, cols)) for _ in range(5))
+
+    # Determine number of jobs
+    if n_jobs == -1:
+        n_jobs = multiprocessing.cpu_count()
+        
+    print(f"Processing {len(tasks)} pixels using {n_jobs} threads...")
+    
+    # Execute parallel processing
+    # Note: 'threading' backend is preferred on Windows to avoid pickling overhead and issues with local functions
+    results = Parallel(n_jobs=n_jobs, backend="threading", verbose=1)(
+        delayed(calculate_ivim_params)(*t) for t in tasks
+    )
+    
+    # Reconstruct 2D parameter maps from flat results
+    map_R2 = np.zeros((rows, cols))
+    map_D = np.zeros((rows, cols))
+    map_f = np.zeros((rows, cols))
+    map_D_star = np.zeros((rows, cols))
+    map_K = np.zeros((rows, cols))
+    
+    for (i, j), (r2, D, f, D_star, K) in zip(coords, results):
+        map_R2[i, j] = r2
+        map_D[i, j] = D
+        map_f[i, j] = f
+        map_D_star[i, j] = D_star
+        map_K[i, j] = K
+        
+    return map_R2, map_D, map_f, map_D_star, map_K

src/ml_models.py

@@ -0,0 +1,132 @@
+import numpy as np
+import pandas as pd
+from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor
+from sklearn.neural_network import MLPRegressor
+from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet
+from sklearn.svm import SVR
+from sklearn.model_selection import train_test_split, cross_val_score
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+import joblib
+import os
+
+class IVIMRegressor:
+    """
+    Machine Learning wrapper for estimating IVIM/DKI parameters from diffusion MRI signals.
+    
+    This class provides a unified interface for training and applying various regression models
+    (Random Forest, Extra Trees, MLP, etc.) to map signal attenuation curves directly to 
+    tissue parameters (D, f, D*, K), bypassing iterative non-linear least squares fitting.
+    
+    Supported architectures:
+    - 'random_forest': Robust baseline, handles noise well.
+    - 'extra_trees': Often faster and slightly more accurate than RF. In our experiments, this model showed superior robustness to noise.
+    - 'mlp': Multi-layer Perceptron for capturing complex non-linear mappings.
+    - 'xgboost': Gradient boosting (requires xgboost package).
+    - 'svr': Support Vector Regression.
+    """
+    
+    def __init__(self, model_type='extra_trees', params=None):
+        self.model_type = model_type
+        self.params = params if params else {}
+        self.model = self._build_model()
+        
+    def _build_model(self):
+        if self.model_type == 'random_forest':
+            # Default params from paper/notebook
+            n_estimators = self.params.get('n_estimators', 100)
+            return RandomForestRegressor(n_estimators=n_estimators, random_state=42, n_jobs=-1)
+            
+        elif self.model_type == 'extra_trees':
+            n_estimators = self.params.get('n_estimators', 100)
+            return ExtraTreesRegressor(n_estimators=n_estimators, random_state=42, n_jobs=-1)
+            
+        elif self.model_type == 'mlp':
+            hidden_layer_sizes = self.params.get('hidden_layer_sizes', (100, 50))
+            return MLPRegressor(hidden_layer_sizes=hidden_layer_sizes, max_iter=500, random_state=42)
+            
+        elif self.model_type == 'xgboost':
+            try:
+                from xgboost import XGBRegressor
+                return XGBRegressor(n_estimators=1000, learning_rate=0.01, n_jobs=-1, random_state=42)
+            except ImportError:
+                print("XGBoost not installed. Falling back to Random Forest.")
+                return RandomForestRegressor(n_estimators=100, random_state=42)
+                
+        elif self.model_type == 'svr':
+            C = self.params.get('C', 100)
+            return SVR(C=C)
+            
+        else:
+            raise ValueError(f"Unknown model type: {self.model_type}")
+
+    def train(self, X, y, test_size=0.2, verbose=True):
+        """
+        Trains the regression model using the provided signal-parameter pairs.
+        
+        Args:
+            X: Input feature matrix (Normalized Signal vs b-values). Shape: [n_samples, n_b_values]
+            y: Target parameter vector (e.g., Diffusion Coefficient D). Shape: [n_samples]
+            test_size: Fraction of data to reserve for validation (default: 0.2).
+            verbose: If True, prints training progress and validation metrics.
+            
+        Returns:
+            Dictionary containing validation metrics (MAE, MSE, RMSE, R2).
+        """
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=42)
+        
+        if verbose:
+            print(f"Training {self.model_type} on {len(X_train)} samples...")
+            
+        self.model.fit(X_train, y_train)
+        
+        # Evaluate
+        predictions = self.model.predict(X_test)
+        metrics = self._evaluate(y_test, predictions)
+        
+        if verbose:
+            print("--- Validation Metrics ---")
+            for k, v in metrics.items():
+                print(f"{k}: {v:.6f}")
+                
+        return metrics
+
+    def predict(self, X):
+        """Predicts parameters for new data."""
+        return self.model.predict(X)
+    
+    def _evaluate(self, y_true, y_pred):
+        return {
+            'MAE': mean_absolute_error(y_true, y_pred),
+            'MSE': mean_squared_error(y_true, y_pred),
+            'RMSE': np.sqrt(mean_squared_error(y_true, y_pred)),
+            'R2': r2_score(y_true, y_pred)
+        }
+    
+    def save(self, filepath):
+        """Saves the trained model to disk."""
+        joblib.dump(self.model, filepath)
+        print(f"Model saved to {filepath}")
+        
+    def load(self, filepath):
+        """Loads a trained model from disk."""
+        if os.path.exists(filepath):
+            self.model = joblib.load(filepath)
+            print(f"Model loaded from {filepath}")
+        else:
+            raise FileNotFoundError(f"Model file not found: {filepath}")
+
+def load_training_data(data_dir, dataset_name='MR701'):
+    """
+    Helper to load X and Y CSV files from the data directory.
+    Expected format: Data_X2_{dataset}.csv and Data_Y_{dataset}.csv
+    """
+    x_path = os.path.join(data_dir, f'Data_X2_{dataset_name}.csv')
+    y_path = os.path.join(data_dir, f'Data_Y_{dataset_name}.csv')
+    
+    if not os.path.exists(x_path) or not os.path.exists(y_path):
+        raise FileNotFoundError(f"Data files not found for {dataset_name} in {data_dir}")
+        
+    X = np.loadtxt(x_path)
+    Y = np.loadtxt(y_path) # Assuming Y contains [D, f, D*, K] columns or similar
+    
+    return X, Y

src/utils.py

@@ -0,0 +1,48 @@
+import numpy as np
+
+def filtro_2D(veces, col, row, Matriz_R):
+    """
+    Applies a 2D filter to the R2 matrix to smooth it.
+    """
+    R_old = np.copy(Matriz_R)
+    R_new = np.copy(Matriz_R)
+    
+    for k in range(veces):
+        for i in range(1, col-1):
+            for j in range(1, row-1):
+                w_A = (R_old[i-1, j] + R_old[i, j-1] + R_old[i+1, j] + R_old[i, j+1]) / 4
+                w_B = (R_old[i-1, j-1] + R_old[i+1, j-1] + R_old[i-1, j+1] + R_old[i+1, j+1]) / (4 * np.sqrt(2))
+                
+                if (w_A + w_B) > 1:
+                    R_new[i, j] = 1
+                else:
+                    R_new[i, j] = 0
+        R_old = np.copy(R_new)
+    
+    return R_new
+
+def filtro_3D(veces, slices, col, row, Tensor_R):
+    """
+    Applies a 3D filter to the R2 tensor.
+    """
+    R_old = np.copy(Tensor_R)
+    R_new = np.copy(Tensor_R)
+    
+    for u in range(veces):
+        for k in range(1, slices-1):
+            for i in range(1, col-1):
+                for j in range(1, row-1):
+                    w_A = (R_old[i-1, j, k] + R_old[i, j-1, k] + R_old[i+1, j, k] + R_old[i, j+1, k] + R_old[i, j, k-1] + R_old[i, j, k+1]) / 6
+                    w_B1 = (R_old[i-1, j, k-1] + R_old[i+1, j, k-1] + R_old[i-1, j, k+1] + R_old[i+1, j, k+1]) / (12 * np.sqrt(2))
+                    w_B2 = (R_old[i-1, j-1, k] + R_old[i-1, j+1, k] + R_old[i+1, j-1, k] + R_old[i+1, j+1, k]) / (12 * np.sqrt(2))
+                    w_B3 = (R_old[i, j-1, k-1] + R_old[i, j+1, k-1] + R_old[i, j-1, k+1] + R_old[i, j+1, k+1]) / (12 * np.sqrt(2))
+                    w_C = (R_old[i-1, j-1, k+1] + R_old[i-1, j+1, k+1] + R_old[i+1, j-1, k+1] + R_old[i+1, j+1, k+1] + R_old[i-1, j-1, k-1] + R_old[i-1, j+1, k-1] + R_old[i+1, j-1 ,k-1] + R_old[i+1, j+1 ,k-1]) / (8 * np.sqrt(3))
+                    w_B = w_B1 + w_B2 + w_B3
+                    
+                    if (w_A + w_B + w_C) >= 1:
+                        R_new[i, j, k] = 1
+                    else:
+                        R_new[i, j, k] = 0
+        R_old = np.copy(R_new)
+        
+    return R_new

train_ml_demo.py

@@ -0,0 +1,96 @@
+import numpy as np
+import os
+import sys
+import matplotlib.pyplot as plt
+
+# Add src to path
+sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
+
+from ml_models import IVIMRegressor
+from ivim_model import calculate_ivim_params
+
+def generate_synthetic_training_data(n_samples=1000):
+    """
+    Generates synthetic data for training ML models.
+    """
+    print(f"Generating {n_samples} synthetic samples...")
+    
+    # b-values
+    b_values = np.array([0, 10, 20, 30, 50, 80, 100, 200, 400, 800, 1000])
+    
+    # Random parameters
+    # D: 0.0005 to 0.003
+    D = np.random.uniform(0.0005, 0.003, n_samples)
+    # f: 0.05 to 0.3
+    f = np.random.uniform(0.05, 0.3, n_samples)
+    # D*: 0.005 to 0.05
+    D_star = np.random.uniform(0.005, 0.05, n_samples)
+    # K: 0 to 1.5
+    K = np.random.uniform(0, 1.5, n_samples)
+    
+    X = []
+    for i in range(n_samples):
+        # Generate signal
+        term_diff = np.exp(-b_values * D[i] + (1/6) * (b_values**2) * (D[i]**2) * K[i])
+        term_perf = np.exp(-b_values * D_star[i])
+        S0 = 1000
+        signal = S0 * (f[i] * term_perf + (1 - f[i]) * term_diff)
+        
+        # Add noise
+        noise = np.random.normal(0, 0.02 * S0, size=len(b_values))
+        signal_noisy = signal + noise
+        signal_noisy[signal_noisy < 0] = 0
+        
+        # Normalize
+        signal_norm = signal_noisy / np.max(signal_noisy)
+        X.append(signal_norm)
+        
+    X = np.array(X)
+    # Targets: Let's predict D for this example
+    y = D 
+    
+    return X, y, b_values
+
+def main():
+    print("=== ML Model Training Demo ===")
+    
+    # 1. Get Data (Synthetic for demo, but structure allows loading real data)
+    # In a real scenario, you would use:
+    # X, Y = load_training_data('data/MR701')
+    # y = Y[:, 0] # D column
+    
+    X, y, b_values = generate_synthetic_training_data()
+    
+    # 2. Initialize Model
+    # We use Random Forest as it was one of the best performers in the paper
+    regressor = IVIMRegressor(model_type='random_forest', params={'n_estimators': 50})
+    
+    # 3. Train
+    print("\nTraining Random Forest to predict Diffusion Coefficient (D)...")
+    metrics = regressor.train(X, y)
+    
+    # 4. Save Model
+    if not os.path.exists('models'):
+        os.makedirs('models')
+    regressor.save('models/rf_diffusion_model.joblib')
+    
+    # 5. Compare with Analytical Fit on a few samples
+    print("\n--- Comparison: ML vs Analytical ---")
+    indices = np.random.choice(len(X), 5)
+    
+    for idx in indices:
+        signal = X[idx]
+        true_val = y[idx]
+        
+        # ML Prediction
+        ml_pred = regressor.predict([signal])[0]
+        
+        # Analytical Fit
+        # Note: calculate_ivim_params expects raw signal, but we normalized. 
+        # It handles normalization internally, so passing normalized is fine (S0=1).
+        _, d_ana, _, _, _ = calculate_ivim_params(b_values, signal, gof=0.9)
+        
+        print(f"True D: {true_val:.6f} | ML: {ml_pred:.6f} | Analytical: {d_ana:.6f}")
+
+if __name__ == "__main__":
+    main()

train_pretrained.py

@@ -0,0 +1,102 @@
+import numpy as np
+import joblib
+import os
+import sys
+from sklearn.ensemble import ExtraTreesRegressor
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error
+
+# Ensure output directory exists
+if not os.path.exists('models'):
+    os.makedirs('models')
+
+def generate_comprehensive_training_data(n_samples=100000):
+    """
+    Generates a large, comprehensive dataset covering a wide range of b-values
+    and physiological parameters to create a robust pre-trained model.
+    """
+    print(f"Generating {n_samples} synthetic samples for pre-training...")
+    
+    # Extended set of b-values to cover various clinical protocols (Prostate, Brain, etc.)
+    # We include a superset of common b-values. 
+    # NOTE: For the pre-trained model to be universal, it ideally needs to be trained 
+    # on the SPECIFIC b-values of the target protocol. 
+    # However, for a general purpose 'demo' model, we will use a standard clinical set.
+    # Users should ideally retrain for their specific protocol, but this serves as a strong baseline.
+    b_values = np.array([0, 10, 20, 30, 50, 80, 100, 150, 200, 400, 600, 800, 1000, 1500, 2000])
+    
+    # Random parameters within broad physiological ranges
+    D = np.random.uniform(0.0001, 0.004, n_samples)      # Diffusion coefficient (mm2/s)
+    f = np.random.uniform(0.01, 0.4, n_samples)          # Perfusion fraction
+    D_star = np.random.uniform(0.005, 0.1, n_samples)    # Pseudo-diffusion (mm2/s)
+    K = np.random.uniform(0, 2.5, n_samples)             # Kurtosis (dimensionless)
+    
+    X = []
+    Y = [] # Targets: [D, f, D*, K]
+    
+    for i in range(n_samples):
+        # Signal model: IVIM-DKI
+        # S/S0 = f * exp(-b*D*) + (1-f) * exp(-b*D + 1/6 * b^2 * D^2 * K)
+        
+        # Diffusion term with Kurtosis
+        # Note: We clip the exponent to avoid overflow/numerical issues at high b-values/K
+        exponent_diff = -b_values * D[i] + (1/6) * (b_values**2) * (D[i]**2) * K[i]
+        term_diff = np.exp(exponent_diff)
+        
+        # Perfusion term
+        term_perf = np.exp(-b_values * D_star[i])
+        
+        signal = f[i] * term_perf + (1 - f[i]) * term_diff
+        
+        # Add Rician noise (approximated as Gaussian for simplicity in this large batch)
+        # SNR varying between 20 and 100
+        snr = np.random.uniform(20, 100)
+        sigma = 1.0 / snr
+        noise = np.random.normal(0, sigma, size=len(b_values))
+        
+        signal_noisy = signal + noise
+        
+        # Rician correction (magnitude)
+        signal_noisy = np.sqrt(signal_noisy**2 + noise**2) # Simple approximation
+        
+        # Normalize (though it's already relative to S0=1)
+        signal_norm = signal_noisy / np.max(signal_noisy)
+        
+        X.append(signal_norm)
+        Y.append([D[i], f[i], D_star[i], K[i]])
+        
+    return np.array(X), np.array(Y), b_values
+
+def train_and_save():
+    X, Y, b_values = generate_comprehensive_training_data(n_samples=50000)
+    
+    print("Training ExtraTreesRegressor (Multi-output)...")
+    # Optimized for model size < 100MB for GitHub hosting
+    model = ExtraTreesRegressor(
+        n_estimators=50,        # Reduced from 100
+        max_depth=20,           # Limit depth to prevent massive trees
+        min_samples_leaf=5,     # Prune leaves to reduce size
+        min_samples_split=10,
+        n_jobs=-1,
+        random_state=42,
+        verbose=1
+    )
+    
+    model.fit(X, Y)
+    
+    # Evaluate on a small subset
+    preds = model.predict(X[:1000])
+    mse = mean_squared_error(Y[:1000], preds)
+    print(f"Training MSE: {mse:.6f}")
+    
+    # Save model
+    model_path = 'models/ivim_dki_extratrees.joblib'
+    joblib.dump(model, model_path, compress=3) # Compress to keep file size small
+    print(f"Model saved to {model_path}")
+    
+    # Save b-values metadata so we know what protocol this model expects
+    np.save('models/b_values_config.npy', b_values)
+    print("Configuration saved.")
+
+if __name__ == "__main__":
+    train_and_save()