Cellpose 2.0 extension for training with sparse annotations.\n",
+ "\n",
+ "This notebook shows how to train cellpose models with sparse annotations."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "IvyuR08OZfw4"
+ },
+ "source": [
+ "# Setup\n",
+ "\n",
+ "We expect that you already set up a conda environment.\\\n",
+ "The following command will install the extra modules required in this notebook."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: stardist==0.8.3 in /mnt/md0/applications/miniconda3/envs/cellpose/lib/python3.8/site-packages (0.8.3)\r\n",
+ "Requirement already satisfied: csbdeep==0.7.2 in /mnt/md0/applications/miniconda3/envs/cellpose/lib/python3.8/site-packages (0.7.2)\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install --no-deps stardist==0.8.3 csbdeep==0.7.2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "e2cBEO1PLuO7"
+ },
+ "source": [
+ "Check CUDA version and that GPU is working in cellpose and import other libraries."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "Tt8hgC7rniP8",
+ "outputId": "677fa3d0-952f-4490-f5bb-4ef1ad0b0469"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/bin/bash: nvcc: command not found\n",
+ "Sun Sep 25 23:34:36 2022 \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| NVIDIA-SMI 470.141.03 Driver Version: 470.141.03 CUDA Version: 11.4 |\n",
+ "|-------------------------------+----------------------+----------------------+\n",
+ "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n",
+ "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n",
+ "| | | MIG M. |\n",
+ "|===============================+======================+======================|\n",
+ "| 0 NVIDIA RTX A6000 Off | 00000000:17:00.0 Off | Off |\n",
+ "| 30% 40C P8 30W / 300W | 5MiB / 48685MiB | 0% Default |\n",
+ "| | | N/A |\n",
+ "+-------------------------------+----------------------+----------------------+\n",
+ "| 1 NVIDIA RTX A6000 Off | 00000000:73:00.0 Off | Off |\n",
+ "| 30% 41C P8 26W / 300W | 2483MiB / 48677MiB | 0% Default |\n",
+ "| | | N/A |\n",
+ "+-------------------------------+----------------------+----------------------+\n",
+ " \n",
+ "+-----------------------------------------------------------------------------+\n",
+ "| Processes: |\n",
+ "| GPU GI CI PID Type Process name GPU Memory |\n",
+ "| ID ID Usage |\n",
+ "|=============================================================================|\n",
+ "| 0 N/A N/A 2430 G /usr/lib/xorg/Xorg 4MiB |\n",
+ "| 1 N/A N/A 2430 G /usr/lib/xorg/Xorg 38MiB |\n",
+ "| 1 N/A N/A 2700 G /usr/bin/gnome-shell 7MiB |\n",
+ "| 1 N/A N/A 3829328 C /opt/conda/bin/python 2433MiB |\n",
+ "+-----------------------------------------------------------------------------+\n",
+ ">>> GPU activated? YES\n"
+ ]
+ }
+ ],
+ "source": [
+ "import os, shutil\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "from cellpose import core, utils, io, models, metrics, transforms\n",
+ "from csbdeep.utils import Path, download_and_extract_zip_file, normalize\n",
+ "from glob import glob\n",
+ "from natsort import natsorted\n",
+ "from stardist import fill_label_holes, random_label_cmap\n",
+ "from stardist.matching import matching, matching_dataset\n",
+ "import skimage.measure\n",
+ "from tifffile import imread\n",
+ "from tqdm import tqdm\n",
+ "\n",
+ "\n",
+ "from utils import plot_img_label, to_sparse, get_data, plot_stats, run_analysis, remove_small_labels\n",
+ "\n",
+ "use_GPU = core.use_gpu()\n",
+ "yn = ['NO', 'YES']\n",
+ "print(f'>>> GPU activated? {yn[use_GPU]}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Data\n",
+ "\n",
+ "\n",
+ "Training data (for input `X` with associated label masks `Y`) can be provided via lists of numpy arrays, where each image can have a different size. Alternatively, a single numpy array can also be used if all images have the same size. \n",
+ "Input images can either be two-dimensional (single-channel) or three-dimensional (multi-channel) arrays, where the channel axis comes last. Label images need to be integer-valued.\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Files found, nothing to download.\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 416/416 [00:01<00:00, 302.05it/s]\n",
+ "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 416/416 [00:02<00:00, 187.74it/s]\n",
+ "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 48/48 [00:00<00:00, 249.61it/s]\n",
+ "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 48/48 [00:00<00:00, 123.91it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "number of images for training: 416\n",
+ "number of images for validation: 48\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "(X_trn, Y_trn), (X_val, Y_val) = get_data()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "VfE75htF0l84"
+ },
+ "source": [
+ "# Train model on manual annotations\n",
+ "\n",
+ "Skip this step if you already have a pretrained model.\n",
+ "\n",
+ "Fill out the form below with the paths to your data and the parameters to start training."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "lLdKNWQ4jxy5"
+ },
+ "source": [
+ "## Training parameters\n",
+ "\n",
+ " **Paths for training, predictions and results**\n",
+ "\n",
+ "\n",
+ "**`train_dir:`, `test_dir`:** These are the paths to your folders train_dir (with images and masks of training images) and test_dir (with images and masks of test images). You can leave the test_dir blank, but it's recommended to have some test images to check the model's performance. To find the paths of the folders containing the respective datasets, go to your Files on the left of the notebook, navigate to the folder containing your files and copy the path by right-clicking on the folder, **Copy path** and pasting it into the right box below.\n",
+ "\n",
+ "**`initial_model`:** Choose a model from the cellpose [model zoo](https://cellpose.readthedocs.io/en/latest/models.html#model-zoo) to start from.\n",
+ "\n",
+ "**`model_name`**: Enter the path where your model will be saved once trained (for instance your result folder).\n",
+ "\n",
+ "**Training parameters**\n",
+ "\n",
+ "**`number_of_epochs`:** Input how many epochs (rounds) the network will be trained. At least 100 epochs are recommended, but sometimes 250 epochs are necessary, particularly from scratch. **Default value: 100**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "cellView": "form",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "XQI4aUxCjz3n",
+ "outputId": "804d0459-b120-4298-9b4c-87a9ca26401c"
+ },
+ "outputs": [],
+ "source": [
+ "#@markdown ###Path to saved models:\n",
+ "\n",
+ "save_path = \".\" #@param {type:\"string\"}\n",
+ "\n",
+ "# model name and path\n",
+ "#@markdown ###Name of the pretrained model to start from and new model name:\n",
+ "initial_model = \"scratch\" #@param ['cyto','nuclei','tissuenet','livecell','cyto2','CP','CPx','TN1','TN2','TN3','LC1','LC2','LC3','LC4','scratch']\n",
+ "\n",
+ "# other parameters for training.\n",
+ "#@markdown ###Training Parameters:\n",
+ "#@markdown Number of epochs:\n",
+ "n_epochs = 100 #@param {type:\"number\"}\n",
+ "\n",
+ "Channel_to_use_for_training = \"Grayscale\" #@param [\"Grayscale\", \"Blue\", \"Green\", \"Red\"]\n",
+ "\n",
+ "# @markdown ###If you have a secondary channel that can be used for training, for instance nuclei, choose it here:\n",
+ "\n",
+ "Second_training_channel= \"None\" #@param [\"None\", \"Blue\", \"Green\", \"Red\"]\n",
+ "\n",
+ "\n",
+ "#@markdown ###Advanced Parameters\n",
+ "\n",
+ "Use_Default_Advanced_Parameters = False #@param {type:\"boolean\"}\n",
+ "#@markdown ###If not, please input:\n",
+ "learning_rate = 0.001 #@param {type:\"number\"}\n",
+ "weight_decay = 0.0001 #@param {type:\"number\"}\n",
+ "\n",
+ "# Here we match the channel to number\n",
+ "chan = [\"Grayscale\", \"Red\", \"Green\", \"Blue\"].index(Channel_to_use_for_training)\n",
+ "chan2 = [\"None\", \"Red\", \"Green\", \"Blue\"].index(Second_training_channel)\n",
+ "\n",
+ "if initial_model=='scratch':\n",
+ " initial_model = None"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "3JRxBPmatrK7"
+ },
+ "source": [
+ "## Train new model\n",
+ "\n",
+ "Using settings from form above, train model in notebook."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def train_model(X_trn, Y_trn, X_val, Y_val, description, **kwargs):\n",
+ " use_GPU = kwargs.get('use_GPU', core.use_gpu())\n",
+ " initial_model = kwargs.get('initial_model', None)\n",
+ " channels = kwargs.get('channels', [0, 0])\n",
+ " save_path = kwargs.get('save_path', '.')\n",
+ " n_epochs = kwargs.get('n_epochs', 100)\n",
+ " learning_rate = kwargs.get('learning_rate', 0.001)\n",
+ " weight_decay = kwargs.get('weight_decay', 0.0001)\n",
+ " nimg_per_epoch = kwargs.get('nimg_per_epoch', 8)\n",
+ " \n",
+ " model = models.CellposeModel(gpu=use_GPU, model_type=initial_model)\n",
+ " model.train(X_trn.copy(),\n",
+ " Y_trn,\n",
+ " test_data=X_val.copy(),\n",
+ " test_labels=Y_val.copy(),\n",
+ " channels=channels,\n",
+ " normalize=False, # already normalized\n",
+ " save_path=save_path,\n",
+ " n_epochs=n_epochs,\n",
+ " learning_rate=learning_rate,\n",
+ " weight_decay=weight_decay,\n",
+ " nimg_per_epoch=nimg_per_epoch,\n",
+ " model_name=description,\n",
+ " min_train_masks=1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def eval_model(X_val, description, **kwargs):\n",
+ " use_GPU = kwargs.get('use_GPU', core.use_gpu())\n",
+ " save_path = kwargs.get('save_path', '.')\n",
+ " model_path = os.path.join(save_path, 'models', description)\n",
+ " model = models.CellposeModel(gpu=use_GPU, pretrained_model=model_path)\n",
+ " channels = kwargs.get('channels', [0, 0]) \n",
+ " diam_labels = model.diam_labels.copy()\n",
+ " return [model.eval(x,\n",
+ " channels=channels,\n",
+ " normalize=False, # already normalized\n",
+ " diameter=diam_labels)[0]\n",
+ " for x in tqdm(X_val)]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2022-09-25 23:43:10,207 [INFO] WRITING LOG OUTPUT TO /home/useradmin/.cellpose/run.log\n"
+ ]
+ }
+ ],
+ "source": [
+ "# start logger (to see training across epochs)\n",
+ "logger = io.logger_setup()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Train models? (existing models can be overwritten) (y/n): y\n"
+ ]
+ }
+ ],
+ "source": [
+ "is_train = input('Train models? (existing models can be overwritten) (y/n): ').lower().strip() == 'y'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "416it [00:05, 81.18it/s] \n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2022-09-29 12:06:49,125 [INFO] ** TORCH CUDA version installed and working. **\n",
+ "2022-09-29 12:06:49,127 [INFO] ** TORCH CUDA version installed and working. **\n",
+ "2022-09-29 12:06:49,128 [INFO] >>>> using GPU\n",
+ "2022-09-29 12:06:49,373 [INFO] computing flows for labels\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 416/416 [00:04<00:00, 93.52it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2022-09-29 12:06:54,898 [INFO] computing flows for labels\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 48/48 [00:01<00:00, 34.96it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2022-09-29 12:06:57,126 [INFO] >>>> median diameter set to = 30\n",
+ "2022-09-29 12:06:57,128 [INFO] >>>> mean of training label mask diameters (saved to model) 14.897\n",
+ "2022-09-29 12:06:57,129 [INFO] >>>> training network with 2 channel input <<<<\n",
+ "2022-09-29 12:06:57,130 [INFO] >>>> LR: 0.00100, batch_size: 8, weight_decay: 0.00010\n",
+ "2022-09-29 12:06:57,131 [INFO] >>>> ntrain = 416, ntest = 48\n",
+ "2022-09-29 12:06:57,133 [INFO] >>>> nimg_per_epoch = 416\n",
+ "2022-09-29 12:07:05,237 [INFO] Epoch 0, Time 8.1s, Loss 2.1501, Loss Test 1.5788, LR 0.0000\n",
+ "2022-09-29 12:07:13,027 [INFO] saving network parameters to paper03/models/min_001\n",
+ "2022-09-29 12:07:46,773 [INFO] Epoch 5, Time 49.6s, Loss 1.1161, Loss Test 1.1538, LR 0.0006\n",
+ "2022-09-29 12:08:28,938 [INFO] Epoch 10, Time 91.8s, Loss 0.7251, Loss Test 0.9274, LR 0.0010\n",
+ "2022-09-29 12:09:54,560 [INFO] Epoch 20, Time 177.4s, Loss 0.5123, Loss Test 1.2449, LR 0.0010\n",
+ "2022-09-29 12:11:19,926 [INFO] Epoch 30, Time 262.8s, Loss 0.3384, Loss Test 1.4229, LR 0.0010\n",
+ "2022-09-29 12:12:44,859 [INFO] Epoch 40, Time 347.7s, Loss 0.3928, Loss Test 1.4110, LR 0.0010\n",
+ "2022-09-29 12:14:08,739 [INFO] Epoch 50, Time 431.6s, Loss 0.3070, Loss Test 1.4498, LR 0.0010\n",
+ "2022-09-29 12:15:32,386 [INFO] Epoch 60, Time 515.3s, Loss 0.3390, Loss Test 1.6376, LR 0.0010\n",
+ "2022-09-29 12:16:57,084 [INFO] Epoch 70, Time 600.0s, Loss 0.3613, Loss Test 1.6754, LR 0.0010\n",
+ "2022-09-29 12:18:21,669 [INFO] Epoch 80, Time 684.5s, Loss 0.3684, Loss Test 1.7127, LR 0.0010\n",
+ "2022-09-29 12:19:46,101 [INFO] Epoch 90, Time 769.0s, Loss 0.3224, Loss Test 1.4578, LR 0.0010\n",
+ "2022-09-29 12:21:01,553 [INFO] saving network parameters to paper03/models/min_001\n",
+ "2022-09-29 12:21:01,822 [INFO] ** TORCH CUDA version installed and working. **\n",
+ "2022-09-29 12:21:01,825 [INFO] >>>> loading model paper03/models/min_001\n",
+ "2022-09-29 12:21:01,827 [INFO] ** TORCH CUDA version installed and working. **\n",
+ "2022-09-29 12:21:01,828 [INFO] >>>> using GPU\n",
+ "2022-09-29 12:21:02,053 [INFO] >>>> model diam_mean = 30.000 (ROIs rescaled to this size during training)\n",
+ "2022-09-29 12:21:02,054 [INFO] >>>> model diam_labels = 14.897 (mean diameter of training ROIs)\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 48/48 [00:17<00:00, 2.82it/s]\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "