Repository: atong01/conditional-flow-matching (language: python)

Issue:
Added the ForestFlow example

This adds the ForestFlow example. Let me know if the format is okay. I left the pip install for the special library requirements (except for torchcfm, which is assumed installed).


Discussion / hints:

Fix patch:
diff --git a/README.md b/README.md
index 65f3eec..ae8c019 100644
--- a/README.md
+++ b/README.md
@@ -23,7 +23,7 @@
 
 ## Description
 
-Conditional Flow Matching (CFM) is a fast way to train continuous normalizing flow (CNF) models. CFM is a simulation-free training objective for continuous normalizing flows that allows conditional generative modeling and speeds up training and inference. CFM's performance closes the gap between CNFs and diffusion models. To spread its use within the machine learning community, we have built a library focused on Flow Matching methods: TorchCFM. TorchCFM is a library showing how Flow Matching methods can be trained and used to deal with image generation, single-cell dynamics and (soon) SO(3) data and tabular data.
+Conditional Flow Matching (CFM) is a fast way to train continuous normalizing flow (CNF) models. CFM is a simulation-free training objective for continuous normalizing flows that allows conditional generative modeling and speeds up training and inference. CFM's performance closes the gap between CNFs and diffusion models. To spread its use within the machine learning community, we have built a library focused on Flow Matching methods: TorchCFM. TorchCFM is a library showing how Flow Matching methods can be trained and used to deal with image generation, single-cell dynamics, tabular data and soon SO(3) data.
 
 <p align="center">
 <img src="assets/169_generated_samples_otcfm.png" width="600"/>
@@ -107,8 +107,8 @@ List of implemented papers:
 - Building Normalizing Flows with Stochastic Interpolants (Albergo et al. 2023a) [Paper](https://openreview.net/forum?id=li7qeBbCR1t)
 - Action Matching: Learning Stochastic Dynamics From Samples (Neklyudov et al. 2022) [Paper](https://arxiv.org/abs/2210.06662) [Code](https://github.com/necludov/jam)
 - Concurrent work to our OT-CFM method: Multisample Flow Matching: Straightening Flows with Minibatch Couplings (Pooladian et al. 2023) [Paper](https://arxiv.org/abs/2304.14772)
-- Soon: SE(3)-Stochastic Flow Matching for Protein Backbone Generation (Bose et al.) [paper](https://arxiv.org/abs/2310.02391)
-- Soon: Generating and Imputing Tabular Data via Diffusion and Flow-based Gradient-Boosted Trees (Jolicoeur-Martineau et al.) [paper](https://arxiv.org/abs/2309.09968)
+- Generating and Imputing Tabular Data via Diffusion and Flow-based Gradient-Boosted Trees (Jolicoeur-Martineau et al.) [Paper](https://arxiv.org/abs/2309.09968) [Code](https://github.com/SamsungSAILMontreal/ForestDiffusion)
+- Soon: SE(3)-Stochastic Flow Matching for Protein Backbone Generation (Bose et al.) [Paper](https://arxiv.org/abs/2310.02391)
 
 ## How to run
 
@@ -155,7 +155,7 @@ python -m ipykernel install --user --name=torchcfm
 
 ## Project Structure
 
-The directory structure of a new project looks like this:
+The directory structure looks like this:
 
 ```
 
diff --git a/examples/notebooks/mnist_example.ipynb b/examples/notebooks/mnist_example.ipynb
index f93334f..eb81c7a 100644
--- a/examples/notebooks/mnist_example.ipynb
+++ b/examples/notebooks/mnist_example.ipynb
@@ -253,6 +253,8 @@
    "outputs": [],
    "source": [
     "# follows example from https://github.com/google-research/torchsde/blob/master/examples/cont_ddpm.py\n",
+    "\n",
+    "\n",
     "class SDE(torch.nn.Module):\n",
     "    noise_type = \"diagonal\"\n",
     "    sde_type = \"ito\"\n",
diff --git a/examples/notebooks/training-8gaussians-to-moons.ipynb b/examples/notebooks/training-8gaussians-to-moons.ipynb
index 3123030..e8d69e0 100644
--- a/examples/notebooks/training-8gaussians-to-moons.ipynb
+++ b/examples/notebooks/training-8gaussians-to-moons.ipynb
@@ -843,6 +843,8 @@
    ],
    "source": [
     "# %%time\n",
+    "\n",
+    "\n",
     "class MLP2(torch.nn.Module):\n",
     "    def __init__(self, dim, out_dim=None, w=64, time_varying=False):\n",
     "        super().__init__()\n",
diff --git a/examples/tabular/README.md b/examples/tabular/README.md
new file mode 100644
index 0000000..1b36507
--- /dev/null
+++ b/examples/tabular/README.md
@@ -0,0 +1,20 @@
+# Forest-Flow experiment on the Iris dataset using TorchCFM
+
+This notebook is a self-contained example showing how to train the novel Forest-Flow method to generate tabular data [(Jolicoeur-Martineau et al. 2023)](https://arxiv.org/abs/2309.09968). The idea behind Forest-Flow is to **learn Independent Conditional Flow-Matching's vector field with XGBoost models** instead of neural networks. The motivation is that it is known that Forests work currently better than neural networks on Tabular data tasks. This idea comes with some difficulties, for instance how to approximate Flow Matching's loss, and this notebook shows how to do it on a minimal example. The method, its training procedure and the experiments are described in [(Jolicoeur-Martineau et al. 2023)](https://arxiv.org/abs/2309.09968). The full code can be found [here](https://github.com/SamsungSAILMontreal/ForestDiffusion).
+
+To run our jupyter notebooks, installing our package:
+
+```bash
+cd ../../
+
+# install torchcfm
+pip install -e '.[forest-flow]'
+
+# install ipykernel
+conda install -c anaconda ipykernel
+
+# install conda env in jupyter notebook
+python -m ipykernel install --user --name=torchcfm
+
+# launch our notebooks with the torchcfm kernel
+```
diff --git a/examples/tabular/Tabular_Data_Generation_with_XGBoost_Conditional_Flow_Matching.ipynb b/examples/tabular/Tabular_Data_Generation_with_XGBoost_Conditional_Flow_Matching.ipynb
new file mode 100644
index 0000000..78e6203
--- /dev/null
+++ b/examples/tabular/Tabular_Data_Generation_with_XGBoost_Conditional_Flow_Matching.ipynb
@@ -0,0 +1,695 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "AvwwEfWfDuea"
+   },
+   "source": [
+    "# Generating Tabular Data via XGBoost Models with Flow-Matching\n",
+    "\n",
+    "This notebook is a self-contained example showing how to train the novel Forest-Flow method to generate tabular data. The idea behind Forest-Flow is to learn Flow-Matching's vector field with XGBoost models instead of neural networks. The motivation is that it is known that Forests work currently better than neural networks on Tabular data tasks. This idea comes with some difficulties, for instance how to approximate Flow Matching's loss, and this notebook shows how to do it on a minimal example. The method, its training procedure and the experiments are described in [(Jolicoeur-Martineau et al. 2023)](https://arxiv.org/abs/2309.09968). The full code can be found [here](https://github.com/SamsungSAILMontreal/ForestDiffusion). "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "nW9nJoK3wMWM"
+   },
+   "source": [
+    "# Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "id": "zEBSd1b7HVVG"
+   },
+   "outputs": [],
+   "source": [
+    "import copy\n",
+    "from functools import partial\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "import xgboost as xgb\n",
+    "from joblib import Parallel, delayed\n",
+    "from sklearn.datasets import load_iris\n",
+    "from sklearn.preprocessing import MinMaxScaler\n",
+    "\n",
+    "from torchcfm.conditional_flow_matching import ConditionalFlowMatcher"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# set seed\n",
+    "seed = 1980\n",
+    "np.random.seed(seed)\n",
+    "torch.manual_seed(seed)\n",
+    "torch.cuda.manual_seed(seed)\n",
+    "torch.cuda.manual_seed_all(seed)\n",
+    "torch.backends.cudnn.benchmark = True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9tIIxR1eHTsm"
+   },
+   "source": [
+    "As example, we use [Iris](https://en.wikipedia.org/wiki/Iris_flower_data_set), a classic tabular dataset about flowers with 150 observations, 4 input continuous variables (sepal length, sepal width, petal length, and petal width), and 1 categorical outcome variable (3 categories of flowers; setosa, versicolor, and virginica)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "id": "4WJCRVrqDVIw"
+   },
+   "outputs": [],
+   "source": [
+    "# Iris: numpy dataset with 4 variables (all numerical) and 1 outcome (categorical; 3 categories)\n",
+    "my_data = load_iris()\n",
+    "X, y = my_data[\"data\"], my_data[\"target\"]\n",
+    "\n",
+    "# shuffle the observations\n",
+    "new_perm = np.random.permutation(X.shape[0])\n",
+    "np.take(X, new_perm, axis=0, out=X)\n",
+    "np.take(y, new_perm, axis=0, out=y)\n",
+    "\n",
+    "# Save data before adding missing values\n",
+    "X_true, y_true = copy.deepcopy(X), copy.deepcopy(y)\n",
+    "Xy_true = np.concatenate((X_true, np.expand_dims(y_true, axis=1)), axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "jjIE966SK2Kr",
+    "outputId": "9e766c37-6153-4da1-cfc7-dc339db4aee7"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[6.4, 2.9, 4.3, 1.3],\n",
+       "       [6.3, 2.5, 4.9, 1.5],\n",
+       "       [5. , 3.5, 1.3, 0.3],\n",
+       "       [7.6, 3. , 6.6, 2.1],\n",
+       "       [5.7, 2.6, 3.5, 1. ],\n",
+       "       [6.9, 3.2, 5.7, 2.3],\n",
+       "       [6.4, 3.2, 5.3, 2.3],\n",
+       "       [5.7, 2.8, 4.1, 1.3],\n",
+       "       [4.4, 3. , 1.3, 0.2],\n",
+       "       [5.4, 3.4, 1.5, 0.4]])"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X[0:10]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "uy5sn6vaLsQq",
+    "outputId": "7a55e318-b7d4-4d59-ea0e-2236ca2adcd8"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1, 1, 0, 2, 1, 2, 2, 1, 0, 0])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y[0:10]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "t9PiFTtrIWgl"
+   },
+   "source": [
+    "We set the hyperparameters here."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "id": "TDYP6yz-IHBt"
+   },
+   "outputs": [],
+   "source": [
+    "# Main hyperparameters\n",
+    "n_t = 50  # number of flow steps (higher is better, 50 is enough for great performance)\n",
+    "duplicate_K = 100  # number of different noise sample per real data sample (higher is better)\n",
+    "\n",
+    "# XGBoost hyperparameters\n",
+    "max_depth = 7\n",
+    "n_estimators = 100\n",
+    "eta = 0.3\n",
+    "tree_method = \"hist\"\n",
+    "reg_lambda = 0.0\n",
+    "reg_alpha = 0.0\n",
+    "subsample = 1.0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "xlDzllCzt-AP"
+   },
+   "source": [
+    "We do the data preprocessing, which includes min/max normalization and extracting the $x(t)$, $y$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "id": "6xamj-lqIHG5"
+   },
+   "outputs": [],
+   "source": [
+    "# Save min/max of the values\n",
+    "X_min = np.nanmin(X, axis=0, keepdims=1)\n",
+    "X_max = np.nanmax(X, axis=0, keepdims=1)\n",
+    "\n",
+    "# Min-Max scaling of the variables\n",
+    "scaler = MinMaxScaler(feature_range=(-1, 1))\n",
+    "X_scaled = scaler.fit_transform(X)\n",
+    "\n",
+    "# Save shape\n",
+    "b, c = X.shape\n",
+    "\n",
+    "# we duplicate the data multiple times, so that X0 is k times bigger, so that we can have k random noise z associated per sample\n",
+    "X1 = np.tile(X_scaled, (duplicate_K, 1))\n",
+    "\n",
+    "# Generate noise data\n",
+    "X0 = np.random.normal(size=X1.shape)\n",
+    "\n",
+    "# Saving the freqency of the classes and storing label masks for later\n",
+    "y_uniques, y_probs = np.unique(y, return_counts=True)\n",
+    "y_probs = y_probs / np.sum(y_probs)\n",
+    "mask_y = {}  # mask for which observations has a specific value of y\n",
+    "for i in range(len(y_uniques)):\n",
+    "    mask_y[y_uniques[i]] = np.zeros(b, dtype=bool)\n",
+    "    mask_y[y_uniques[i]][y == y_uniques[i]] = True\n",
+    "    mask_y[y_uniques[i]] = np.tile(mask_y[y_uniques[i]], (duplicate_K))\n",
+    "n_y = len(y_uniques)  # number of classes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "id": "SkAnNB_tn2Tt"
+   },
+   "outputs": [],
+   "source": [
+    "# Build [X(t), y] at multiple values of t\n",
+    "\n",
+    "# Define Independent Conditional Flow Matching (I-CFM)\n",
+    "FM = ConditionalFlowMatcher(sigma=0.0)\n",
+    "\n",
+    "# Time levels\n",
+    "t_levels = np.linspace(1e-3, 1, num=n_t)\n",
+    "\n",
+    "# Interpolation between x0 and x1 (xt)\n",
+    "X_train = np.zeros((n_t, X0.shape[0], X0.shape[1]))  # [n_t, b, c]\n",
+    "\n",
+    "# Output to predict (ut)\n",
+    "y_train = np.zeros((n_t, X0.shape[0], X0.shape[1]))  # [n_t, b, c]\n",
+    "\n",
+    "# Fill with xt and ut\n",
+    "for i in range(n_t):\n",
+    "    t = torch.ones(X0.shape[0]) * t_levels[i]  # current t\n",
+    "    _, xt, ut = FM.sample_location_and_conditional_flow(\n",
+    "        torch.from_numpy(X0), torch.from_numpy(X1), t=t\n",
+    "    )\n",
+    "    X_train[i], y_train[i] = xt.numpy(), ut.numpy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1f-NfQ1DuKYv"
+   },
+   "source": [
+    "We train the $ckn_t$ XGBoost models, where $k$ is the number of classes (3), $c$ is the number of input variables (4), and $n_t$ is the number of time levels (50) ."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "id": "bB0kQI8zsSpB"
+   },
+   "outputs": [],
+   "source": [
+    "# Function used for training one model\n",
+    "\n",
+    "\n",
+    "def train_parallel(X_train, y_train):\n",
+    "    model = xgb.XGBRegressor(\n",
+    "        n_estimators=n_estimators,\n",
+    "        objective=\"reg:squarederror\",\n",
+    "        eta=eta,\n",
+    "        max_depth=max_depth,\n",
+    "        reg_lambda=reg_lambda,\n",
+    "        reg_alpha=reg_alpha,\n",
+    "        subsample=subsample,\n",
+    "        seed=666,\n",
+    "        tree_method=tree_method,\n",
+    "        device=\"cpu\",\n",
+    "    )\n",
+    "\n",
+    "    y_no_miss = ~np.isnan(y_train)\n",
+    "    model.fit(X_train[y_no_miss, :], y_train[y_no_miss])\n",
+    "\n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "FR6zUk0asDQ5",
+    "outputId": "878152dc-9b1d-432c-bc18-2b6bee5dfbc1"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 4.27 s, sys: 1.82 s, total: 6.09 s\n",
+      "Wall time: 10.4 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "# Train all model(s); fast if you have a decent multi-core CPU, but extremely slow on Google Colab because it uses a weak 2-core CPU\n",
+    "\n",
+    "\n",
+    "regr = Parallel(n_jobs=-1)(  # using all cpus\n",
+    "    delayed(train_parallel)(\n",
+    "        X_train.reshape(n_t, b * duplicate_K, c)[i][mask_y[j], :],\n",
+    "        y_train.reshape(n_t, b * duplicate_K, c)[i][mask_y[j], k],\n",
+    "    )\n",
+    "    for i in range(n_t)\n",
+    "    for j in y_uniques\n",
+    "    for k in range(c)\n",
+    ")\n",
+    "\n",
+    "# Replace fits with doubly loops to make things easier\n",
+    "regr_ = [[[None for k in range(c)] for i in range(n_t)] for j in y_uniques]\n",
+    "current_i = 0\n",
+    "for i in range(n_t):\n",
+    "    for j in range(len(y_uniques)):\n",
+    "        for k in range(c):\n",
+    "            regr_[j][i][k] = regr[current_i]\n",
+    "            current_i += 1\n",
+    "regr = regr_"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "v3arcvLGum4X"
+   },
+   "source": [
+    "We generate data by solving the ODE."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "id": "xk85Vtbvurx3"
+   },
+   "outputs": [],
+   "source": [
+    "batch_size = 150  # number of generated samples"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "id": "o77nB480vQNO"
+   },
+   "outputs": [],
+   "source": [
+    "# Return the flow at time t using the XGBoost models\n",
+    "\n",
+    "\n",
+    "def my_model(t, xt, mask_y=None):\n",
+    "    # xt is [b*c]\n",
+    "    xt = xt.reshape(xt.shape[0] // c, c)  # [b, c]\n",
+    "\n",
+    "    # Output from the models\n",
+    "    out = np.zeros(xt.shape)  # [b, c]\n",
+    "    i = int(round(t * (n_t - 1)))\n",
+    "    for j, label in enumerate(y_uniques):\n",
+    "        for k in range(c):\n",
+    "            out[mask_y[label], k] = regr[j][i][k].predict(xt[mask_y[label], :])\n",
+    "\n",
+    "    out = out.reshape(-1)  # [b*c]\n",
+    "    return out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "id": "XCSiPfy-topJ"
+   },
+   "outputs": [],
+   "source": [
+    "# Simple Euler ODE solver (nothing fancy)\n",
+    "\n",
+    "\n",
+    "def euler_solve(x0, my_model, N=100):\n",
+    "    h = 1 / (N - 1)\n",
+    "    x_fake = x0\n",
+    "    t = 0\n",
+    "    # from t=0 to t=1\n",
+    "    for i in range(N - 1):\n",
+    "        x_fake = x_fake + h * my_model(t=t, xt=x_fake)\n",
+    "        t = t + h\n",
+    "    return x_fake"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "id": "ap2rI0zhs7Fp"
+   },
+   "outputs": [],
+   "source": [
+    "# Generate prior noise\n",
+    "x0 = np.random.normal(size=(batch_size, c))\n",
+    "\n",
+    "# Generate random labels for the outcome\n",
+    "label_y_fake = y_uniques[np.argmax(np.random.multinomial(1, y_probs, size=x0.shape[0]), axis=1)]\n",
+    "mask_y_fake = {}  # mask for which observations has a specific value of y\n",
+    "for i in range(len(y_uniques)):\n",
+    "    mask_y_fake[y_uniques[i]] = np.zeros(x0.shape[0], dtype=bool)\n",
+    "    mask_y_fake[y_uniques[i]][label_y_fake == y_uniques[i]] = True\n",
+    "\n",
+    "# ODE solve\n",
+    "ode_solved = euler_solve(\n",
+    "    my_model=partial(my_model, mask_y=mask_y_fake), x0=x0.reshape(-1), N=n_t\n",
+    ")  # [t, b*c]\n",
+    "solution = ode_solved.reshape(batch_size, c)  # [b, c]\n",
+    "\n",
+    "# invert the min-max normalization\n",
+    "solution = scaler.inverse_transform(solution)\n",
+    "\n",
+    "# clip to min/max values\n",
+    "small = (solution < X_min).astype(float)\n",
+    "solution = small * X_min + (1 - small) * solution\n",
+    "big = (solution > X_max).astype(float)\n",
+    "solution = big * X_max + (1 - big) * solution\n",
+    "\n",
+    "# Concatenate the y label\n",
+    "Xy_fake = np.concatenate((solution, np.expand_dims(label_y_fake, axis=1)), axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "W0n4u7bc0uOB"
+   },
+   "source": [
+    "We just generated fake tabular data! Lets now compare the two dataset (real vs fake)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "-Vw__-M2yKK7",
+    "outputId": "d7ca83b0-1c1e-474c-b5c2-f9cf86e60570"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[6.4, 2.9, 4.3, 1.3, 1. ],\n",
+       "       [6.3, 2.5, 4.9, 1.5, 1. ],\n",
+       "       [5. , 3.5, 1.3, 0.3, 0. ],\n",
+       "       [7.6, 3. , 6.6, 2.1, 2. ],\n",
+       "       [5.7, 2.6, 3.5, 1. , 1. ],\n",
+       "       [6.9, 3.2, 5.7, 2.3, 2. ],\n",
+       "       [6.4, 3.2, 5.3, 2.3, 2. ],\n",
+       "       [5.7, 2.8, 4.1, 1.3, 1. ],\n",
+       "       [4.4, 3. , 1.3, 0.2, 0. ],\n",
+       "       [5.4, 3.4, 1.5, 0.4, 0. ]])"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Xy_true[0:10]  # Real data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "tRXq9n3QvwsW",
+    "outputId": "2803303c-c42e-43d8-aaee-da38458bb385"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[5.98631354, 2.70193138, 4.65867317, 1.19586857, 1.        ],\n",
+       "       [5.74409306, 2.50085168, 5.09530475, 2.25178491, 2.        ],\n",
+       "       [6.73807458, 3.02723934, 5.38495621, 2.05042391, 2.        ],\n",
+       "       [6.38365676, 2.91431543, 5.74605444, 2.19531052, 2.        ],\n",
+       "       [5.019457  , 3.60030362, 1.40577746, 0.19351193, 0.        ],\n",
+       "       [5.68787654, 2.90044269, 4.15852277, 1.298309  , 1.        ],\n",
+       "       [6.98276689, 3.18978173, 5.77776862, 2.09860239, 2.        ],\n",
+       "       [5.10127287, 3.80102575, 1.55116821, 0.19748871, 0.        ],\n",
+       "       [5.669288  , 2.80610403, 4.0720058 , 1.29987691, 1.        ],\n",
+       "       [4.95260976, 3.19941354, 1.37698165, 0.2002001 , 0.        ]])"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Xy_fake[0:10]  # Flow generated data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 455
+    },
+    "id": "teqKVOb-xgsk",
+    "outputId": "2c426c9b-f9e9-46bc-f7fc-926869552a5d"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_, (ax1, ax2) = plt.subplots(2)\n",
+    "# Real data\n",
+    "scatter = ax1.scatter(Xy_true[:, 0], Xy_true[:, 1], c=Xy_true[:, -1])\n",
+    "ax1.set(\n",
+    "    xlabel=my_data.feature_names[0], ylabel=my_data.feature_names[1], xlim=(4, 8), ylim=(2, 4.5)\n",
+    ")\n",
+    "_ = ax1.legend(\n",
+    "    scatter.legend_elements()[0], my_data.target_names, loc=\"lower right\", title=\"Classes\"\n",
+    ")\n",
+    "# Fake data\n",
+    "scatter = ax2.scatter(Xy_fake[:, 0], Xy_fake[:, 1], c=Xy_fake[:, -1])\n",
+    "ax2.set(\n",
+    "    xlabel=my_data.feature_names[0], ylabel=my_data.feature_names[1], xlim=(4, 8), ylim=(2, 4.5)\n",
+    ")\n",
+    "_ = ax2.legend(\n",
+    "    scatter.legend_elements()[0], my_data.target_names, loc=\"lower right\", title=\"Classes\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "qgMj9KxODUyP"
+   },
+   "source": [
+    "Below we show how to do the same with the [ForestDiffusion pip package](https://github.com/SamsungSAILMontreal/ForestDiffusion)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "iwsuf2VP6HxI",
+    "outputId": "6ac4e540-e272-4b1f-bae7-03ac014d2abc"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 2.84 s, sys: 5.15 s, total: 8 s\n",
+      "Wall time: 11.6 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "from ForestDiffusion import ForestDiffusionModel as ForestFlowModel\n",
+    "\n",
+    "forest_model = ForestFlowModel(\n",
+    "    X,\n",
+    "    label_y=y,\n",
+    "    n_t=50,\n",
+    "    duplicate_K=100,\n",
+    "    bin_indexes=[],\n",
+    "    cat_indexes=[],\n",
+    "    int_indexes=[],\n",
+    "    diffusion_type=\"flow\",\n",
+    "    n_jobs=-1,\n",
+    "    seed=1,\n",
+    ")\n",
+    "Xy_fake_ = forest_model.generate(batch_size=X.shape[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 455
+    },
+    "id": "yGxkJT3g6TJ5",
+    "outputId": "788ee11f-7cf8-4d9b-b300-a4b243559fad"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_, (ax1, ax2) = plt.subplots(2)\n",
+    "# Real data\n",
+    "scatter = ax1.scatter(Xy_true[:, 0], Xy_true[:, 1], c=Xy_true[:, -1])\n",
+    "ax1.set(\n",
+    "    xlabel=my_data.feature_names[0], ylabel=my_data.feature_names[1], xlim=(4, 8), ylim=(2, 4.5)\n",
+    ")\n",
+    "_ = ax1.legend(\n",
+    "    scatter.legend_elements()[0], my_data.target_names, loc=\"lower right\", title=\"Classes\"\n",
+    ")\n",
+    "# Fake data\n",
+    "scatter = ax2.scatter(Xy_fake_[:, 0], Xy_fake_[:, 1], c=Xy_fake_[:, -1])\n",
+    "ax2.set(\n",
+    "    xlabel=my_data.feature_names[0], ylabel=my_data.feature_names[1], xlim=(4, 8), ylim=(2, 4.5)\n",
+    ")\n",
+    "_ = ax2.legend(\n",
+    "    scatter.legend_elements()[0], my_data.target_names, loc=\"lower right\", title=\"Classes\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "torchcfm",
+   "language": "python",
+   "name": "torchcfm"
+  },
+  "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.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/setup.py b/setup.py
index 7e958d4..cde6dd2 100644
--- a/setup.py
+++ b/setup.py
@@ -36,4 +36,5 @@
     long_description=readme,
     long_description_content_type="text/markdown",
     packages=find_packages(exclude=["tests", "tests.*"]),
+    extras_require={"forest-flow": ["xgboost", "scikit-learn", "ForestDiffusion"]},
 )
diff --git a/torchcfm/conditional_flow_matching.py b/torchcfm/conditional_flow_matching.py
index 603d15d..b71b6bd 100644
--- a/torchcfm/conditional_flow_matching.py
+++ b/torchcfm/conditional_flow_matching.py
@@ -155,7 +155,7 @@ def compute_conditional_flow(self, x0, x1, t, xt):
     def sample_noise_like(self, x):
         return torch.randn_like(x)
 
-    def sample_location_and_conditional_flow(self, x0, x1, return_noise=False):
+    def sample_location_and_conditional_flow(self, x0, x1, t=None, return_noise=False):
         """
         Compute the sample xt (drawn from N(t * x1 + (1 - t) * x0, sigma))
         and the conditional vector field ut(x1|x0) = x1 - x0, see Eq.(15) [1].
@@ -166,6 +166,9 @@ def sample_location_and_conditional_flow(self, x0, x1, return_noise=False):
             represents the source minibatch
         x1 : Tensor, shape (bs, *dim)
             represents the target minibatch
+        (optionally) t : Tensor, shape (bs)
+            represents the time levels
+            if None, drawn from uniform [0,1]
         return_noise : bool
             return the noise sample epsilon
 
@@ -182,7 +185,10 @@ def sample_location_and_conditional_flow(self, x0, x1, return_noise=False):
         ----------
         [1] Improving and Generalizing Flow-Based Generative Models with minibatch optimal transport, Preprint, Tong et al.
         """
-        t = torch.rand(x0.shape[0]).type_as(x0)
+        if t is None:
+            t = torch.rand(x0.shape[0]).type_as(x0)
+        assert len(t) == x0.shape[0], "t has to have batch size dimension"
+
         eps = self.sample_noise_like(x0)
         xt = self.sample_xt(x0, x1, t, eps)
         ut = self.compute_conditional_flow(x0, x1, t, xt)
@@ -228,7 +234,7 @@ def __init__(self, sigma: Union[float, int] = 0.0):
         super().__init__(sigma)
         self.ot_sampler = OTPlanSampler(method="exact")
 
-    def sample_location_and_conditional_flow(self, x0, x1, return_noise=False):
+    def sample_location_and_conditional_flow(self, x0, x1, t=None, return_noise=False):
         r"""
         Compute the sample xt (drawn from N(t * x1 + (1 - t) * x0, sigma))
         and the conditional vector field ut(x1|x0) = x1 - x0, see Eq.(15) [1]
@@ -240,6 +246,9 @@ def sample_location_and_conditional_flow(self, x0, x1, return_noise=False):
             represents the source minibatch
         x1 : Tensor, shape (bs, *dim)
             represents the target minibatch
+        (optionally) t : Tensor, shape (bs)
+            represents the time levels
+            if None, drawn from uniform [0,1]
         return_noise : bool
             return the noise sample epsilon
 
@@ -256,10 +265,10 @@ def sample_location_and_conditional_flow(self, x0, x1, return_noise=False):
         [1] Improving and Generalizing Flow-Based Generative Models with minibatch optimal transport, Preprint, Tong et al.
         """
         x0, x1 = self.ot_sampler.sample_plan(x0, x1)
-        return super().sample_location_and_conditional_flow(x0, x1, return_noise)
+        return super().sample_location_and_conditional_flow(x0, x1, t, return_noise)
 
     def guided_sample_location_and_conditional_flow(
-        self, x0, x1, y0=None, y1=None, return_noise=False
+        self, x0, x1, y0=None, y1=None, t=None, return_noise=False
     ):
         r"""
         Compute the sample xt (drawn from N(t * x1 + (1 - t) * x0, sigma))
@@ -276,6 +285,9 @@ def guided_sample_location_and_conditional_flow(
             represents the source label minibatch
         y1 : Tensor, shape (bs) (default: None)
             represents the target label minibatch
+        (optionally) t : Tensor, shape (bs)
+            represents the time levels
+            if None, drawn from uniform [0,1]
         return_noise : bool
             return the noise sample epsilon
 
@@ -293,10 +305,10 @@ def guided_sample_location_and_conditional_flow(
         """
         x0, x1, y0, y1 = self.ot_sampler.sample_plan_with_labels(x0, x1, y0, y1)
         if return_noise:
-            t, xt, ut, eps = super().sample_location_and_conditional_flow(x0, x1, return_noise)
+            t, xt, ut, eps = super().sample_location_and_conditional_flow(x0, x1, t, return_noise)
             return t, xt, ut, y0, y1, eps
         else:
-            t, xt, ut = super().sample_location_and_conditional_flow(x0, x1, return_noise)
+            t, xt, ut = super().sample_location_and_conditional_flow(x0, x1, t, return_noise)
             return t, xt, ut, y0, y1
 
 
@@ -456,7 +468,7 @@ def compute_conditional_flow(self, x0, x1, t, xt):
         ut = sigma_t_prime_over_sigma_t * (xt - mu_t) + x1 - x0
         return ut
 
-    def sample_location_and_conditional_flow(self, x0, x1, return_noise=False):
+    def sample_location_and_conditional_flow(self, x0, x1, t=None, return_noise=False):
         """
         Compute the sample xt (drawn from N(t * x1 + (1 - t) * x0, sqrt(t * (1 - t))*sigma^2 ))
         and the conditional vector field ut(x1|x0) = (1 - 2 * t) / (2 * t * (1 - t)) * (xt - mu_t) + x1 - x0,
@@ -468,6 +480,9 @@ def sample_location_and_conditional_flow(self, x0, x1, return_noise=False):
             represents the source minibatch
         x1 : Tensor, shape (bs, *dim)
             represents the target minibatch
+        (optionally) t : Tensor, shape (bs)
+            represents the time levels
+            if None, drawn from uniform [0,1]
         return_noise: bool
             return the noise sample epsilon
 
@@ -485,10 +500,10 @@ def sample_location_and_conditional_flow(self, x0, x1, return_noise=False):
         [1] Improving and Generalizing Flow-Based Generative Models with minibatch optimal transport, Preprint, Tong et al.
         """
         x0, x1 = self.ot_sampler.sample_plan(x0, x1)
-        return super().sample_location_and_conditional_flow(x0, x1, return_noise)
+        return super().sample_location_and_conditional_flow(x0, x1, t, return_noise)
 
     def guided_sample_location_and_conditional_flow(
-        self, x0, x1, y0=None, y1=None, return_noise=False
+        self, x0, x1, y0=None, y1=None, t=None, return_noise=False
     ):
         r"""
         Compute the sample xt (drawn from N(t * x1 + (1 - t) * x0, sigma))
@@ -505,6 +520,9 @@ def guided_sample_location_and_conditional_flow(
             represents the source label minibatch
         y1 : Tensor, shape (bs) (default: None)
             represents the target label minibatch
+        (optionally) t : Tensor, shape (bs)
+            represents the time levels
+            if None, drawn from uniform [0,1]
         return_noise : bool
             return the noise sample epsilon
 
@@ -522,10 +540,10 @@ def guided_sample_location_and_conditional_flow(
         """
         x0, x1, y0, y1 = self.ot_sampler.sample_plan_with_labels(x0, x1, y0, y1)
         if return_noise:
-            t, xt, ut, eps = super().sample_location_and_conditional_flow(x0, x1, return_noise)
+            t, xt, ut, eps = super().sample_location_and_conditional_flow(x0, x1, t, return_noise)
             return t, xt, ut, y0, y1, eps
         else:
-            t, xt, ut = super().sample_location_and_conditional_flow(x0, x1, return_noise)
+            t, xt, ut = super().sample_location_and_conditional_flow(x0, x1, t, return_noise)
             return t, xt, ut, y0, y1
 
 
diff --git a/torchcfm/version.py b/torchcfm/version.py
index 92192ee..68cdeee 100644
--- a/torchcfm/version.py
+++ b/torchcfm/version.py
@@ -1,1 +1,1 @@
-__version__ = "1.0.4"
+__version__ = "1.0.5"


Test patch:
diff --git a/tests/test_time_t.py b/tests/test_time_t.py
new file mode 100644
index 0000000..89d9499
--- /dev/null
+++ b/tests/test_time_t.py
@@ -0,0 +1,70 @@
+"""Tests for time Tensor t."""
+
+# Author: Kilian Fatras <kilian.fatras@mila.quebec>
+
+import pytest
+import torch
+
+from torchcfm.conditional_flow_matching import (
+    ConditionalFlowMatcher,
+    ExactOptimalTransportConditionalFlowMatcher,
+    SchrodingerBridgeConditionalFlowMatcher,
+    TargetConditionalFlowMatcher,
+    VariancePreservingConditionalFlowMatcher,
+)
+
+seed = 1994
+batch_size = 128
+
+
+@pytest.mark.parametrize(
+    "FM",
+    [
+        ConditionalFlowMatcher(sigma=0.0),
+        ExactOptimalTransportConditionalFlowMatcher(sigma=0.0),
+        TargetConditionalFlowMatcher(sigma=0.0),
+        SchrodingerBridgeConditionalFlowMatcher(sigma=0.1),
+        VariancePreservingConditionalFlowMatcher(sigma=0.0),
+    ],
+)
+def test_random_Tensor_t(FM):
+    # Test sample_location_and_conditional_flow functions
+    x0 = torch.randn(batch_size, 2)
+    x1 = torch.randn(batch_size, 2)
+
+    torch.manual_seed(seed)
+    t_given = torch.rand(batch_size)
+    t_given, xt, ut = FM.sample_location_and_conditional_flow(x0, x1, t=t_given)
+
+    torch.manual_seed(seed)
+    t_random, xt, ut = FM.sample_location_and_conditional_flow(x0, x1, t=None)
+
+    assert any(t_given == t_random)
+
+
+@pytest.mark.parametrize(
+    "FM",
+    [
+        ExactOptimalTransportConditionalFlowMatcher(sigma=0.0),
+        SchrodingerBridgeConditionalFlowMatcher(sigma=0.1),
+    ],
+)
+def test_guided_random_Tensor_t(FM):
+    # Test guided_sample_location_and_conditional_flow functions
+    x0 = torch.randn(batch_size, 2)
+    y0 = torch.randint(high=10, size=(batch_size, 1))
+    x1 = torch.randn(batch_size, 2)
+    y1 = torch.randint(high=10, size=(batch_size, 1))
+
+    torch.manual_seed(seed)
+    t_given = torch.rand(batch_size)
+    t_given, xt, ut, y0, y1 = FM.guided_sample_location_and_conditional_flow(
+        x0, x1, y0=y0, y1=y1, t=t_given
+    )
+
+    torch.manual_seed(seed)
+    t_random, xt, ut, y0, y1 = FM.guided_sample_location_and_conditional_flow(
+        x0, x1, y0=y0, y1=y1, t=None
+    )
+
+    assert any(t_given == t_random)