Cellpose_2D_run_on_local_environment.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Cellpose_2D_run_on_local_environment.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.6.4"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/pr4deepr/cellpose-colab/blob/main/Cellpose_2D_run_on_local_environment.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0YVrnjRozAGg"
      },
      "source": [
        "## **ZeroCostDL4Mic notebook modified to run on a local cellpose environment on a PC**\n",
        "\n",
        "\n",
        "\n",
        "The original ZeroCostDL4Mic Cellpose 2D notebook has been modified to run locally on a PC where cellpose environment is configured with jupyter installed.\n",
        "\n",
        "Credit for the original code and software should go to the authors of [Cellpose and Omnipose](https://github.com/MouseLand/cellpose) and [ZeroCostDL4Mic team](https://github.com/HenriquesLab/ZeroCostDL4Mic/wiki)\n",
        "\n",
        "Pradeep Rajasekhar \n",
        "\n",
        "Walter and Eliza Hall Institute of Medical Research, Melbourne, Australia"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V9zNGvape2-I"
      },
      "source": [
        "# **Cellpose - Omnipose (2D)**\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n4yWFoJNnoin"
      },
      "source": [
        "# **1. Setting up cellpose to run locally.**\n",
        "---\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **1.1 SETUP JUPYTER AND COLAB (ONLY NEED TO DO THIS FIRST TIME )**\n",
        "---\n",
        "<font size = 4> \n",
        "\n",
        "Setup jupyter so that you can connect to your local environment. We use the jupyter_http_over_ws for colab to connect to local environment\n",
        "\n",
        "* Make sure you've installed and configured [cellpose environment](https://github.com/MouseLand/cellpose#local-installation) on your computer. \n",
        "* Ensure you have activated the cellpose environment \n",
        "* Download this yml file: https://github.com/pr4deepr/cellpose-colab/blob/main/cellpose_colab_local.yml\n",
        "* On the top right of the file, right click the `Raw` button and select `Save Link As`.\n",
        "\n",
        "![image.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAPwAAADfCAYAAADSk77/AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAACCwSURBVHhe7Z0LfFTVncd/PCKvAHEUjQIjttF+DKJRF6syumF3rQGB7S4PtV0xWLWrTT8L292SdrdbtbvdxE+7ZNsUW20lxE+3PmD7WUSIrZ/C1mCtjzY+SHdLXHAAS7UMAcI7JHv+5557587MncnMZCZkcn9fODPnde+59879nfM/Zyb/O+z8yRf3ghDiC4abd0KID0g6wpdecAGuumYmpkydipKSs03u4Gfv3t14+ef/bVJDhxMnTuLo0SM4ePCgySEkczwFHwxehFvmzsOBAxG8t2sn3u34rSkZ/Hzmvgew+lsNJjU0GDZsGEaOHIExo8dIAh9++CG6u0+ZUkLSJ8Gkl5H9llvn4dChTvzsxRcKSuxDld7eXpw61Y1Dhw+r91OYNGmSKSEkMxIEf9XVM9XIvh8/fWGzySGDiWPHjkkPgIkTJ5ocQtInQfBTglMR3rnLpMhg5NjxYxg7dpxJEZI+CXP4v//SP+IHj602qcJjKM7h45E5/bnnnoNdu4ZGxzw1eBFu//SdJuXNoc5ObNv2Et55602TM/SJvy65uAYUfIEyadK5aQtebpy5t87HhJISk5Meu8Pv4Z2338q7yD57fw0OHjqIsGovGTMuv0K/f+/RRv0+kMh1u+OOv9Lxt995Cy+/9HMdzzfx1yUX14Dfw/sAGSXkxtnW+vOMgjBr1o36PZ+IoOSmFiElCyK0TDusXCBtivAEOcZZoZtww4036XS+ib8uubgGI4onnP2giWtmqZP59RuvmVThcfU1M/HaL18xqaHLuHFj0alMvHSQz1RGarlpZNRON8jNdcmlH8PLRvz5Qo7PbjMZUy+6SH9dnO9jceMW+4/XP4s3Xn9VL5ZeesnHdDwfSHt/cvMn9DUR5JwlLkHigp2eMeOKjI+DIzwhHthil3mzIB2O5F1+xZXaWsoXMkf3srY8g6qbKTkR/Onht+Ffm3+ItU9GQ8NDd+PK4mGmxuBm/I1fxJpnnsVTz1rhRz/8Pr5yR3lM2cPV43Wa9A9ZT5B1Ign26DnYcIt90/PPaXGJKW/nbVOWUr6Q9RLbhO8rZLO2ktMR/tA7/4n6R76OR9e9jZEX/yluv7PClBQGu7Z8HV/752/gv/eOxvR5d2LOWYXRYRUSsngopnu2I1S+iRe7HKtMhwR3Xj6RNRexJJIhnWa2nWVOBd/bvR/tb2/Hyxu2Ym9XL8aNLawfh5w82oHtb/4S//X2HqDoLIzlhCfniKDshajB9hWbl9i98vLNxAkTMSHFD6suV3N3Oa5syOktPWzkOSifMR03Lr0VZcXHsPM3Vs949W1fwbd/YMz9tY/ja5/7U4waXoWvPPZDfOsLlbrOOQu+gh80r8XKT47V6aUPPonvPrhIxweSYePK8eczpuD0vp341cnEvyuav+LbeOIpY/4/HTX9P/PI0/jREw/j/i9/z5oWqPj86/4Kj6yx6q791grMHKmr4vIFK7HK5P+o6d/x+Sr+VPZMM1jELsgaQdAs0CVDjikbcir4CZf/JVZ+8cu4NzQGLz/xJazaFNH5B373Cn709c/hrjvvxRO/OoHgx29GVdEL+N89J1BcehnOV5bzTdMvRu+JXkz+6LXoUZ3BRRcOx94dW/X2A8Wltz6hBPgQKi86jDdefAn7ekyBi/ff+Qka/24Zblt8Dzb/3yhc9ifzUDHCKhs2/kKMefNf8eXHXkdX8WX41Ocr0P6dL+CbL4QxonQmbvmLcRj7RzW4/1OXYPfTD+h9PLVjPG64/fP44yL/Th9ESHKDy9ddyUJfAugPg0ns6TBRHZv93Xym5FTwB9sex+e/3oL3h12AK2+4AaNNfmfX+bjpnn/B4499B8uuKdF/DCK0vvN/6DkviOsmXo+PTT6EX/9qN4onX44ZM8tw/qg/4N1tB3S9TLD3nRm9erudP5M5/ENY87MjuOrTK1BTNcYps3d7csxHsaT223iy+XFUfXSUuoJFEK1KnZ5DO/HSC7vQoTqL8KEeHNv1KppeD+MXa17Hvt6RKFJzhI//8eUIDJ+AmXd/B0898zhuv7IYGDMW55pOIx8cOnAAM6bP8BRSqiAik21zidfnI3PkieMn4IZZNyYNUv7UD580W+QWWVeQ83SL/b6//lxM3kByUHUycr7JEJM/W3I+Sz30myex9sV3MfZj8/CZ0Cg1Wt+K5X99Cy48sBH/+DfV+OLGd42AerG35X/x+97z8ZE5V+JcvI9Xnn8XnYELMHP6NIze144Xd3XLHZJRsG6ozIJ1PD04cWSHmsO/jee/LwIdjYuvuM4pk/fRV9yPz37qj9Dz1mp87q7F+MGrh6xyvQ+rjvyz9tmD4wc/dLVhyiWc2IG1n16CO5YstsJtX8D642JOxB5XqiD7SZfWbS/p+tffEMooTJ4yFc+rGz6X2NfAjczlv/fd7+Abdf+SNEh5PoQ3Xc2H5TzlGmmxq7nzvZ99QItdzv1MjOydBzv1p5wM6ZCy/WowZ4K3Pkgr/punn8eOw6Nw1fxqXDRsLEYU9eLQwfdxePQMfHLGZPT0qJtftjnyEt57fzg+EroCo/e049VwO/YdOh/XXFWC3+98RXUG9u2dQTDHkUmQl56eXhSp0fuyGdMx5+6rMKnnJHbveMUpk3ojx4/FKHXshz98Dz0X/BlmXTLWKZN23fFeFe+Rd1da4r9+M4wjIz6Cqi/MRelY4NwrPokv/e2dpl76QeNV4BG2K0E9pgTzTSUcO8gqudzUdlriIjx3HQl75Ib32Ge2wfp8vMvsMGVqEPfed79nWa7DFCV2OR4xkaXde4zYN23amPNz7zM4dzEwXnU8yRbu5HgPZekIJUeCdx2weh/W8wp+/NJOnJ50LZbc2ootr+9H6cdX4N8fuRcj9++zhKFqD8Pv8MbO32P06CLs3P4ihvf+Ev8T7sbosSew+612vedM0TdTpqhtepWQp970RXyp9h9w503j8e4Lq7HqP486ZSLeQ9t+jNaOY7hs0SqsfujPcCR8WOVbE32rjj3pl5vaGtHttHRyso8DL67Cms0dKCr/NB55/D/wzRW3YGxn5qOI7Ntc8YzDeDVCyAj+9va3nDyJl18+Q5e56+Y86GuS+tjlLzaL1c3uVZbrMFUJXgR+j+pgFt/+KR3frMQuI7tX/bwG9SJh93u71HuP+oxm4bpZytoK3eiEqrnzVE3L7M+G3P3xjP4grQOPRc7CieWd6rvvw2Nn4A8sBhr5a7n33gubVGZcN2sWrr8+hO3vvI1Dh62RYsL4iZiuBP+LX7TilW3bdF4+WHzbHfp9957kxz51SlCPtqu+UW9y8scnquZi6tSp2N7+jhrRw9ize7cpObOI0G9QnbJ4OFL/FfJuLey+rKYfv2jN7jcMuRG8GW2iWCL3yss3dy67B9//7qMmNXQ599yAMkOzE/yyz9ynTUYv9u7ZjfXPPGVSueey6TNw3XXXJ21fOKzM1Z+8sFkfi79J/ObGaN9+yZj+C95D7DLY95zu1mbuCNMrDR+e3QES4kdOnz6N7u4edCsdnTzVraaDpkDRH9HndJVe5md6rnrqpBI6UDRiuBY6xU5IZowYMQKjRhVh3NgxKJlQjLOKRurBVdCvsaNs2iQIvrPzAMrKLjWpPnCP7iJ21RuprgkjldApcUJyg8zdx48bg/HFY5SuXKLPQvUJgpdFi+C0i00qNW6xS1y+ehrB0ZyQvHBWURGKVHDkrkWXmegTBC/OL84+O4Cbb5ljcrxxf+UkMRndR+Z0gkAIiad47GgP6zl90Sd4vOnq6sIfPvhA/wLpggsvVCP2cEQi1m/iHVy9ihVVou85resSQvKHmPeyTtatps72op39tV06JKzS2+hHTV0tj5qagolxj5rSP/pQoUeJXL+f7sHm/1qvOoY/mBqEkHxx/MQJHDl6wla6JfU0RZ9U8KkRwZuoiZ89sZgjPCEDQHd3NzoPH40Z2dMd5bNTqEcXQbETMjCMHGkcK7hJc9jOQqXWIp2FiulEmq0RQnJErPbcr6nIUPCJO+y7CUJIPvDWXmpFZj7Cu/dHtRNyZslQjxkIXu3N+m+wYzGZhJCBQGvOpUH7NSY/kX6ttCXfLSFkIMhUg2kKXu3W+u+JexmPEJJ/kmlO50ZfEhh21bU3plRr9Ce0Fjqtgv4n7yb0nDxmahBC8s3ws8boX905Qb6DN3E3CekJZ5+fUvCxiNj1f4Od7sXUyReYvPyysGEjaiqKTQroamvE/OXrTCq/SNvVaNLtrWzeilCkr7ZrsXZrOdorlyKV75b09jV4cV8XMjDs3vs7I3JJWaKORq20Fxkv2kWJSQwIWuxlHWisrMRsE1oDNdjSXGtqDBz1SytzdoPncl85pbb5jFxbkikuLepocm1mvGgXvysZ3QeERQ2oroigZd5yrDdZQv3SRrQFQlg18A+pIeSMEq+9dJTYr1X6gdK6piyA4nC7h2m8DvsixQiUSVxM6GaslJFp61Ydnmtw9QSq03jO5G+ReiZbLIfnGmqxaqMp29iAhaYsGWKGrzWDnxWXts32nqOiKfcoy3xffdTzOs+Y0XqRPle7TV0/vh2pXxUEglVqHxutDtV1XZ08h7Lo9XNdW5JnMtRg+qv0Z5iFpQF0RTpMKpaOSBcCpfbdF0RVebsx+VsQqai2bky5qauBJns60AJUuW7y4oqQFKoyZTGgAgvi7v++CFbJXN1qMxwMxYlBBFYFtKjypXUmLzmp9xXFs16y8+yIoCtQanVki0JKnuqalVsnuTCkesv4a1u3VG0bBsItaj/zsEJmHJLn7DeCCtdFil6/SjS2BWKuLTkTeGs2oxH+TMp+/b4Iiq1h3JPIPnsOHEaLI6o6bGhTY09IKUEshOIK1NgjlIxetgAUXW1N1k2tLIbWDncHkh7hFnthrg7tYdviEAIIbaxBoLUSd/WtdU3yfcXiWS/Zea5rRYeSuVwKEXiktRURc/5qE3S0prOGYFkGqa+f+qyWt6oOqJyj/BmgL42mL/gzPcjLCOV5Ey2C1wDliR6tzAglIW49IJ9k2oH0C8/zlI7M6vzKAhG016lOIiIdQC3KAx3oW+8idqvj0vtsbFM2AhmUpNBqlnP4M6D+dcvRGlbmesz82roJKyKtzugiJr2xVBW1WFBhRi/dYYSSmsf5I4LWeY3oKKuJXU/IFynOc70oPrAAaiKgLYP69gjKqkMIdLSm0fGVIVDc5XSsYiVEvxxVJn1ZyPlcFjaEEPRcbyH5Iz1N9m/RboCRr68aO8qi5urWGpR1NMbNi9W8s9wul3mzmX+qDmO+zDtr7LK4Bb28sg4rjOjTWRDsF6nOU8z6gDLF2831qmtHRKk2qTmvysPOop01PbL3W62sBPcI3xUJoNq0p786TWOtggw8af7wRlWx/htMTOdZBVOnDMwPb1Ijq9Z9/9CFkEJn957f6d/XRH98I1gR/Rp9iaGgRnhCSP/IXvD26G4nCCEDiKU528JOl+xNev3f5PT2KpP+QitOCMk7u/e8r9Rrm/Dq3WXCR6NW2g1NekJ8RBqCj47rhJBCIlG7HOEJ8REUPCE+goInxEdQ8IT4CAqeEB9BwRPiIyh4QnwEBU+Ij6DgCfERBSd4cThp/513zN96DwCWs0urPXEi2Xfb8ue6fTt0TG9fgxE5v3hnlumQ3nUhuaegBE+/9IONOtxlO7gkBUHhCH4R/dIT0l8KR/D0Sx9Dynpe55mNX/o+65vrrTNN3HXtnfoK91TsuYZSk2vw9HcvbbqmC1LH9bmsbM5mKkEKRvD0S59IXv3SZ1pf47r2LWEEQ0agSqw1Yp2ZY2pSewvq+goRsr405ngbO1BWI52IuyNXAi9Xn79xsy2dS3kwAsczOUmbghE8/dInkle/9Fn5sXdde3GAWRxQe7A66+ixGr/1Jh5fZnsnlr6lvl11GrqTMa60xemu7HBRKQL0ipsVhWPS0y99+uTEL31//dhHKQu4HVpngPaaqz5zJXDVw6BeHZBYGboDsj3vkowoHMHTL3165NAvff/82EfRI7Vt3iu033oTF8stWBVdT5EpSSgYNp60xXIJoHxBQFkY6jPUbrZDqC6TDkjXJhlSOIJX0C99GuTSL32m9ZNRtxQtkeg0o1pNFmyTXsr0s+hM2ZaaMnQ0Rk186WSCysKwmrSsjuIIzflsScOJpe2o0u0wx0oMPieWslIsC1muOSEhQ5D0nFgKTkRTUCM8IaR/UPCE+IghZtIT4g9o0hNC+oSCJ8RHUPCE+AgKnhAfQcET4iMoeEJ8BAVPiI+g4AnxERQ8IT6CgifER1DwhPiIghM8/dJbZLNNPtGfS7wjzDyQXTtxDjF9TEH98Yx82Novvcs1ldz4VWhJyzlkf5H2q9GUgQ95n/59vjimFGeWA/CZpIcIXjx7Dh0f+kP/j2cW0S89If2lcARPv/QxpL1NknOWbaw8FRL8BNplygxuUNfS3p/sS9VdKWa1XW4ur3UNVUK7nQ6KD+2Y8uTt2cSZ3bIfVz3bD73Tjs5Lcd6ue2BLc8hk2rjP0bWdbOPsw6qT6Iu/sCkYwdMvfWq8t1Fi0D7iJF+CNbUQoehpkM4zfgLNtVjZLE5B7bIm1dHa7iYNxRUIqWmN3q4NqIi/UHVLtU96y3OuZUKnai9Kdn7ok/rmrwqgzT7v9gAqHMe58lkYX4jmeFrU0elOJCtf/IVFwQiefulT47lNbTmCYbdHX2ERSgPua2T8xGsX4FLWhbYNdtk6rGh13E1adLWhyaxhiFdbRyBJSdVeLNn4ofc8b3Gc73yeiroNaOsycSVj1RU45yDUWzdJ5r77C5DCMenplz5jUllF3igxFJ/BJ7rkyA+9nHd25M4X/2ClcARPv/QZo/3K21MaBzGd1XV0mdTaT7weQWWUDCLkHKe6vqE4kz5jUrUXj7Tffz/01nkviA4OtQtcJn2H+kQqUO36LFZaN4nu/HPli3+wUjiCV9AvfYYknLO1aGd9syGLala+/qrTXMP6pbLuoY5Tl1UrIcSZ9OmgR+rool2q9uLJiR96dd5Nbl/35RGXSS+fhfscrfUF56vWXPniH6TQLz1JSea/PSADAZ1YkjzgmhKRIQEFT2KQEd02dWOmRGRIQL/0hBQgNOkJIX1CwRPiIyh4QnwEBU+Ij6DgCfERFDwhPoKCJ8RHUPCE+Iic/vDmnPPOs9KEkLyx/4MPsv7hDX9pR0gBwl/aEUL6hIInxEdQ8IT4CAqeEB+Rs0W7a66+0ooTQvLOG796U6nXXqRT766VOldU4UQ0HOEJ8REUPCE+goInxEdQ8IT4CAqeEB9BwRPiIyh4QnxEYQn+gQY8/cyzJjTgfpOdF+Y+iCfWPIg5djyN9uZ8tQlPfHWuSREy+CgcwYvoKoGtSxbjNglNnZj0gCnLN5sexN1LluNRkySkUCkcwU8rwbi9v42KTonw4dUmTghJi8IR/OrfYu/k2d4mc4yp34R/kiqSZ5vkmgfwb45ZPhf/tMau/yz+rS9LwWXeW2b7A9HtY9qIIvWcY4lBjiPadvR83Ple2xHSfwpoDr8af7tkDXZNW6ZFESPS1cstM1/C1k5Mv1kVrv4JtmMaZjp6uhSTtYUgYl8CPGvqL9kCVGa2HjBu+rVm+zWqjemQ5mJQnU31tF1oWlKNhzeZPAc5j2jbndM/odue89VrUbJ9jcn32o6Q/lNYi3bYhIeX2SJ1i941YldOBkrOU6PuJry2S80EjOLvv6QE238qc4BpKBk3DtOr7dF0NiajBJMyGFGPbH/GCFLaOIIS98bTluDpmZ1oWvYgNpuseKzRP7btzR92qo5kWd/WBiH9oMAEb6NGya17MfkSUYeIfRlKXjOjZtN2HLEqYbNW/LWYo0zymSW78Jozau6NLv7leEQdp8KRcSWqW/FGxF5d8qppV1kI9sEaK2XHJdIR0KQn+aFwBK/MZPfoN2dSiYnJiH0EnUrbwpyZ07ToNJsexGud03DzzdPQ+Zo94u5C55HJmJmnr8+O7HoGd29VBkiSr/GmlYzDEftg516Lac7BWjy6YjFUn2VZJu51iPj4KpoCJHMKaNHuJ+icaZvhz1pz5BVioq/GT5VAbBN9cUmnM8ILj+7oxOTJndjhrOjLtEDmztZagA5JFt6yRkZrLfrEBcFH9cGatheXqM7Hyo+a+da5PfsQJ/Ek99ABBiEFCB1gEEL6hIInxEdQ8IT4CAqeEB9BwRPiIyh4QnwEHyZJSAHCh0kSQvqEgifER1DwhPgICp4QH0HBE+IjKHhCfAQFT4iPKDzBL2rAc1u3YosJa2tNfh5Z2LARzzUscuJbmvtudGVzDo+ttjlFm7VYu7UZK02KkFQUlOC12GoCaK2sxGwT2ksbsNCUDwTrl8/D7KV1JkVIYVFAgq/FgooIWiqXot7kCPXLl2O9iRNCUlM4gq8tRzDcHiP2eMSMtk39LRujI79lktdi1Ua73JjAYiq76lnm8Uassqx3T+LN+5j9xuwrinVcHma3tG8fb0y7i1zHqvJLTbZBWzpmu+caXIUy3VHHsMrdXswUKHoM7n3Y0wWvPDK0KBjBLywNoCvSYVKJiKiq0OKY+o0dZahx3bTFFSGgyZS1BVAlZXUb0IYyhGyh6U6lFSvWmXQaRPfbqPZVgQVxOhERWccVa5lo6pY6xzu7JYIKs/HK5hpUROxzaQLKgjpfozqJGm3pWNs1qeN3lcoBIdAuZao9EXu1HJ7dBqzzdqwlk6+nKF55ZKhRMIJfvy+C4kCZScWzCKWBMFpcN+n65a0IB8udEa2rrckRcrRsHVpVH1JmFL+yPIhwe2Y3enS/sq8uBEqj5kEgtBE1gdYU4nGN5FVKtoFSZSHEn8s6rGgNm7jV8YVbop2HPhcT13S1YYO9aVkAxaoDqLFHbaeNDkS6gqiKsUi88shQo3BM+o4IulwCzhUimEhZSN3ktSgPuMSSK7TAvBCx1yDQakbUxjZ06fwyBIp1xJOyVIVehKNWjw7zZM1DdSLzVFwZD9WO+e6VR4YahSP4dcvRGo4fgZRomiW9Dvsiqsx1ky5sCMXM+Yu1qC1iy+rQHlFmfUM5Ah2tOV0AjLTOs6YWnqOmCLsL9ixlYagMlpTV8ajzDJl1An2OoajRXt8eRjAU3Z8+FxNPQHeSoeRrEuqazq9sibGEPPPIkKFwBK+oX2rm5raJulVNUDdYq/T1S9UcOlBl8reipqwDjS5TuisSsEYuj7L6djV/rgBal2cweU8T+RrPOub4xcA6bGgDKmqsY6oOKHGakvqlLYhU1JhzUefY4TLa1by/JRI106uVKR5j0rsR8cragGlDgrXgKIuTdl4V1PxBdX5eeWSo4QsHGLJwVo0mzE8maFktL2/nQhUpGOgAI2sskznTxTpCChF/C15/D16Dso5G3EW9Ex9An3aEFCA06QkhfULBE+IjKHhCfAQFT4iPoOAJ8REUPCE+goInxEdQ8IT4iJz+8Oac886z0oSQvLH/gw+y/uENf2lHSAHCX9oRQvqEgifER1DwhPgICp4QH0HBE+IjKHhCfAQFT4iPoOAJ8REUPCE+goInxEdQ8IT4CAqeEB9RQIKXhy+mfnY7ISQ1HOGzQJ5Fv5YPVyUFCAVPiI8ooL+HF5O+GmiahxXrrFG2vL0FqKqyHpcsz0HXD4OUejWoMI9RD7dU4q46eTJqOazq1sOVu9oaXQ+X9NrGiks7ZhO9TWugxkmrDDTq560TMrD48u/hg1VKxJWVmK2fZx6y5ve1C1ARUeLX+VHhqtqokifEmvqRimqzHmB3JFZ9KUNVs342ujx1tgrRfUkHIY+sbglbncJsip0UGAUt+LDzDPM6tIeLEShT0Y4IuoJV5jnobsJocR4HbT2bvSwkdcoQKC52PUNdLIYAShctQkjtr20DnzJJhg5Dbw6/bjnmq9G4CdVawOktrqnOwIziVpBpg3QEEexL8kh5QgqRIbtot375PMxWtnew3FZ8EE4UtVhQoYyBVlFzByJdQYQSLAKxGtQ0oJnL8WToMPQEr5/5bszzKrjMeDXxLo+a7WixFv+USYAV82ROXxPdbmMDFqqS+qWNaAtUOfn2NKG+XXUkVdF6hBQKPvFaa1bpK+05PyGFDb3WEkL6hIInxEfwQRSEFCADb9LH7ocQcqbIQIs06QnxEf0SvDYlCCFnjEw1mKMRfhhOnjpp4oSQfGJpLbvBNjeCV22fOnHKJAgh+URrLUvjOg3Bp7fnE6e6TYwQkk/S11qidrMc4RN3dPTYMfT2Rr+4I4Tknp6e0zh69JhJuUlvYM7RHB7o7elBJNJpUoSQfCAa6+3tManM6bfgnVXCYcP0KH/82HErTQjJKcePH8ex4ye01oRsviXrn+A92vtg/35EDkgvRPOekFwgWjqgNPXBH/abHBcZaj6Nn9YK+ne09g9pDSal86NxO1U0cgTGjBmt3otw1llnoahopBQSQtLg1KlunDx5Eqe6u3FMWc6nuk8bbatXI/LoT2oFJ2LFoi8x5FbwghnZnVdXkTsRk02Iz4mVpitlhOvkGHNeODOCF3SZO23FnVdXUSxJCwjxEYnC1BjROqVJxS64y2JeYkhf8OYttnI033pzlcaIXlAxVzEhJAkusTqSjRe7FTG4y+wXIZpvk7Ov5ZIRcyiSSDwGQojg6MMSST6kkqbg+2jaqzimR7KrmJiU2ZnuQIgf8Lr3tV6sYMccXFpy8MiKxbtCmia9YJnkiZVNjvMWV0Mnk25FCFEkkWdCQSpzXtCp6EsCmZn0ah/eu1GYAtcSg4VOJm4lOe5AiJ/o+/5XuXEFiWKPRWcnKbPJYIQXVFXrfxwmx1WQMNILOssjnxBiUIr1EG3MQOpEYyvqVPTFk6wW7ZLuzlWQMNILkuWaqxBCBKMHe20rDm+xx5IkO4HMR3jzlriRKycmmlgzKRlUJaRgSVediuRij92JTjlZsWVuMhS8oKqbLRI3dOXERBNrEkJSk5HYBR2JLYsnu+/hk+7TVSBRk5QDt/8RQpKToBWXjiySaChNaWUh+OiBeLcRlytJV5b7hOx/hPgRtwbsfw5xurFI1IrOcbITy+PJwqS3MZupt+Q7SFKSZYuEDGmS6tW7IFOxC/0QvGA2VW+pd0KFE5I5yUWcjdiF7ObwDqYh9Sax5M3apclrEEKE1FpxSpxi73rJ6OcIbxMd6W04phOSO2JknaXYhX6O8DamYXlLjBJCsiRGRwmJTAH+H/BgU6mGpddYAAAAAElFTkSuQmCC)\n",
        "\n",
        "This should allow you to save the file as a yml file. If it saves as a text file for some reason, just rename the file extension for .txt to .yml. \n",
        "\n",
        "* Once you've downloaded the file, now you can use this yml file to upgrade your environment and install necessary packages to run colab with jupyter locally. If your environment name is cellpose and you've stored the yml file in E: drive, run this command to update your environment:\n",
        "\n",
        "`conda env update --name cellpose --file E:\\cellpose_colab_local.yml --prune`\n",
        "\n",
        "Essentially, we are telling conda to update the environment *cellpose* using the file *cellpose_colab_local.yml*\n",
        "\n",
        "*   Once you've done that, enter this command in your command line to enable the jupyter_http_over_ws extension:\n",
        "\n",
        "`jupyter serverextension enable --py jupyter_http_over_ws`\n",
        "\n",
        "\n",
        "This needs to be done only once.\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Create a jupyter environment by entering this:\n",
        "\n",
        "`jupyter notebook --NotebookApp.allow_origin=\"https://colab.research.google.com\" --port=8888 --NotebookApp.port_retries=0`\n",
        "\n",
        "\n",
        "This is how you start a jupyter instance everytime you want to run this notebook and connect to your environment.\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "This will activate a jupyter environment. Once the server has started, it will print a message with the initial backend URL used for authentication. Make a copy of this URL as you'll need to provide this in the next step. \n",
        "\n",
        "It will be something like:\n",
        "\n",
        "http://localhost:8888/?token=1b45abcdefghiklmnowhyoureadingthishaha\n",
        "\n",
        "In Colaboratory, click the \"Connect\" button and select \"Connect to local runtime...\". Enter the URL from the previous step in the dialog that appears and click the \"Connect\" button. After this, you should now be connected to your local runtime.\n",
        "\n",
        "This information is taken from: https://research.google.com/colaboratory/local-runtimes.html#:~:text=In%20Colaboratory%2C%20click%20the%20%22Connect,connected%20to%20your%20local%20runtime.\n"
      ],
      "metadata": {
        "id": "aLrSw7eG8l52"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wgeU4cC55Sej"
      },
      "source": [
        "## **1.2. Load key dependencies** \n",
        "---\n",
        "<font size = 4> "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kkbr0GAA5ZAQ",
        "cellView": "form"
      },
      "source": [
        "#@markdown ##Load key dependencies & extra setup for running locally\n",
        "\n",
        "Notebook_version = '1.15.1'\n",
        "Network = 'Cellpose'\n",
        "\n",
        "from builtins import any as b_any\n",
        "\n",
        "### Local setup\n",
        "from pathlib import Path\n",
        "home_dir = str(Path.home())\n",
        "\n",
        "import sys\n",
        "#logging gets printed in console\n",
        "import logging\n",
        "#logging.basicConfig(stream=sys.stdout, level=logging.INFO)\n",
        "#####\n",
        "import torch\n",
        "\n",
        "%load_ext memory_profiler\n",
        "\n",
        "def get_requirements_path():\n",
        "    # Store requirements file in 'contents' directory\n",
        "    current_dir = os.getcwd()\n",
        "    dir_count = current_dir.count('/') - 1\n",
        "    path = '../' * (dir_count) + 'requirements.txt'\n",
        "    return path\n",
        "\n",
        "def filter_files(file_list, filter_list):\n",
        "    filtered_list = []\n",
        "    for fname in file_list:\n",
        "        if b_any(fname.split('==')[0] in s for s in filter_list):\n",
        "            filtered_list.append(fname)\n",
        "    return filtered_list\n",
        "\n",
        "def build_requirements_file(before, after):\n",
        "    path = get_requirements_path()\n",
        "\n",
        "    # Exporting requirements.txt for local run\n",
        "    !pip freeze > $path\n",
        "\n",
        "    # Get minimum requirements file\n",
        "    df = pd.read_csv(path, delimiter = \"\\n\")\n",
        "    mod_list = [m.split('.')[0] for m in after if not m in before]\n",
        "    req_list_temp = df.values.tolist()\n",
        "    req_list = [x[0] for x in req_list_temp]\n",
        "\n",
        "    # Replace with package name and handle cases where import name is different to module name\n",
        "    mod_name_list = [['sklearn', 'scikit-learn'], ['skimage', 'scikit-image']]\n",
        "    mod_replace_list = [[x[1] for x in mod_name_list] if s in [x[0] for x in mod_name_list] else s for s in mod_list]\n",
        "    filtered_list = filter_files(req_list, mod_replace_list)\n",
        "\n",
        "    file=open(path,'w')\n",
        "    for item in filtered_list:\n",
        "        file.writelines(item + '\\n')\n",
        "\n",
        "    file.close()\n",
        "\n",
        "import sys\n",
        "before = [str(m) for m in sys.modules]\n",
        "\n",
        "\n",
        "\n",
        "# ------- Variable specific to Cellpose -------\n",
        "\n",
        "from urllib.parse import urlparse\n",
        "%matplotlib inline\n",
        "from cellpose import models\n",
        "use_GPU = torch.cuda.is_available()\n",
        "\n",
        "#use_GPU = models.use_gpu()\n",
        "\n",
        "#import mxnet as mx\n",
        "\n",
        "from skimage.util import img_as_ubyte\n",
        "import cv2\n",
        "from cellpose import plot\n",
        "from ipywidgets import interact, interact_manual\n",
        "from zipfile import ZIP_DEFLATED\n",
        "\n",
        "\n",
        "# For sliders and dropdown menu and progress bar\n",
        "from ipywidgets import interact\n",
        "import ipywidgets as widgets\n",
        "\n",
        "\n",
        "# ------- Common variable to all ZeroCostDL4Mic notebooks -------\n",
        "import numpy as np\n",
        "from matplotlib import pyplot as plt\n",
        "import urllib\n",
        "import os, random\n",
        "import shutil \n",
        "import zipfile\n",
        "from tifffile import imread, imsave\n",
        "import time\n",
        "#import sys\n",
        "import wget\n",
        "from pathlib import Path\n",
        "import pandas as pd\n",
        "import csv\n",
        "from glob import glob\n",
        "from scipy import signal\n",
        "from scipy import ndimage\n",
        "from skimage import io\n",
        "from sklearn.linear_model import LinearRegression\n",
        "from skimage.util import img_as_uint\n",
        "import matplotlib as mpl\n",
        "from skimage.metrics import structural_similarity\n",
        "from skimage.metrics import peak_signal_noise_ratio as psnr\n",
        "from astropy.visualization import simple_norm\n",
        "from skimage import img_as_float32\n",
        "from skimage.util import img_as_ubyte\n",
        "from tqdm import tqdm \n",
        "from fpdf import FPDF, HTMLMixin\n",
        "from datetime import datetime\n",
        "import subprocess\n",
        "from pip._internal.operations.freeze import freeze\n",
        "\n",
        "# Colors for the warning messages\n",
        "class bcolors:\n",
        "  WARNING = '\\033[31m'\n",
        "\n",
        "W  = '\\033[0m'  # white (normal)\n",
        "R  = '\\033[31m' # red\n",
        "\n",
        "#Disable some of the tensorflow warnings\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "print(\"Libraries installed\")\n",
        "\n",
        "# Check if this is the latest version of the notebook\n",
        "All_notebook_versions = pd.read_csv(\"https://raw.githubusercontent.com/HenriquesLab/ZeroCostDL4Mic/master/Colab_notebooks/Latest_Notebook_versions.csv\", dtype=str)\n",
        "print('Notebook version: '+Notebook_version)\n",
        "Latest_Notebook_version = All_notebook_versions[All_notebook_versions[\"Notebook\"] == Network]['Version'].iloc[0]\n",
        "print('Latest notebook version: '+Latest_Notebook_version)\n",
        "if Notebook_version == Latest_Notebook_version:\n",
        "  print(\"This notebook is up-to-date.\")\n",
        "else:\n",
        "  print(bcolors.WARNING +\"A new version of this notebook has been released. We recommend that you download it at https://github.com/HenriquesLab/ZeroCostDL4Mic/wiki\")\n",
        "\n",
        "\n",
        "!pip freeze > requirements.txt\n",
        "\n",
        "#Create a pdf document with training summary\n",
        "\n",
        "def pdf_export(trained = False, augmentation = False, pretrained_model = False):\n",
        "    # save FPDF() class into a  \n",
        "    # variable pdf \n",
        "    #from datetime import datetime\n",
        "\n",
        "    class MyFPDF(FPDF, HTMLMixin):\n",
        "        pass\n",
        "\n",
        "    pdf = MyFPDF()\n",
        "    pdf.add_page()\n",
        "    pdf.set_right_margin(-1)\n",
        "    pdf.set_font(\"Arial\", size = 11, style='B') \n",
        "\n",
        "    \n",
        "    day = datetime.now()\n",
        "    datetime_str = str(day)[0:10]\n",
        "\n",
        "    Header = 'Training report for '+Network+' model ('+model_name+')\\nDate: '+datetime_str\n",
        "    pdf.multi_cell(180, 5, txt = Header, align = 'L') \n",
        "\n",
        "    # add another cell \n",
        "    if trained:\n",
        "      training_time = \"Training time: \"+str(hour)+ \"hour(s) \"+str(mins)+\"min(s) \"+str(round(sec))+\"sec(s)\"\n",
        "      pdf.cell(190, 5, txt = training_time, ln = 1, align='L')\n",
        "    pdf.ln(1)\n",
        "\n",
        "    Header_2 = 'Information for your materials and methods:'\n",
        "    pdf.cell(190, 5, txt=Header_2, ln=1, align='L')\n",
        "\n",
        "    all_packages = ''\n",
        "    for requirement in freeze(local_only=True):\n",
        "      all_packages = all_packages+requirement+', '\n",
        "    #print(all_packages)\n",
        "\n",
        "    #Main Packages\n",
        "    main_packages = ''\n",
        "    version_numbers = []\n",
        "    for name in ['tensorflow','numpy','Keras','csbdeep']:\n",
        "      find_name=all_packages.find(name)\n",
        "      main_packages = main_packages+all_packages[find_name:all_packages.find(',',find_name)]+', '\n",
        "      #Version numbers only here:\n",
        "      version_numbers.append(all_packages[find_name+len(name)+2:all_packages.find(',',find_name)])\n",
        "\n",
        "    cuda_version = subprocess.run('nvcc --version',stdout=subprocess.PIPE, shell=True)\n",
        "    cuda_version = cuda_version.stdout.decode('utf-8')\n",
        "    cuda_version = cuda_version[cuda_version.find(', V')+3:-1]\n",
        "    gpu_name = subprocess.run('nvidia-smi',stdout=subprocess.PIPE, shell=True)\n",
        "    gpu_name = gpu_name.stdout.decode('utf-8')\n",
        "    gpu_name = gpu_name[gpu_name.find('Tesla'):gpu_name.find('Tesla')+10]\n",
        "    #print(cuda_version[cuda_version.find(', V')+3:-1])\n",
        "    #print(gpu_name)\n",
        "\n",
        "    shape = io.imread(Training_source+'/'+os.listdir(Training_source)[1]).shape\n",
        "    dataset_size = len(os.listdir(Training_source))\n",
        "\n",
        "    text = 'The '+Network+' model was trained from scratch for '+str(number_of_epochs)+' epochs on '+str(dataset_size)+' paired image patches (image dimensions: '+str(shape)+', with a batch size of '+str(batch_size)+', using the '+Network+' ZeroCostDL4Mic notebook (v '+Notebook_version[0]+') (von Chamier & Laine et al., 2020). Key python packages used include tensorflow (v '+version_numbers[0]+'), Keras (v '+version_numbers[2]+'), numpy (v '+version_numbers[1]+'), cuda (v '+cuda_version+'). The training was accelerated using a '+gpu_name+'GPU.'\n",
        "\n",
        "\n",
        "    if pretrained_model:\n",
        "      text = 'The '+Network+' model was trained for '+str(number_of_epochs)+' epochs on '+str(dataset_size)+' paired image patches (image dimensions: '+str(shape)+', with a batch size of '+str(batch_size)+', using the '+Network+' ZeroCostDL4Mic notebook (v '+Notebook_version[0]+') (von Chamier & Laine et al., 2020). The model was re-trained from a pretrained model. Key python packages used include tensorflow (v '+version_numbers[0]+'), Keras (v '+version_numbers[2]+'), numpy (v '+version_numbers[1]+'), cuda (v '+cuda_version+'). The training was accelerated using a '+gpu_name+'GPU.'\n",
        "\n",
        "    # print(text)\n",
        "\n",
        "    pdf.set_font('')\n",
        "    pdf.set_font_size(10.)\n",
        "    pdf.multi_cell(190, 5, txt = text, align='L')\n",
        "    pdf.set_font('')\n",
        "    pdf.set_font('Arial', size = 10, style = 'B')\n",
        "    pdf.ln(1)\n",
        "    pdf.cell(28, 5, txt='Augmentation: ', ln=0)\n",
        "    pdf.set_font('')\n",
        "    if augmentation:\n",
        "      aug_text = 'The dataset was augmented by a factor of '+str(Multiply_dataset_by)\n",
        "\n",
        "    else:\n",
        "      aug_text = 'No augmentation was used for training.'\n",
        "    pdf.multi_cell(190, 5, txt=aug_text, align='L')\n",
        "    pdf.set_font('Arial', size = 11, style = 'B')\n",
        "    pdf.ln(1)\n",
        "    pdf.cell(180, 5, txt = 'Parameters', align='L', ln=1)\n",
        "    pdf.set_font('')\n",
        "    pdf.set_font_size(10.)\n",
        "    if Use_Default_Advanced_Parameters:\n",
        "      pdf.cell(200, 5, txt='Default Advanced Parameters were enabled')\n",
        "    pdf.cell(200, 5, txt='The following parameters were used for training:')\n",
        "    pdf.ln(1)\n",
        "    html = \"\"\" \n",
        "    <table width=40% style=\"margin-left:0px;\">\n",
        "      <tr>\n",
        "        <th width = 50% align=\"left\">Parameter</th>\n",
        "        <th width = 50% align=\"left\">Value</th>\n",
        "      </tr>\n",
        "      <tr>\n",
        "        <td width = 50%>number_of_epochs</td>\n",
        "        <td width = 50%>{0}</td>\n",
        "      </tr>\n",
        "      <tr>\n",
        "        <td width = 50%>batch_size</td>\n",
        "        <td width = 50%>{1}</td>\n",
        "      </tr>\n",
        "      <tr>\n",
        "        <td width = 50%>percentage_validation</td>\n",
        "        <td width = 50%>{2}</td>\n",
        "      </tr>\n",
        "      <tr>\n",
        "        <td width = 50%>initial_learning_rate</td>\n",
        "        <td width = 50%>{3}</td>\n",
        "      </tr>\n",
        "    </table>\n",
        "    \"\"\".format(number_of_epochs,batch_size,percentage_validation,initial_learning_rate)\n",
        "    pdf.write_html(html)\n",
        "\n",
        "    #pdf.multi_cell(190, 5, txt = text_2, align='L')\n",
        "    pdf.set_font(\"Arial\", size = 11, style='B')\n",
        "    pdf.ln(1)\n",
        "    pdf.cell(190, 5, txt = 'Training Dataset', align='L', ln=1)\n",
        "    pdf.set_font('')\n",
        "    pdf.set_font('Arial', size = 10, style = 'B')\n",
        "    pdf.cell(29, 5, txt= 'Training_source:', align = 'L', ln=0)\n",
        "    pdf.set_font('')\n",
        "    pdf.multi_cell(170, 5, txt = Training_source, align = 'L')\n",
        "    pdf.set_font('')\n",
        "    pdf.set_font('Arial', size = 10, style = 'B')\n",
        "    pdf.cell(27, 5, txt= 'Training_target:', align = 'L', ln=0)\n",
        "    pdf.set_font('')\n",
        "    pdf.multi_cell(170, 5, txt = Training_target, align = 'L')\n",
        "    #pdf.cell(190, 5, txt=aug_text, align='L', ln=1)\n",
        "    pdf.ln(1)\n",
        "    pdf.set_font('')\n",
        "    pdf.set_font('Arial', size = 10, style = 'B')\n",
        "    pdf.cell(22, 5, txt= 'Model Path:', align = 'L', ln=0)\n",
        "    pdf.set_font('')\n",
        "    pdf.multi_cell(170, 5, txt = model_path+'/'+model_name, align = 'L')\n",
        "    pdf.ln(1)\n",
        "    pdf.cell(60, 5, txt = 'Example Training pair', ln=1)\n",
        "    pdf.ln(1)\n",
        "    exp_size = io.imread(home_dir+'/TrainingDataExample_Cellpose2D.png').shape\n",
        "    pdf.image(home_dir+'/TrainingDataExample_Cellpose2D.png', x = 11, y = None, w = round(exp_size[1]/8), h = round(exp_size[0]/8))\n",
        "    pdf.ln(1)\n",
        "    ref_1 = 'References:\\n - ZeroCostDL4Mic: von Chamier, Lucas & Laine, Romain, et al. \"ZeroCostDL4Mic: an open platform to simplify access and use of Deep-Learning in Microscopy.\" BioRxiv (2020).'\n",
        "    pdf.multi_cell(190, 5, txt = ref_1, align='L')\n",
        "    ref_2 = '- Cellpose: Stringer, Carsen, et al. \"Cellpose: a generalist algorithm for cellular segmentation.\" Nature Methods 18, pages100-106(2021).'\n",
        "    pdf.multi_cell(190, 5, txt = ref_2, align='L')\n",
        "    pdf.ln(3)\n",
        "    reminder = 'Important:\\nRemember to perform the quality control step on all newly trained models\\nPlease consider depositing your training dataset on Zenodo'\n",
        "    pdf.set_font('Arial', size = 11, style='B')\n",
        "    pdf.multi_cell(190, 5, txt=reminder, align='C')\n",
        "\n",
        "    pdf.output(model_path+model_name+model_name+\"_training_report.pdf\")\n",
        "    # pdf.output(Saving_path+'/train_folder/models/'+model_name+\"_training_report.pdf\")\n",
        "\n",
        "  \n",
        "\n",
        "#Make a pdf summary of the QC results\n",
        "\n",
        "def qc_pdf_export():\n",
        "  class MyFPDF(FPDF, HTMLMixin):\n",
        "    pass\n",
        "\n",
        "  pdf = MyFPDF()\n",
        "  pdf.add_page()\n",
        "  pdf.set_right_margin(-1)\n",
        "  pdf.set_font(\"Arial\", size = 11, style='B') \n",
        "\n",
        "  Network = 'Cellpose 2D'\n",
        "  #model_name = os.path.basename(full_QC_model_path)\n",
        "  day = datetime.now()\n",
        "  datetime_str = str(day)[0:10]\n",
        "\n",
        "  Header = 'Quality Control report for '+Network+' model ('+QC_model_name+')\\nDate: '+datetime_str\n",
        "  pdf.multi_cell(180, 5, txt = Header, align = 'L') \n",
        "\n",
        "  all_packages = ''\n",
        "  for requirement in freeze(local_only=True):\n",
        "    all_packages = all_packages+requirement+', '\n",
        "\n",
        "  pdf.set_font('')\n",
        "  pdf.set_font('Arial', size = 11, style = 'B')\n",
        "  pdf.ln(2)\n",
        "  pdf.cell(190, 5, txt = 'Development of Training Losses', ln=1, align='L')\n",
        "  pdf.ln(1)\n",
        "  exp_size = io.imread(full_QC_model_path+'Quality Control/QC_example_data.png').shape\n",
        "  if os.path.exists(full_QC_model_path+'Quality Control/lossCurvePlots.png'):\n",
        "    pdf.image(full_QC_model_path+'Quality Control/lossCurvePlots.png', x = 11, y = None, w = round(exp_size[1]/10), h = round(exp_size[0]/13))\n",
        "  else:\n",
        "    pdf.set_font('')\n",
        "    pdf.set_font('Arial', size=10)\n",
        "    pdf.multi_cell(190, 5, txt='If you would like to see the evolution of the loss function during training please play the first cell of the QC section in the notebook.', align='L')\n",
        "  pdf.ln(2)\n",
        "  pdf.set_font('')\n",
        "  pdf.set_font('Arial', size = 10, style = 'B')\n",
        "  pdf.ln(3)\n",
        "  pdf.cell(80, 5, txt = 'Example Quality Control Visualisation', ln=1)\n",
        "  pdf.ln(1)\n",
        "  exp_size = io.imread(full_QC_model_path+'Quality Control/QC_example_data.png').shape\n",
        "  pdf.image(full_QC_model_path+'Quality Control/QC_example_data.png', x = 16, y = None, w = round(exp_size[1]/10), h = round(exp_size[0]/10))\n",
        "  pdf.ln(1)\n",
        "  pdf.set_font('')\n",
        "  pdf.set_font('Arial', size = 11, style = 'B')\n",
        "  pdf.ln(1)\n",
        "  pdf.cell(180, 5, txt = 'Quality Control Metrics', align='L', ln=1)\n",
        "  pdf.set_font('')\n",
        "  pdf.set_font_size(10.)\n",
        "\n",
        "  pdf.ln(1)\n",
        "  html = \"\"\"\n",
        "  <body>\n",
        "  <font size=\"7\" face=\"Courier New\" >\n",
        "  <table width=94% style=\"margin-left:0px;\">\"\"\"\n",
        "  with open(full_QC_model_path+'Quality Control/Quality_Control for '+QC_model_name+'.csv', 'r') as csvfile:\n",
        "    metrics = csv.reader(csvfile)\n",
        "    header = next(metrics)\n",
        "    image = header[0]\n",
        "    mSSIM_PvsGT = header[1]\n",
        "    mSSIM_SvsGT = header[2]\n",
        "    NRMSE_PvsGT = header[3]\n",
        "    NRMSE_SvsGT = header[4]\n",
        "    PSNR_PvsGT = header[5]\n",
        "    PSNR_SvsGT = header[6]\n",
        "    header = \"\"\"\n",
        "    <tr>\n",
        "      <th width = 10% align=\"left\">{0}</th>\n",
        "      <th width = 15% align=\"left\">{1}</th>\n",
        "      <th width = 15% align=\"center\">{2}</th>\n",
        "      <th width = 15% align=\"left\">{3}</th>\n",
        "      <th width = 15% align=\"center\">{4}</th>\n",
        "      <th width = 15% align=\"left\">{5}</th>\n",
        "      <th width = 15% align=\"center\">{6}</th>\n",
        "    </tr>\"\"\".format(image,mSSIM_PvsGT,mSSIM_SvsGT,NRMSE_PvsGT,NRMSE_SvsGT,PSNR_PvsGT,PSNR_SvsGT)\n",
        "    html = html+header\n",
        "    for row in metrics:\n",
        "      image = row[0]\n",
        "      mSSIM_PvsGT = row[1]\n",
        "      mSSIM_SvsGT = row[2]\n",
        "      NRMSE_PvsGT = row[3]\n",
        "      NRMSE_SvsGT = row[4]\n",
        "      PSNR_PvsGT = row[5]\n",
        "      PSNR_SvsGT = row[6]\n",
        "      cells = \"\"\"\n",
        "        <tr>\n",
        "          <td width = 10% align=\"left\">{0}</td>\n",
        "          <td width = 15% align=\"center\">{1}</td>\n",
        "          <td width = 15% align=\"center\">{2}</td>\n",
        "          <td width = 15% align=\"center\">{3}</td>\n",
        "          <td width = 15% align=\"center\">{4}</td>\n",
        "          <td width = 15% align=\"center\">{5}</td>\n",
        "          <td width = 15% align=\"center\">{6}</td>\n",
        "        </tr>\"\"\".format(image,str(round(float(mSSIM_PvsGT),3)),str(round(float(mSSIM_SvsGT),3)),str(round(float(NRMSE_PvsGT),3)),str(round(float(NRMSE_SvsGT),3)),str(round(float(PSNR_PvsGT),3)),str(round(float(PSNR_SvsGT),3)))\n",
        "      html = html+cells\n",
        "    html = html+\"\"\"</body></table>\"\"\"\n",
        "\n",
        "  pdf.write_html(html)\n",
        "\n",
        "  pdf.ln(1)\n",
        "  pdf.set_font('')\n",
        "  pdf.set_font_size(10.)\n",
        "  ref_1 = 'References:\\n - ZeroCostDL4Mic: von Chamier, Lucas & Laine, Romain, et al. \"ZeroCostDL4Mic: an open platform to simplify access and use of Deep-Learning in Microscopy.\" BioRxiv (2020).'\n",
        "  pdf.multi_cell(190, 5, txt = ref_1, align='L')\n",
        "  ref_2 = '- CARE: Weigert, Martin, et al. \"Content-aware image restoration: pushing the limits of fluorescence microscopy.\" Nature methods 15.12 (2018): 1090-1097.'\n",
        "  pdf.multi_cell(190, 5, txt = ref_2, align='L')\n",
        "\n",
        "  pdf.ln(3)\n",
        "  reminder = 'To find the parameters and other information about how this model was trained, go to the training_report.pdf of this model which should be in the folder of the same name.'\n",
        "\n",
        "  pdf.set_font('Arial', size = 11, style='B')\n",
        "  pdf.multi_cell(190, 5, txt=reminder, align='C')\n",
        "\n",
        "  pdf.output(full_QC_model_path+'Quality Control/'+QC_model_name+'_QC_report.pdf')\n",
        "\n",
        "\n",
        "# Build requirements file for local run\n",
        "after = [str(m) for m in sys.modules]\n",
        "build_requirements_file(before, after)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b4-r1gE7Iamv"
      },
      "source": [
        "# **2. Initialise the Colab session**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BDhmUgqCStlm",
        "cellView": "form"
      },
      "source": [
        "#@markdown ##Run this cell to check if you have GPU access\n",
        "\n",
        "#%tensorflow_version 1.x\n",
        "\n",
        "!nvidia-smi"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2UfUWjI_askO"
      },
      "source": [
        "# **3. Select your parameters and paths**\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZyMxrSWvavVL"
      },
      "source": [
        "## **3.1. Setting main training parameters**\n",
        "---\n",
        "<font size = 4> "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5MlTyQVXXvDx"
      },
      "source": [
        "<font size = 5> **Paths for training, predictions and results**\n",
        "\n",
        "\n",
        "<font size = 4>**`Training_source:`, `Training_target`:** These are the paths to your folders containing the Training_source (images of cells) and Training_target (masks) training data respecively. 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",
        "<font size = 4>**`model_name`:** Use only my_model -style, not my-model (Use \"_\" not \"-\"). Do not use spaces in the name. Avoid using the name of an existing model (saved in the same folder) as it will be overwritten.\n",
        "\n",
        "<font size = 4>**`model_path`**: Enter the path where your model will be saved once trained (for instance your result folder).\n",
        "\n",
        "\n",
        "<font size = 5>**Training parameters**\n",
        "\n",
        "<font size = 4>**`number_of_epochs`:** Input how many epochs (rounds) the network will be trained. Preliminary results can already be observed after a 100 epochs, but a full training should run for up to 500-1000 epochs. Evaluate the performance after training (see 5.). **Default value: 500**\n",
        "\n",
        "<font size = 5>**Advanced Parameters - experienced users only**\n",
        "\n",
        "<font size =4>**`batch_size:`** This parameter defines the number of patches seen in each training step. Reducing or increasing the **batch size** may slow or speed up your training, respectively, and can influence network performance. **Default value: 8**\n",
        "\n",
        "\n",
        "<font size = 4>**`percentage_validation`:**  Input the percentage of your training dataset you want to use to validate the network during the training. **Default value: 10** \n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2HkNZ16BdfJv",
        "cellView": "form"
      },
      "source": [
        "#@markdown ###Path to training images:\n",
        "\n",
        "Training_source = \"D:\\\\cellpose_test\\\\data\\\\train\\\\images\" #@param {type:\"string\"}\n",
        "Training_target = \"D:\\\\cellpose_test\\\\data\\\\train\\\\masks\" #@param {type:\"string\"}\n",
        "\n",
        "#Define where the patch file will be saved\n",
        "base = home_dir\n",
        "#\"/content\"\n",
        "\n",
        "# model name and path\n",
        "#@markdown ###Name of the model and path to model folder:\n",
        "model_name = \"model_test\" #@param {type:\"string\"}\n",
        "model_path = \"D:\\\\cellpose_test\" #@param {type:\"string\"}\n",
        "\n",
        "# other parameters for training.\n",
        "#@markdown ###Training Parameters:\n",
        "#@markdown Number of epochs:\n",
        "number_of_epochs =  2#@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 = True #@param {type:\"boolean\"}\n",
        "#@markdown ###If not, please input:\n",
        "batch_size =  8#@param {type:\"number\"}\n",
        "initial_learning_rate = 0.0002 #@param {type:\"number\"}\n",
        "percentage_validation =  10#@param {type:\"number\"}\n",
        "\n",
        "if (Use_Default_Advanced_Parameters): \n",
        "  print(\"Default advanced parameters enabled\")\n",
        "  batch_size = 8  \n",
        "  initial_learning_rate = 0.0002\n",
        "  percentage_validation = 10\n",
        "\n",
        "#here we check that no model with the same name already exist, if so delete\n",
        "if os.path.exists(model_path+'/'+model_name):\n",
        "  print(bcolors.WARNING +\"!! WARNING: \"+model_name+\" already exists and will be deleted in the following cell !!\")\n",
        "  print(bcolors.WARNING +\"To continue training \"+model_name+\", choose a new model_name here, and load \"+model_name+\" in section 3.3\"+W)\n",
        "  \n",
        "# Here we enable the cyto pre-trained model by default (in case the  cell is not ran)\n",
        "model_to_load = \"cyto\"\n",
        "# Here we disable data augmentation by default (in case the cell is not ran)\n",
        "\n",
        "Use_Data_augmentation = True\n",
        "\n",
        "# This will display a randomly chosen dataset input and output\n",
        "random_choice = random.choice(os.listdir(Training_source))\n",
        "x = io.imread(Training_source+\"/\"+random_choice)\n",
        "norm = simple_norm(x, percent = 99)\n",
        "y = io.imread(Training_target+\"/\"+random_choice)\n",
        "\n",
        "# Find the number of channel in the input image\n",
        "\n",
        "n_channel = 1 if x.ndim == 2 else x.shape[-1]\n",
        "\n",
        "\n",
        "# Here we match the channel to number\n",
        "\n",
        "if Channel_to_use_for_training == \"Grayscale\":\n",
        "  Training_channel = 0\n",
        "\n",
        "  if not n_channel == 1:\n",
        "      print(bcolors.WARNING +\"!! WARNING: your image has more than one channel, choose which channel you want to use for trainning !!\")\n",
        "\n",
        "if Channel_to_use_for_training == \"Blue\":\n",
        "  Training_channel = 3\n",
        "\n",
        "if Channel_to_use_for_training == \"Green\":\n",
        "  Training_channel = 2\n",
        "\n",
        "if Channel_to_use_for_training == \"Red\":\n",
        "  Training_channel = 1\n",
        "\n",
        "\n",
        "if Second_training_channel == \"Blue\":\n",
        "  Second_training_channel = 3\n",
        "\n",
        "if Second_training_channel == \"Green\":\n",
        "  Second_training_channel = 2\n",
        "\n",
        "if Second_training_channel == \"Red\":\n",
        "  Second_training_channel = 1\n",
        "\n",
        "if Second_training_channel == \"None\":\n",
        "  Second_training_channel = 0\n",
        "\n",
        "\n",
        "if n_channel ==1:\n",
        "\n",
        "  f=plt.figure(figsize=(16,8))\n",
        "  plt.subplot(1,2,1)\n",
        "  plt.imshow(x, norm=norm, cmap='magma', interpolation='nearest')\n",
        "  plt.title('Training source')\n",
        "  plt.axis('off');\n",
        "\n",
        "  plt.subplot(1,2,2)\n",
        "  plt.imshow(y,cmap='nipy_spectral', interpolation='nearest')\n",
        "  plt.title('Training target')\n",
        "  plt.axis('off');\n",
        "\n",
        "  plt.savefig(home_dir+'/TrainingDataExample_Cellpose2D.png',bbox_inches='tight',pad_inches=0)\n",
        "\n",
        "else:\n",
        "\n",
        "  f=plt.figure(figsize=(20,10))\n",
        "  plt.subplot(1,3,1)\n",
        "  plt.imshow(x, interpolation='nearest')\n",
        "  plt.title('Training source')\n",
        "  plt.axis('off');\n",
        "\n",
        "  plt.subplot(1,3,2)\n",
        "  plt.imshow(x[:, :, int(Training_channel-1)],cmap='magma', interpolation='nearest')\n",
        "  plt.title('Channel used for training')\n",
        "  plt.axis('off');\n",
        "\n",
        "  plt.subplot(1,3,3)\n",
        "  plt.imshow(y,cmap='nipy_spectral', interpolation='nearest')\n",
        "  plt.title('Training target')\n",
        "  plt.axis('off');\n",
        "\n",
        "  plt.savefig(home_dir+'/TrainingDataExample_Cellpose2D.png',bbox_inches='tight',pad_inches=0)\n",
        "\n",
        "Use_pretrained_model = False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qEg6ar0PhuDY"
      },
      "source": [
        "## **3.2. Data augmentation**\n",
        "---\n",
        "<font size = 4>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t6q9aqDUhxlw"
      },
      "source": [
        "<font size = 4>Data augmentation can improve training progress by amplifying differences in the dataset. This can be useful if the available dataset is small since, in this case, it is possible that a network could quickly learn every example in the dataset (overfitting), without augmentation. Augmentation is not necessary for training and if your training dataset is large you should disable it.\n",
        "\n",
        "<font size = 4>By default, a x4 data augmentation is enabled in this notebook."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SblwpgmahfBl",
        "cellView": "form"
      },
      "source": [
        "#Data augmentation\n",
        "\n",
        "Use_Data_augmentation = True #@param {type:\"boolean\"}\n",
        "\n",
        "if Use_Data_augmentation:\n",
        "  print(bcolors.WARNING+\"Data augmentation enabled\")\n",
        "  Multiply_dataset_by = 4\n",
        "\n",
        "\n",
        "if not Use_Data_augmentation:\n",
        "  print(bcolors.WARNING+\"Data augmentation disabled\") "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s2NC_-Tuc02W"
      },
      "source": [
        "\n",
        "## **3.3. Using weights from a pre-trained model as initial weights**\n",
        "---\n",
        "<font size = 4>  Here, you can set the path to a pre-trained model from which the weights can be extracted and used as a starting point for this training session. **This pre-trained model needs to be a Cellpose model**. \n",
        "\n",
        "<font size = 4>  You can also use the pretrained models already available in Cellpose: \n",
        "\n",
        "- The cytoplasm model in cellpose is trained on two-channel images, where the first channel is the channel to segment, and the second channel is an optional nuclear channel.\n",
        "\n",
        "- The cytoplasm2 model is an updated cytoplasm model trained with user-submitted images.\n",
        "\n",
        "- The nuclear model in cellpose is trained on two-channel images, where the first channel is the channel to segment, and the second channel is always set to an array of zeros.\n",
        "\n",
        "<font size = 4> This option allows you to perform training over multiple Colab runtimes or to do transfer learning using models trained outside of ZeroCostDL4Mic. **You do not need to run this section if you want to train a network from scratch**.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sLdgQM6Rc7vp",
        "cellView": "form"
      },
      "source": [
        "# @markdown ##Loading weights from a pre-trained network\n",
        "\n",
        "Use_pretrained_model = False #@param {type:\"boolean\"}\n",
        "\n",
        "Pretrained_model = \"Nuclei\" #@param [\"Cytoplasm\",\"Cytoplasm2\", \"Nuclei\", \"Own_model\"]\n",
        "\n",
        "#@markdown ###If using your own model, please provide the path to the model (not the folder):\n",
        "pretrained_model_path = \"\" #@param {type:\"string\"}\n",
        "\n",
        "# --------------------- Check if we load a previously trained model ------------------------\n",
        "\n",
        "if Use_pretrained_model == True :\n",
        "\n",
        "  if Pretrained_model == \"Own_model\":    \n",
        "\n",
        "    model_to_load = pretrained_model_path\n",
        "\n",
        "    print('The model '+ str(model_to_load) + \"will be used as a starting point\")\n",
        "\n",
        "  if Pretrained_model == \"Cytoplasm\":\n",
        "    model_to_load = \"cyto\"\n",
        "    print('The model Cytoplasm will be used as a starting point')\n",
        "\n",
        "  if Pretrained_model == \"Cytoplasm2\":\n",
        "    model_to_load = \"cyto2\"\n",
        "    print('The model Cytoplasm2 (cyto2) will be used as a starting point')\n",
        "\n",
        "  if Pretrained_model == \"Nuclei\":\n",
        "    model_to_load = \"nuclei\"\n",
        "    print('The model nuclei will be used as a starting point')\n",
        "\n",
        "else:\n",
        "  model_to_load = None\n",
        "  print(bcolors.WARNING+'No pretrained network will be used.')\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qeYZ7PeValfs"
      },
      "source": [
        "#**4. Train the network**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown ##Create the model and dataset objects\n",
        "\n",
        "\n",
        "# Here we check that the model destination folder is empty\n",
        "if os.path.exists(model_path+os.sep+model_name):\n",
        "  print(bcolors.WARNING +\"!! WARNING: Model folder already exists and has been removed !!\" + W)\n",
        "  shutil.rmtree(model_path+os.sep+model_name)\n",
        "\n",
        "os.makedirs(model_path+os.sep+model_name)\n",
        "\n",
        "\n",
        "#To use cellpose to work we need to organise the data in a way the network can understand\n",
        "\n",
        "# Here we count the number of files in the training target folder\n",
        "Filelist = os.listdir(Training_target)\n",
        "number_files = len(Filelist)\n",
        "\n",
        "# Here we count the number of file to use for validation\n",
        "Image_for_validation =  int((number_files)*(percentage_validation/100))\n",
        "if Image_for_validation <=0:\n",
        "  Image_for_validation =1\n",
        "Saving_path= home_dir+os.sep+model_name\n",
        "#Saving_path= \"/content/\"+model_name\n",
        "\n",
        "if os.path.exists(Saving_path):\n",
        "  shutil.rmtree(Saving_path)\n",
        "os.makedirs(Saving_path)\n",
        "\n",
        "train_folder = Saving_path+os.sep+\"train_folder\"\n",
        "os.makedirs(train_folder)\n",
        "\n",
        "test_folder = Saving_path+os.sep+\"test_folder\"\n",
        "os.makedirs(test_folder)\n",
        "\n",
        "index = 0\n",
        "\n",
        "print('Copying training source data...')\n",
        "for f in tqdm(os.listdir(Training_source)):  \n",
        "    short_name = os.path.splitext(f)\n",
        "\n",
        "    if index < Image_for_validation:\n",
        "      shutil.copyfile(Training_source+os.sep+f, test_folder+os.sep+short_name[0]+\"_img.tif\")\n",
        "      shutil.copyfile(Training_target+os.sep+f, test_folder+os.sep+short_name[0]+\"_masks.tif\")    \n",
        "    else:\n",
        "      shutil.copyfile(Training_source+os.sep+f, train_folder+os.sep+short_name[0]+\"_img.tif\")\n",
        "      shutil.copyfile(Training_target+os.sep+f, train_folder+os.sep+short_name[0]+\"_masks.tif\")    \n",
        "    index = index +1\n",
        "    \n",
        "print(\"Done\")\n",
        "\n",
        "pdf_export(augmentation = Use_Data_augmentation, pretrained_model = Use_pretrained_model)\n",
        "\n",
        "\n",
        "\"\"\"\n",
        "\n",
        "#Read images and masks into imgs & masks array\n",
        "#Could lead to memory issues if not sufficient memory\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "from skimage.io import imread\n",
        "imgs = []\n",
        "masks = []\n",
        "\n",
        "for img in os.listdir(Training_source):\n",
        "  imgs.append(imread(Training_source+os.sep+img))\n",
        "  masks.append(imread(Training_target+os.sep+img))\n",
        "\n",
        "\"\"\"\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "GQ-vCUPbKVR3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jRorFe296LgI"
      },
      "source": [
        "## **4.2. Start Training**\n",
        "---\n",
        "\n",
        "<font size = 4>When playing the cell below you should see updates after each epoch (round). Network training can take some time.\n",
        "\n",
        "<font size = 4>* **CRITICAL NOTE:** Training is currently done using Torch.\n",
        "\n",
        "<font size = 4>* **CRITICAL NOTE:** Google Colab has a time limit for processing (to prevent using GPU power for datamining). Training time must be less than 12 hours! If training takes longer than 12 hours, please decrease the number of epochs or number of patches. Another way circumvent this is to save the parameters of the model after training and start training again from this point.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YXUnd3awi6K3",
        "cellView": "form"
      },
      "source": [
        "#@markdown ##Start training\n",
        "\"\"\"\n",
        "import cellpose.models\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "import cellpose.models\n",
        "\n",
        "#use_gpu = False\n",
        "\n",
        "cellpose_class = cellpose.models.CellposeModel(gpu=use_gpu)\n",
        "\n",
        "cellpose_class.train(train_data=imgs,train_labels=masks,pretrained_model=model_to_load,channels=[Training_channel,Second_training_channel],n_epochs=number_of_epochs,\\\n",
        "                                    learning_rate=initial_learning_rate,batch_size=batch_size,save_path=model_save,netstr=model_name)\n",
        "\n",
        "\"\"\"\n",
        "\n",
        "start = time.time()\n",
        "if not Use_Data_augmentation:\n",
        "  #!python -m cellpose --train --use_gpu --mxnet --fast_mode --dir \"$train_folder\" --test_dir \"$test_folder\" --pretrained_model $model_to_load --chan $Training_channel --chan2 $Second_training_channel --n_epochs $number_of_epochs --learning_rate $initial_learning_rate --batch_size $batch_size --img_filter img --mask_filter masks\n",
        "  !python -m cellpose --train --use_gpu  --dir \"$train_folder\" --test_dir \"$test_folder\" --pretrained_model $model_to_load --chan $Training_channel --chan2 $Second_training_channel --n_epochs $number_of_epochs --learning_rate $initial_learning_rate --batch_size $batch_size --img_filter img --mask_filter masks --verbose\n",
        "\n",
        "else:\n",
        "  #!python -m cellpose --train --use_gpu --mxnet --dir \"$train_folder\" --test_dir \"$test_folder\" --pretrained_model $model_to_load --chan $Training_channel --chan2 $Second_training_channel  --n_epochs $number_of_epochs --learning_rate $initial_learning_rate --batch_size $batch_size --img_filter img --mask_filter masks\n",
        "  !python -m cellpose --train --use_gpu --fast_mode --dir \"$train_folder\" --test_dir \"$test_folder\" --pretrained_model $model_to_load --chan $Training_channel --chan2 $Second_training_channel --n_epochs $number_of_epochs --learning_rate $initial_learning_rate --batch_size $batch_size --img_filter img --mask_filter masks --verbose\n",
        "\n",
        "\n",
        "#Settings\n",
        "# --check_mkl', action='store_true', help='check if mkl working'\n",
        "\n",
        "#'--mkldnn', action='store_true', help='for mxnet, force MXNET_SUBGRAPH_BACKEND = \"MKLDNN\"')\n",
        "\n",
        "#'--train', action='store_true', help='train network using images in dir')\n",
        "#'--dir', required=False, help='folder containing data to run or train on')\n",
        "#  '--mxnet', action='store_true', help='use mxnet')\n",
        "#  '--img_filter', required=False, default=[], type=str, help='end string for images to run on')\n",
        "#  '--use_gpu', action='store_true', help='use gpu if mxnet with cuda installed')\n",
        "#   '--fast_mode', action='store_true', help=\"make code run faster by turning off 4 network averaging\")\n",
        "#  '--resample', action='store_true', help=\"run dynamics on full image (slower for images with large diameters)\")\n",
        "# '--no_interp', action='store_true', help='do not interpolate when running dynamics (was default)')\n",
        "#  '--do_3D', action='store_true',  help='process images as 3D stacks of images (nplanes x nchan x Ly x Lx')\n",
        "   \n",
        "# settings for training\n",
        "#    parser.add_argument('--train_size', action='store_true', help='train size network at end of training')\n",
        "#    parser.add_argument('--mask_filter', required=False, default='_masks', type=str, help='end string for masks to run on')\n",
        "#    parser.add_argument('--test_dir', required=False, default=[], type=str, help='folder containing test data (optional)')\n",
        "#    parser.add_argument('--learning_rate', required=False, default=0.2, type=float, help='learning rate')\n",
        "#    parser.add_argument('--n_epochs', required=False, default=500, type=int, help='number of epochs')\n",
        "#    parser.add_argument('--batch_size', required=False, default=8, type=int, help='batch size')\n",
        "#    parser.add_argument('--residual_on', required=False, default=1, type=int, help='use residual connections')\n",
        "#    parser.add_argument('--style_on', required=False, default=1, type=int, help='use style vector')\n",
        "#    parser.add_argument('--concatenation', required=False, dfault=0, type=int, help='concatenate downsampled layers with upsampled layers (off by default which means they are added)')\n",
        "\n",
        "#Here we copy the model to the result folder after training\n",
        "\n",
        "if os.path.exists(model_path+'/'+model_name):\n",
        "  print(bcolors.WARNING +\"!! WARNING: Model folder already exists and has been removed !!\" + W)\n",
        "  shutil.rmtree(model_path+'/'+model_name)\n",
        "try:\n",
        "  destination = shutil.copytree(Saving_path+\"/train_folder/models\", model_path+\"/\"+model_name)\n",
        "except FileNotFoundError:\n",
        "  print(\"Training may have encountered an error as no training model folder found at :\"+ Saving_path)\n",
        "\n",
        "# Displaying the time elapsed for training\n",
        "dt = time.time() - start\n",
        "mins, sec = divmod(dt, 60) \n",
        "hour, mins = divmod(mins, 60) \n",
        "print(\"Time elapsed:\",hour, \"hour(s)\",mins,\"min(s)\",round(sec),\"sec(s)\")\n",
        "print(\"Your model is also available here: \"+str(model_path+\"/\"+model_name))\n",
        "\n",
        "\n",
        "pdf_export(trained=True, augmentation = Use_Data_augmentation, pretrained_model = Use_pretrained_model)\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qvbm9EJGaXr9"
      },
      "source": [
        "# **5. Evaluate your model**\n",
        "---\n",
        "\n",
        "<font size = 4>This section allows the user to perform important quality checks on the validity and generalisability of the trained model.  \n",
        "\n",
        "\n",
        "<font size = 4>**We highly recommend to perform quality control on all newly trained models.**\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IeiU6D2jGDh4",
        "cellView": "form"
      },
      "source": [
        "# model name and path\n",
        "#@markdown ###Do you want to assess the model you just trained ?\n",
        "Use_the_current_trained_model = True #@param {type:\"boolean\"}\n",
        "\n",
        "#@markdown ###If not, indicate which model you want to assess:\n",
        "\n",
        "QC_model = \"Cytoplasm\" #@param [\"Cytoplasm\",\"Cytoplasm2\", \"Cytoplasm2_Omnipose\", \"Bacteria_Omnipose\", \"Nuclei\", \"Own_model\"]\n",
        "\n",
        "#@markdown ###If using your own model, please provide the path to the model (not the folder):\n",
        "\n",
        "QC_model_path = \"\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown ###If using the Cellpose or Omnipose models, please indicate where you want to save the results:\n",
        "Saving_path = \"\" #@param {type:\"string\"}\n",
        "\n",
        "model_save = model_path+os.sep+model_name\n",
        "\n",
        "if Use_the_current_trained_model :\n",
        "\n",
        "  list_files = os.listdir(model_save)\n",
        "  \n",
        "  QC_model_path = model_save+os.sep+list_files[0]\n",
        "  QC_model = \"Own_model\"\n",
        "\n",
        "  model = models.CellposeModel(gpu=True, pretrained_model=QC_model_path, torch=False, diam_mean=30.0, net_avg=True, device=None, residual_on=True, style_on=True, concatenation=False)\n",
        "  #model = models.CellposeModel(gpu=use_gpu, pretrained_model=QC_model_path, torch=True, diam_mean=30.0, net_avg=True, device=None, residual_on=True, style_on=True, concatenation=False)\n",
        "\n",
        "  QC_model_folder = os.path.dirname(QC_model_path)\n",
        "  QC_model_name = os.path.basename(QC_model_folder)\n",
        "  Saving_path = QC_model_folder\n",
        "\n",
        "  print(\"The \"+str(QC_model_name)+\" model will be evaluated\")\n",
        "\n",
        "if not Use_the_current_trained_model:\n",
        "\n",
        "  if QC_model == \"Cytoplasm\":\n",
        "    model = models.Cellpose(gpu=True, model_type=\"cyto\")\n",
        "    QC_model_folder = Saving_path\n",
        "    QC_model_name = \"Cytoplasm\"\n",
        "\n",
        "    print('The model \"Cytoplasm\" will be evaluated')\n",
        "\n",
        "  if QC_model == \"Cytoplasm2\":\n",
        "    model = models.Cellpose(gpu=True, model_type=\"cyto2\")\n",
        "    QC_model_folder = Saving_path\n",
        "    QC_model_name = \"Cytoplasm2\"\n",
        "\n",
        "    print('The model \"Cytoplasm\" will be evaluated')\n",
        "\n",
        "  if QC_model == \"Cytoplasm2_Omnipose\":\n",
        "    model = models.Cellpose(gpu=True, model_type=\"cyto2_omni\")\n",
        "    QC_model_folder = Saving_path\n",
        "    QC_model_name = \"Cytoplasm2_Omnipose\"\n",
        "    print(\"The model Cytoplasm2_Omnipose will be evaluated\") \n",
        "\n",
        "  if QC_model == \"Bacteria_Omnipose\":\n",
        "    model = models.Cellpose(gpu=True, model_type=\"bact_omni\")\n",
        "    QC_model_folder = Saving_path\n",
        "    QC_model_name = \"Bacteria_Omnipose\"\n",
        "    print(\"The model Bacteria_omnipose will be evaluated\")\n",
        "\n",
        "  if QC_model == \"Nuclei\":\n",
        "    model = models.Cellpose(gpu=True, model_type=\"nuclei\")\n",
        "\n",
        "    QC_model_folder = Saving_path\n",
        "    QC_model_name = \"Nuclei\"\n",
        "\n",
        "    print('The model \"Nuclei\" will be evaluated')\n",
        "  \n",
        "  if QC_model == \"Own_model\":\n",
        "\n",
        "    if os.path.exists(QC_model_path):\n",
        "      model = models.CellposeModel(gpu=True, pretrained_model=QC_model_path, torch=True, diam_mean=30.0, net_avg=True, device=None, residual_on=True, style_on=True, concatenation=False)\n",
        "      \n",
        "      QC_model_folder = os.path.dirname(QC_model_path)\n",
        "      Saving_path = QC_model_folder\n",
        "      QC_model_name = os.path.basename(QC_model_folder)\n",
        "      print(\"The \"+str(QC_model_name)+\" model will be evaluated\")\n",
        "      \n",
        "    else:  \n",
        "      print(bcolors.WARNING+'!! WARNING: The chosen model does not exist !!')\n",
        "      print('Please make sure you provide a valid model path and model name before proceeding further.')\n",
        "\n",
        "#Here we make the folder to save the resuslts if it does not exists\n",
        "\n",
        "if not Saving_path == \"\":\n",
        "  if os.path.exists(QC_model_folder) == False:\n",
        "    os.makedirs(QC_model_folder)\n",
        "else:\n",
        "  print(bcolors.WARNING+'!! WARNING: Indicate where you want to save the results')\n",
        "\n",
        "\n",
        "# Here we load the def that perform the QC, code taken from StarDist  https://github.com/mpicbg-csbd/stardist/blob/master/stardist/matching.py\n",
        "\n",
        "import numpy as np\n",
        "from numba import jit\n",
        "from tqdm import tqdm\n",
        "from scipy.optimize import linear_sum_assignment\n",
        "from collections import namedtuple\n",
        "\n",
        "\n",
        "matching_criteria = dict()\n",
        "\n",
        "def label_are_sequential(y):\n",
        "    \"\"\" returns true if y has only sequential labels from 1... \"\"\"\n",
        "    labels = np.unique(y)\n",
        "    return (set(labels)-{0}) == set(range(1,1+labels.max()))\n",
        "\n",
        "\n",
        "def is_array_of_integers(y):\n",
        "    return isinstance(y,np.ndarray) and np.issubdtype(y.dtype, np.integer)\n",
        "\n",
        "\n",
        "def _check_label_array(y, name=None, check_sequential=False):\n",
        "    err = ValueError(\"{label} must be an array of {integers}.\".format(\n",
        "        label = 'labels' if name is None else name,\n",
        "        integers = ('sequential ' if check_sequential else '') + 'non-negative integers',\n",
        "    ))\n",
        "    is_array_of_integers(y) or print(\"An error occured\")\n",
        "    if check_sequential:\n",
        "        label_are_sequential(y) or print(\"An error occured\")\n",
        "    else:\n",
        "        y.min() >= 0 or print(\"An error occured\")\n",
        "    return True\n",
        "\n",
        "\n",
        "def label_overlap(x, y, check=True):\n",
        "    if check:\n",
        "        _check_label_array(x,'x',True)\n",
        "        _check_label_array(y,'y',True)\n",
        "        x.shape == y.shape or _raise(ValueError(\"x and y must have the same shape\"))\n",
        "    return _label_overlap(x, y)\n",
        "\n",
        "@jit(nopython=True)\n",
        "def _label_overlap(x, y):\n",
        "    x = x.ravel()\n",
        "    y = y.ravel()\n",
        "    overlap = np.zeros((1+x.max(),1+y.max()), dtype=np.uint)\n",
        "    for i in range(len(x)):\n",
        "        overlap[x[i],y[i]] += 1\n",
        "    return overlap\n",
        "\n",
        "\n",
        "def intersection_over_union(overlap):\n",
        "    _check_label_array(overlap,'overlap')\n",
        "    if np.sum(overlap) == 0:\n",
        "        return overlap\n",
        "    n_pixels_pred = np.sum(overlap, axis=0, keepdims=True)\n",
        "    n_pixels_true = np.sum(overlap, axis=1, keepdims=True)\n",
        "    return overlap / (n_pixels_pred + n_pixels_true - overlap)\n",
        "\n",
        "matching_criteria['iou'] = intersection_over_union\n",
        "\n",
        "\n",
        "def intersection_over_true(overlap):\n",
        "    _check_label_array(overlap,'overlap')\n",
        "    if np.sum(overlap) == 0:\n",
        "        return overlap\n",
        "    n_pixels_true = np.sum(overlap, axis=1, keepdims=True)\n",
        "    return overlap / n_pixels_true\n",
        "\n",
        "matching_criteria['iot'] = intersection_over_true\n",
        "\n",
        "\n",
        "def intersection_over_pred(overlap):\n",
        "    _check_label_array(overlap,'overlap')\n",
        "    if np.sum(overlap) == 0:\n",
        "        return overlap\n",
        "    n_pixels_pred = np.sum(overlap, axis=0, keepdims=True)\n",
        "    return overlap / n_pixels_pred\n",
        "\n",
        "matching_criteria['iop'] = intersection_over_pred\n",
        "\n",
        "\n",
        "def precision(tp,fp,fn):\n",
        "    return tp/(tp+fp) if tp > 0 else 0\n",
        "def recall(tp,fp,fn):\n",
        "    return tp/(tp+fn) if tp > 0 else 0\n",
        "def accuracy(tp,fp,fn):\n",
        "    # also known as \"average precision\" (?)\n",
        "    # -> https://www.kaggle.com/c/data-science-bowl-2018#evaluation\n",
        "    return tp/(tp+fp+fn) if tp > 0 else 0\n",
        "def f1(tp,fp,fn):\n",
        "    # also known as \"dice coefficient\"\n",
        "    return (2*tp)/(2*tp+fp+fn) if tp > 0 else 0\n",
        "\n",
        "\n",
        "def _safe_divide(x,y):\n",
        "    return x/y if y>0 else 0.0\n",
        "\n",
        "def matching(y_true, y_pred, thresh=0.5, criterion='iou', report_matches=False):\n",
        "    \"\"\"Calculate detection/instance segmentation metrics between ground truth and predicted label images.\n",
        "    Currently, the following metrics are implemented:\n",
        "    'fp', 'tp', 'fn', 'precision', 'recall', 'accuracy', 'f1', 'criterion', 'thresh', 'n_true', 'n_pred', 'mean_true_score', 'mean_matched_score', 'panoptic_quality'\n",
        "    Corresponding objects of y_true and y_pred are counted as true positives (tp), false positives (fp), and false negatives (fn)\n",
        "    whether their intersection over union (IoU) >= thresh (for criterion='iou', which can be changed)\n",
        "    * mean_matched_score is the mean IoUs of matched true positives\n",
        "    * mean_true_score is the mean IoUs of matched true positives but normalized by the total number of GT objects\n",
        "    * panoptic_quality defined as in Eq. 1 of Kirillov et al. \"Panoptic Segmentation\", CVPR 2019\n",
        "    Parameters\n",
        "    ----------\n",
        "    y_true: ndarray\n",
        "        ground truth label image (integer valued)\n",
        "        predicted label image (integer valued)\n",
        "    thresh: float\n",
        "        threshold for matching criterion (default 0.5)\n",
        "    criterion: string\n",
        "        matching criterion (default IoU)\n",
        "    report_matches: bool\n",
        "        if True, additionally calculate matched_pairs and matched_scores (note, that this returns even gt-pred pairs whose scores are below  'thresh')\n",
        "    Returns\n",
        "    -------\n",
        "    Matching object with different metrics as attributes\n",
        "    Examples\n",
        "    --------\n",
        "    >>> y_true = np.zeros((100,100), np.uint16)\n",
        "    >>> y_true[10:20,10:20] = 1\n",
        "    >>> y_pred = np.roll(y_true,5,axis = 0)\n",
        "    >>> stats = matching(y_true, y_pred)\n",
        "    >>> print(stats)\n",
        "    Matching(criterion='iou', thresh=0.5, fp=1, tp=0, fn=1, precision=0, recall=0, accuracy=0, f1=0, n_true=1, n_pred=1, mean_true_score=0.0, mean_matched_score=0.0, panoptic_quality=0.0)\n",
        "    \"\"\"\n",
        "    _check_label_array(y_true,'y_true')\n",
        "    _check_label_array(y_pred,'y_pred')\n",
        "    y_true.shape == y_pred.shape or _raise(ValueError(\"y_true ({y_true.shape}) and y_pred ({y_pred.shape}) have different shapes\".format(y_true=y_true, y_pred=y_pred)))\n",
        "    criterion in matching_criteria or _raise(ValueError(\"Matching criterion '%s' not supported.\" % criterion))\n",
        "    if thresh is None: thresh = 0\n",
        "    thresh = float(thresh) if np.isscalar(thresh) else map(float,thresh)\n",
        "\n",
        "    y_true, _, map_rev_true = relabel_sequential(y_true)\n",
        "    y_pred, _, map_rev_pred = relabel_sequential(y_pred)\n",
        "\n",
        "    overlap = label_overlap(y_true, y_pred, check=False)\n",
        "    scores = matching_criteria[criterion](overlap)\n",
        "    assert 0 <= np.min(scores) <= np.max(scores) <= 1\n",
        "\n",
        "    # ignoring background\n",
        "    scores = scores[1:,1:]\n",
        "    n_true, n_pred = scores.shape\n",
        "    n_matched = min(n_true, n_pred)\n",
        "\n",
        "    def _single(thr):\n",
        "        not_trivial = n_matched > 0 and np.any(scores >= thr)\n",
        "        if not_trivial:\n",
        "            # compute optimal matching with scores as tie-breaker\n",
        "            costs = -(scores >= thr).astype(float) - scores / (2*n_matched)\n",
        "            true_ind, pred_ind = linear_sum_assignment(costs)\n",
        "            assert n_matched == len(true_ind) == len(pred_ind)\n",
        "            match_ok = scores[true_ind,pred_ind] >= thr\n",
        "            tp = np.count_nonzero(match_ok)\n",
        "        else:\n",
        "            tp = 0\n",
        "        fp = n_pred - tp\n",
        "        fn = n_true - tp\n",
        "        # assert tp+fp == n_pred\n",
        "        # assert tp+fn == n_true\n",
        "\n",
        "        # the score sum over all matched objects (tp)\n",
        "        sum_matched_score = np.sum(scores[true_ind,pred_ind][match_ok]) if not_trivial else 0.0\n",
        "\n",
        "        # the score average over all matched objects (tp)\n",
        "        mean_matched_score = _safe_divide(sum_matched_score, tp)\n",
        "        # the score average over all gt/true objects\n",
        "        mean_true_score    = _safe_divide(sum_matched_score, n_true)\n",
        "        panoptic_quality   = _safe_divide(sum_matched_score, tp+fp/2+fn/2)\n",
        "\n",
        "        stats_dict = dict (\n",
        "            criterion          = criterion,\n",
        "            thresh             = thr,\n",
        "            fp                 = fp,\n",
        "            tp                 = tp,\n",
        "            fn                 = fn,\n",
        "            precision          = precision(tp,fp,fn),\n",
        "            recall             = recall(tp,fp,fn),\n",
        "            accuracy           = accuracy(tp,fp,fn),\n",
        "            f1                 = f1(tp,fp,fn),\n",
        "            n_true             = n_true,\n",
        "            n_pred             = n_pred,\n",
        "            mean_true_score    = mean_true_score,\n",
        "            mean_matched_score = mean_matched_score,\n",
        "            panoptic_quality   = panoptic_quality,\n",
        "        )\n",
        "        if bool(report_matches):\n",
        "            if not_trivial:\n",
        "                stats_dict.update (\n",
        "                    # int() to be json serializable\n",
        "                    matched_pairs  = tuple((int(map_rev_true[i]),int(map_rev_pred[j])) for i,j in zip(1+true_ind,1+pred_ind)),\n",
        "                    matched_scores = tuple(scores[true_ind,pred_ind]),\n",
        "                    matched_tps    = tuple(map(int,np.flatnonzero(match_ok))),\n",
        "                )\n",
        "            else:\n",
        "                stats_dict.update (\n",
        "                    matched_pairs  = (),\n",
        "                    matched_scores = (),\n",
        "                    matched_tps    = (),\n",
        "                )\n",
        "        return namedtuple('Matching',stats_dict.keys())(*stats_dict.values())\n",
        "\n",
        "    return _single(thresh) if np.isscalar(thresh) else tuple(map(_single,thresh))\n",
        "\n",
        "\n",
        "\n",
        "def matching_dataset(y_true, y_pred, thresh=0.5, criterion='iou', by_image=False, show_progress=True, parallel=False):\n",
        "    \"\"\"matching metrics for list of images, see `stardist.matching.matching`\n",
        "    \"\"\"\n",
        "    len(y_true) == len(y_pred) or _raise(ValueError(\"y_true and y_pred must have the same length.\"))\n",
        "    return matching_dataset_lazy (\n",
        "        tuple(zip(y_true,y_pred)), thresh=thresh, criterion=criterion, by_image=by_image, show_progress=show_progress, parallel=parallel,\n",
        "    )\n",
        "\n",
        "\n",
        "\n",
        "def matching_dataset_lazy(y_gen, thresh=0.5, criterion='iou', by_image=False, show_progress=True, parallel=False):\n",
        "\n",
        "    expected_keys = set(('fp', 'tp', 'fn', 'precision', 'recall', 'accuracy', 'f1', 'criterion', 'thresh', 'n_true', 'n_pred', 'mean_true_score', 'mean_matched_score', 'panoptic_quality'))\n",
        "\n",
        "    single_thresh = False\n",
        "    if np.isscalar(thresh):\n",
        "        single_thresh = True\n",
        "        thresh = (thresh,)\n",
        "\n",
        "    tqdm_kwargs = {}\n",
        "    tqdm_kwargs['disable'] = not bool(show_progress)\n",
        "    if int(show_progress) > 1:\n",
        "        tqdm_kwargs['total'] = int(show_progress)\n",
        "\n",
        "    # compute matching stats for every pair of label images\n",
        "    if parallel:\n",
        "        from concurrent.futures import ThreadPoolExecutor\n",
        "        fn = lambda pair: matching(*pair, thresh=thresh, criterion=criterion, report_matches=False)\n",
        "        with ThreadPoolExecutor() as pool:\n",
        "            stats_all = tuple(pool.map(fn, tqdm(y_gen,**tqdm_kwargs)))\n",
        "    else:\n",
        "        stats_all = tuple (\n",
        "            matching(y_t, y_p, thresh=thresh, criterion=criterion, report_matches=False)\n",
        "            for y_t,y_p in tqdm(y_gen,**tqdm_kwargs)\n",
        "        )\n",
        "\n",
        "    # accumulate results over all images for each threshold separately\n",
        "    n_images, n_threshs = len(stats_all), len(thresh)\n",
        "    accumulate = [{} for _ in range(n_threshs)]\n",
        "    for stats in stats_all:\n",
        "        for i,s in enumerate(stats):\n",
        "            acc = accumulate[i]\n",
        "            for k,v in s._asdict().items():\n",
        "                if k == 'mean_true_score' and not bool(by_image):\n",
        "                    # convert mean_true_score to \"sum_matched_score\"\n",
        "                    acc[k] = acc.setdefault(k,0) + v * s.n_true\n",
        "                else:\n",
        "                    try:\n",
        "                        acc[k] = acc.setdefault(k,0) + v\n",
        "                    except TypeError:\n",
        "                        pass\n",
        "\n",
        "    # normalize/compute 'precision', 'recall', 'accuracy', 'f1'\n",
        "    for thr,acc in zip(thresh,accumulate):\n",
        "        set(acc.keys()) == expected_keys or _raise(ValueError(\"unexpected keys\"))\n",
        "        acc['criterion'] = criterion\n",
        "        acc['thresh'] = thr\n",
        "        acc['by_image'] = bool(by_image)\n",
        "        if bool(by_image):\n",
        "            for k in ('precision', 'recall', 'accuracy', 'f1', 'mean_true_score', 'mean_matched_score', 'panoptic_quality'):\n",
        "                acc[k] /= n_images\n",
        "        else:\n",
        "            tp, fp, fn, n_true = acc['tp'], acc['fp'], acc['fn'], acc['n_true']\n",
        "            sum_matched_score = acc['mean_true_score']\n",
        "\n",
        "            mean_matched_score = _safe_divide(sum_matched_score, tp)\n",
        "            mean_true_score    = _safe_divide(sum_matched_score, n_true)\n",
        "            panoptic_quality   = _safe_divide(sum_matched_score, tp+fp/2+fn/2)\n",
        "\n",
        "            acc.update(\n",
        "                precision          = precision(tp,fp,fn),\n",
        "                recall             = recall(tp,fp,fn),\n",
        "                accuracy           = accuracy(tp,fp,fn),\n",
        "                f1                 = f1(tp,fp,fn),\n",
        "                mean_true_score    = mean_true_score,\n",
        "                mean_matched_score = mean_matched_score,\n",
        "                panoptic_quality   = panoptic_quality,\n",
        "            )\n",
        "\n",
        "    accumulate = tuple(namedtuple('DatasetMatching',acc.keys())(*acc.values()) for acc in accumulate)\n",
        "    return accumulate[0] if single_thresh else accumulate\n",
        "\n",
        "\n",
        "\n",
        "# copied from scikit-image master for now (remove when part of a release)\n",
        "def relabel_sequential(label_field, offset=1):\n",
        "    \"\"\"Relabel arbitrary labels to {`offset`, ... `offset` + number_of_labels}.\n",
        "    This function also returns the forward map (mapping the original labels to\n",
        "    the reduced labels) and the inverse map (mapping the reduced labels back\n",
        "    to the original ones).\n",
        "    Parameters\n",
        "    ----------\n",
        "    label_field : numpy array of int, arbitrary shape\n",
        "        An array of labels, which must be non-negative integers.\n",
        "    offset : int, optional\n",
        "        The return labels will start at `offset`, which should be\n",
        "        strictly positive.\n",
        "    Returns\n",
        "    -------\n",
        "    relabeled : numpy array of int, same shape as `label_field`\n",
        "        The input label field with labels mapped to\n",
        "        {offset, ..., number_of_labels + offset - 1}.\n",
        "        The data type will be the same as `label_field`, except when\n",
        "        offset + number_of_labels causes overflow of the current data type.\n",
        "    forward_map : numpy array of int, shape ``(label_field.max() + 1,)``\n",
        "        The map from the original label space to the returned label\n",
        "        space. Can be used to re-apply the same mapping. See examples\n",
        "        for usage. The data type will be the same as `relabeled`.\n",
        "    inverse_map : 1D numpy array of int, of length offset + number of labels\n",
        "        The map from the new label space to the original space. This\n",
        "        can be used to reconstruct the original label field from the\n",
        "        relabeled one. The data type will be the same as `relabeled`.\n",
        "    Notes\n",
        "    -----\n",
        "    The label 0 is assumed to denote the background and is never remapped.\n",
        "    The forward map can be extremely big for some inputs, since its\n",
        "    length is given by the maximum of the label field. However, in most\n",
        "    situations, ``label_field.max()`` is much smaller than\n",
        "    ``label_field.size``, and in these cases the forward map is\n",
        "    guaranteed to be smaller than either the input or output images.\n",
        "    Examples\n",
        "    --------\n",
        "    >>> from skimage.segmentation import relabel_sequential\n",
        "    >>> label_field = np.array([1, 1, 5, 5, 8, 99, 42])\n",
        "    >>> relab, fw, inv = relabel_sequential(label_field)\n",
        "    >>> relab\n",
        "    array([1, 1, 2, 2, 3, 5, 4])\n",
        "    >>> fw\n",
        "    array([0, 1, 0, 0, 0, 2, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
        "           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0,\n",
        "           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
        "           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
        "           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5])\n",
        "    >>> inv\n",
        "    array([ 0,  1,  5,  8, 42, 99])\n",
        "    >>> (fw[label_field] == relab).all()\n",
        "    True\n",
        "    >>> (inv[relab] == label_field).all()\n",
        "    True\n",
        "    >>> relab, fw, inv = relabel_sequential(label_field, offset=5)\n",
        "    >>> relab\n",
        "    array([5, 5, 6, 6, 7, 9, 8])\n",
        "    \"\"\"\n",
        "    offset = int(offset)\n",
        "    if offset <= 0:\n",
        "        raise ValueError(\"Offset must be strictly positive.\")\n",
        "    if np.min(label_field) < 0:\n",
        "        raise ValueError(\"Cannot relabel array that contains negative values.\")\n",
        "    max_label = int(label_field.max()) # Ensure max_label is an integer\n",
        "    if not np.issubdtype(label_field.dtype, np.integer):\n",
        "        new_type = np.min_scalar_type(max_label)\n",
        "        label_field = label_field.astype(new_type)\n",
        "    labels = np.unique(label_field)\n",
        "    labels0 = labels[labels != 0]\n",
        "    new_max_label = offset - 1 + len(labels0)\n",
        "    new_labels0 = np.arange(offset, new_max_label + 1)\n",
        "    output_type = label_field.dtype\n",
        "    required_type = np.min_scalar_type(new_max_label)\n",
        "    if np.dtype(required_type).itemsize > np.dtype(label_field.dtype).itemsize:\n",
        "        output_type = required_type\n",
        "    forward_map = np.zeros(max_label + 1, dtype=output_type)\n",
        "    forward_map[labels0] = new_labels0\n",
        "    inverse_map = np.zeros(new_max_label + 1, dtype=output_type)\n",
        "    inverse_map[offset:] = labels0\n",
        "    relabeled = forward_map[label_field]\n",
        "    return relabeled, forward_map, inverse_map\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s2VXDuiOF7r4"
      },
      "source": [
        "## **5.2. Error mapping and quality metrics estimation**\n",
        "---\n",
        "<font size = 4>This section will calculate the Intersection over Union score for all the images provided in the Source_QC_folder and Target_QC_folder ! The result for one of the image will also be displayed.\n",
        "\n",
        "<font size = 4>The **Intersection over Union** (IuO) metric is a method that can be used to quantify the percent overlap between the target mask and your prediction output. **Therefore, the closer to 1, the better the performance.** This metric can be used to assess the quality of your model to accurately predict nuclei. \n",
        "\n",
        "<font size = 4>Here, the IuO is both calculated over the whole image and on a per-object basis. The value displayed below is the IuO value calculated over the entire image. The IuO value calculated on a per-object basis is used to calculate the other metrics displayed.\n",
        "\n",
        "<font size = 4>“n_true” refers to the number of objects present in the ground truth image. “n_pred” refers to the number of objects present in the predicted image. \n",
        "\n",
        "<font size = 4>When a segmented object has an IuO value above 0.5 (compared to the corresponding ground truth), it is then considered a true positive. The number of “**true positives**” is available in the table below. The number of “false positive” is then defined as  “**false positive**” = “n_pred” - “true positive”. The number of “false negative” is defined as “false negative” = “n_true” - “true positive”.\n",
        "\n",
        "<font size = 4>The mean_matched_score is the mean IoUs of matched true positives. The mean_true_score is the mean IoUs of matched true positives but normalized by the total number of ground truth objects. The panoptic_quality is calculated as described by [Kirillov et al. 2019](https://arxiv.org/abs/1801.00868).\n",
        "\n",
        "<font size = 4>For more information about the other metric displayed, please consult the SI of the paper describing ZeroCostDL4Mic.\n",
        "\n",
        "<font size = 4> The results can be found in the \"*Quality Control*\" folder which is located inside your \"model_folder\".\n",
        "\n",
        "<font size = 4>**`model_choice`:** Choose the model to use to make predictions. This model needs to be a Cellpose model. You can also use the pretrained models already available in cellpose: \n",
        "\n",
        "- The cytoplasm model in cellpose is trained on two-channel images, where the first channel is the channel to segment, and the second channel is an optional nuclear channel.\n",
        "- The cytoplasm2 model is an updated cytoplasm model trained with user-submitted images.\n",
        "\n",
        "- The nuclear model in cellpose is trained on two-channel images, where the first channel is the channel to segment, and the second channel is always set to an array of zeros.\n",
        "\n",
        "- The bacteria Omnipose model is an Omnipose model dedicated to the segmentation of bacteria or other elongated cells.\n",
        "\n",
        "- The cytoplasm2 Omnipose model is an Omnipose model trained using the same dataset as the cellpose cytoplasm2 model.\n",
        "\n",
        "<font size = 4>**`Channel_to_segment`:** Choose the channel to segment. If using single-channel grayscale images, choose \"Grayscale\".\n",
        "\n",
        "<font size = 4>**`Nuclear_channel`:** If you are using a model that segment the \"cytoplasm\", you can use a nuclear channel to aid the segmentation. \n",
        "\n",
        "<font size = 4>**`Object_diameter`:** Indicate the diameter of the objects (cells or Nuclei) you want to segment (in pixel). If you input \"0\", this parameter will be estimated automatically for each of your images.\n",
        "\n",
        "<font size = 4>**`Flow_threshold`:** This parameter controls the maximum allowed error of the flows for each mask. Increase this threshold if cellpose is not returning as many masks as you'd expect. Similarly, decrease this threshold if cellpose is returning too many ill-shaped masks. **Default value: 0.4**\n",
        "\n",
        "<font size = 4>**`mask_threshold`:** The pixels greater than the mask_threshold are used to run dynamics and determine masks.  Decrease this threshold if cellpose is not returning as many masks as you'd expect. Similarly, increase this threshold if cellpose is returning too many masks, particularly from dim areas. **Default value: 0.0**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BUrTuonhEH5J",
        "cellView": "form"
      },
      "source": [
        "#@markdown ##Choose the folders that contain your Quality Control dataset\n",
        "\n",
        "Source_QC_folder = \"D:\\\\cellpose_test\\\\data\\\\test\\\\images\" #@param{type:\"string\"}\n",
        "Target_QC_folder = \"D:\\\\cellpose_test\\\\data\\\\test\\\\masks\" #@param{type:\"string\"}\n",
        "\n",
        "Channel_to_segment= \"Grayscale\" #@param [\"Grayscale\", \"Blue\", \"Green\", \"Red\"]\n",
        "\n",
        "# @markdown ###If you chose the model \"cytoplasm\" indicate if you also have a nuclear channel that can be used to aid the segmentation.\n",
        "\n",
        "Nuclear_channel= \"None\" #@param [\"None\", \"Blue\", \"Green\", \"Red\"]\n",
        "\n",
        "#@markdown ### Segmentation parameters:\n",
        "Object_diameter =  0#@param {type:\"number\"}\n",
        "\n",
        "Flow_threshold = 0.4 #@param {type:\"slider\", min:0.1, max:1.1, step:0.1}\n",
        "mask_threshold=0 #@param {type:\"slider\", min:-6, max:6, step:1}\n",
        "\n",
        "if Object_diameter is 0:\n",
        "  Object_diameter = None\n",
        "  print(\"The cell size will be estimated automatically for each image\")\n",
        "\n",
        "\n",
        "# Find the number of channel in the input image\n",
        "\n",
        "random_choice = random.choice(os.listdir(Source_QC_folder))\n",
        "x = io.imread(Source_QC_folder+\"/\"+random_choice)\n",
        "n_channel = 1 if x.ndim == 2 else x.shape[-1]\n",
        "\n",
        "if Channel_to_segment == \"Grayscale\":\n",
        "  segment_channel = 0\n",
        "\n",
        "  if not n_channel == 1:\n",
        "      print(bcolors.WARNING +\"!! WARNING: your image has more than one channel, choose which channel you want to use for QC !!\")\n",
        "\n",
        "if Channel_to_segment == \"Blue\":\n",
        "  segment_channel = 3\n",
        "\n",
        "if Channel_to_segment == \"Green\":\n",
        "  segment_channel = 2\n",
        "\n",
        "if Channel_to_segment == \"Red\":\n",
        "  segment_channel = 1\n",
        "\n",
        "if Nuclear_channel == \"Blue\":\n",
        "  nuclear_channel = 3\n",
        "\n",
        "if Nuclear_channel == \"Green\":\n",
        "  nuclear_channel = 2\n",
        "\n",
        "if Nuclear_channel == \"Red\":\n",
        "  nuclear_channel = 1\n",
        "\n",
        "if Nuclear_channel == \"None\":\n",
        "  nuclear_channel = 0\n",
        "\n",
        "if QC_model == \"Cytoplasm\":  \n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "\n",
        "if QC_model == \"Cytoplasm2_Omnipose\":  \n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "\n",
        "if QC_model == \"Bacteria_Omnipose\":  \n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "\n",
        "if QC_model == \"Cytoplasm2\":  \n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "  \n",
        "if QC_model == \"Nuclei\":\n",
        "  channels=[segment_channel,0]\n",
        "\n",
        "if QC_model == \"Own_model\":\n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "\n",
        "#Create a quality control Folder and check if the folder already exist\n",
        "if os.path.exists(QC_model_folder+\"/Quality Control\") == False:\n",
        "  os.makedirs(QC_model_folder+\"/Quality Control\")\n",
        "\n",
        "if os.path.exists(QC_model_folder+\"/Quality Control/Prediction\"):\n",
        "  shutil.rmtree(QC_model_folder+\"/Quality Control/Prediction\")\n",
        "os.makedirs(QC_model_folder+\"/Quality Control/Prediction\")\n",
        "\n",
        "\n",
        "# Here we need to make predictions\n",
        "\n",
        "for name in os.listdir(Source_QC_folder):\n",
        "  \n",
        "  print(\"Performing prediction on: \"+name)\n",
        "  image = io.imread(Source_QC_folder+\"/\"+name) \n",
        "\n",
        "  short_name = os.path.splitext(name)\n",
        "        \n",
        "  if QC_model == \"Own_model\":\n",
        "    masks, flows, styles = model.eval(image, diameter=Object_diameter, flow_threshold=Flow_threshold,mask_threshold=mask_threshold, channels=channels)\n",
        "  else:\n",
        "    masks, flows, styles, diams = model.eval(image, diameter=Object_diameter, flow_threshold=Flow_threshold,mask_threshold=mask_threshold, channels=channels)\n",
        "            \n",
        "  os.chdir(QC_model_folder+\"/Quality Control/Prediction\")\n",
        "  imsave(str(short_name[0])+\".tif\", masks, compress=ZIP_DEFLATED)  \n",
        "  \n",
        "# Here we start testing the differences between GT and predicted masks\n",
        "\n",
        "with open(QC_model_folder+\"/Quality Control/Quality_Control for \"+QC_model_name+\".csv\", \"w\", newline='') as file:\n",
        "  writer = csv.writer(file, delimiter=\",\")\n",
        "  writer.writerow([\"image\",\"Prediction v. GT Intersection over Union\", \"false positive\", \"true positive\", \"false negative\", \"precision\", \"recall\", \"accuracy\", \"f1 score\", \"n_true\", \"n_pred\", \"mean_true_score\", \"mean_matched_score\", \"panoptic_quality\"])  \n",
        "\n",
        "# define the images\n",
        "\n",
        "  for n in os.listdir(Source_QC_folder):\n",
        "    \n",
        "    if not os.path.isdir(os.path.join(Source_QC_folder,n)):\n",
        "      print('Running QC on: '+n)\n",
        "      test_input = io.imread(os.path.join(Source_QC_folder,n))\n",
        "      test_prediction = io.imread(os.path.join(QC_model_folder+\"/Quality Control/Prediction\",n))\n",
        "      test_ground_truth_image = io.imread(os.path.join(Target_QC_folder, n))\n",
        "\n",
        "      # Calculate the matching (with IoU threshold `thresh`) and all metrics\n",
        "\n",
        "      stats = matching(test_ground_truth_image, test_prediction, thresh=0.5)\n",
        "      \n",
        "\n",
        "      #Convert pixel values to 0 or 255\n",
        "      test_prediction_0_to_255 = test_prediction\n",
        "      test_prediction_0_to_255[test_prediction_0_to_255>0] = 255\n",
        "\n",
        "      #Convert pixel values to 0 or 255\n",
        "      test_ground_truth_0_to_255 = test_ground_truth_image\n",
        "      test_ground_truth_0_to_255[test_ground_truth_0_to_255>0] = 255\n",
        "\n",
        "\n",
        "      # Intersection over Union metric\n",
        "\n",
        "      intersection = np.logical_and(test_ground_truth_0_to_255, test_prediction_0_to_255)\n",
        "      union = np.logical_or(test_ground_truth_0_to_255, test_prediction_0_to_255)\n",
        "      iou_score =  np.sum(intersection) / np.sum(union)\n",
        "      writer.writerow([n, str(iou_score), str(stats.fp), str(stats.tp), str(stats.fn), str(stats.precision), str(stats.recall), str(stats.accuracy), str(stats.f1), str(stats.n_true), str(stats.n_pred), str(stats.mean_true_score), str(stats.mean_matched_score), str(stats.panoptic_quality)])\n",
        "\n",
        "from tabulate import tabulate\n",
        "\n",
        "df = pd.read_csv (QC_model_folder+\"/Quality Control/Quality_Control for \"+QC_model_name+\".csv\")\n",
        "print(tabulate(df, headers='keys', tablefmt='psql'))\n",
        "\n",
        "\n",
        "from astropy.visualization import simple_norm\n",
        "\n",
        "# ------------- For display ------------\n",
        "print('--------------------------------------------------------------')\n",
        "@interact\n",
        "def show_QC_results(file = os.listdir(Source_QC_folder)):\n",
        "  \n",
        "\n",
        "  plt.figure(figsize=(25,5))\n",
        "  if n_channel > 1:\n",
        "    source_image = io.imread(os.path.join(Source_QC_folder, file))\n",
        "  if n_channel == 1:\n",
        "    source_image = io.imread(os.path.join(Source_QC_folder, file), as_gray = True)\n",
        "\n",
        "  target_image = io.imread(os.path.join(Target_QC_folder, file), as_gray = True)\n",
        "  prediction = io.imread(QC_model_folder+\"/Quality Control/Prediction/\"+file, as_gray = True)\n",
        "\n",
        "  stats = matching(prediction, target_image, thresh=0.5)\n",
        "\n",
        "  target_image_mask = np.empty_like(target_image)\n",
        "  target_image_mask[target_image > 0] = 255\n",
        "  target_image_mask[target_image == 0] = 0\n",
        "  \n",
        "  prediction_mask = np.empty_like(prediction)\n",
        "  prediction_mask[prediction > 0] = 255\n",
        "  prediction_mask[prediction == 0] = 0\n",
        "\n",
        "  intersection = np.logical_and(target_image_mask, prediction_mask)\n",
        "  union = np.logical_or(target_image_mask, prediction_mask)\n",
        "  iou_score =  np.sum(intersection) / np.sum(union)\n",
        "\n",
        "  norm = simple_norm(source_image, percent = 99)\n",
        "\n",
        "  #Input\n",
        "  plt.subplot(1,4,1)\n",
        "  plt.axis('off')\n",
        "  if n_channel > 1:\n",
        "    plt.imshow(source_image)\n",
        "  if n_channel == 1:\n",
        "    plt.imshow(source_image, aspect='equal', norm=norm, cmap='magma', interpolation='nearest')\n",
        "  plt.title('Input')\n",
        "\n",
        "  #Ground-truth\n",
        "  plt.subplot(1,4,2)\n",
        "  plt.axis('off')\n",
        "  plt.imshow(target_image_mask, aspect='equal', cmap='Greens')\n",
        "  plt.title('Ground Truth')\n",
        "\n",
        "  #Prediction\n",
        "  plt.subplot(1,4,3)\n",
        "  plt.axis('off')\n",
        "  plt.imshow(prediction_mask, aspect='equal', cmap='Purples')\n",
        "  plt.title('Prediction')\n",
        "\n",
        "  #Overlay\n",
        "  plt.subplot(1,4,4)\n",
        "  plt.axis('off')\n",
        "  plt.imshow(target_image_mask, cmap='Greens')\n",
        "  plt.imshow(prediction_mask, alpha=0.5, cmap='Purples')\n",
        "  plt.title('Ground Truth and Prediction, Intersection over Union:'+str(round(iou_score,3 )));\n",
        "  plt.savefig(QC_model_folder+'/Quality Control/QC_example_data.png',bbox_inches='tight',pad_inches=0)\n",
        "\n",
        "\n",
        "full_QC_model_path = QC_model_folder+'/'\n",
        "qc_pdf_export()\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Io62PUMLagFS"
      },
      "source": [
        "# **6. Using the trained model**\n",
        "\n",
        "---\n",
        "\n",
        "<font size = 4>In this section the unseen data is processed using the trained model (in section 4). First, your unseen images are uploaded and prepared for prediction. After that your trained model from section 4 is activated and finally saved into your Google Drive."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E29LWfWpjkZU"
      },
      "source": [
        "\n",
        "\n",
        "## **6.1 Generate prediction(s) from unseen dataset (2D and 2D + t data)**\n",
        "---\n",
        "\n",
        "<font size = 4>The current trained model (from section 4.3) can now be used to process images. If an older model needs to be used, please untick the **Use_the_current_trained_model** box and enter the model's name and path to use. Predicted output images are saved in your **Prediction_folder** folder as restored image stacks (ImageJ-compatible TIFF images).\n",
        "\n",
        "<font size = 4>**`Data_folder`:** This folder should contain the images that you want to predict using the network that you will train.\n",
        "\n",
        "<font size = 4>**`Result_folder`:** This folder will contain the predicted output.\n",
        "\n",
        "<font size = 4>**`Data_type`:** Please indicate if the images you want to predict are single images or stacks\n",
        "\n",
        "<font size = 4>**`model_choice`:** Choose the model to use to make predictions. This model needs to be a Cellpose model. You can also use the pretrained models already available in cellpose: \n",
        "\n",
        "- The cytoplasm model in cellpose is trained on two-channel images, where the first channel is the channel to segment, and the second channel is an optional nuclear channel.\n",
        "\n",
        "- The cytoplasm2 model is an updated cytoplasm model trained with user-submitted images.\n",
        "\n",
        "- The nuclear model in cellpose is trained on two-channel images, where the first channel is the channel to segment, and the second channel is always set to an array of zeros.\n",
        "\n",
        "- The bacteria Omnipose model is an Omnipose model dedicated to the segmentation of bacteria or other elongated cells.\n",
        "\n",
        "- The cytoplasm2 Omnipose model is an Omnipose model trained using the same dataset as the cellpose cytoplasm2 model.\n",
        "\n",
        "<font size = 4>**`Channel_to_segment`:** Choose the channel to segment. If using single-channel grayscale images, choose \"Grayscale\".\n",
        "\n",
        "<font size = 4>**`Nuclear_channel`:** If you are using a model that segment the \"cytoplasm\", you can use a nuclear channel to aid the segmentation. \n",
        "\n",
        "<font size = 4>**`Object_diameter`:** Indicate the diameter of the objects (cells or Nuclei) you want to segment (in pixel). If you input \"0\", this parameter will be estimated automatically for each of your images.\n",
        "\n",
        "<font size = 4>**`Flow_threshold`:** This parameter controls the maximum allowed error of the flows for each mask. Increase this threshold if cellpose is not returning as many masks as you'd expect. Similarly, decrease this threshold if cellpose is returning too many ill-shaped masks. **Default value: 0.4**\n",
        "\n",
        "<font size = 4>**`mask_threshold`:** The pixels greater than the mask_threshold are used to run dynamics and determine masks.  Decrease this threshold if cellpose is not returning as many masks as you'd expect. Similarly, increase this threshold if cellpose is returning too many masks, particularly from dim areas. **Default value: 0.0**\n",
        "\n",
        "<font size = 4>**IMPORTANT:** One example result will be displayed first so that you can assess the quality of the prediction and change your settings accordingly. Once the most suitable settings have been chosen, press on the yellow button \"process your images\".\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mfgvhMk2xid9",
        "cellView": "form"
      },
      "source": [
        "\n",
        "#@markdown ### Provide the path to your dataset and to the folder where the predictions are saved, then play the cell to predict outputs from your unseen images.\n",
        "\n",
        "Data_folder = \"\" #@param {type:\"string\"}\n",
        "Result_folder = \"\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown ###Are your data single images or stacks?\n",
        "\n",
        "Data_type = \"Single_Images\" #@param [\"Single_Images\", \"Stacks (2D + t)\"]\n",
        "\n",
        "#@markdown ###What model do you want to use?\n",
        "\n",
        "model_choice = \"Cytoplasm2\" #@param [\"Cytoplasm\",\"Cytoplasm2\", \"Cytoplasm2_Omnipose\", \"Bacteria_Omnipose\", \"Nuclei\", \"Own_model\"]\n",
        "\n",
        "#@markdown ####If using your own model, please provide the path to the model (not the folder):\n",
        "\n",
        "Prediction_model = \"\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown ### What channel do you want to segment?\n",
        "\n",
        "Channel_to_segment= \"Grayscale\" #@param [\"Grayscale\", \"Blue\", \"Green\", \"Red\"]\n",
        "\n",
        "# @markdown ###If you chose the model \"cytoplasm\" indicate if you also have a nuclear channel that can be used to aid the segmentation.\n",
        "\n",
        "Nuclear_channel= \"None\" #@param [\"None\", \"Blue\", \"Green\", \"Red\"]\n",
        "\n",
        "#@markdown ### Segmentation parameters:\n",
        "Object_diameter =  0#@param {type:\"number\"}\n",
        "\n",
        "Flow_threshold = 0.4 #@param {type:\"slider\", min:0.1, max:1.1, step:0.1}\n",
        "mask_threshold=0 #@param {type:\"slider\", min:-6, max:6, step:1}\n",
        "\n",
        "# Find the number of channel in the input image\n",
        "\n",
        "random_choice = random.choice(os.listdir(Data_folder))\n",
        "x = io.imread(Data_folder+\"/\"+random_choice)\n",
        "n_channel = 1 if x.ndim == 2 else x.shape[-1]\n",
        "\n",
        "if Channel_to_segment == \"Grayscale\":\n",
        "  segment_channel = 0\n",
        "\n",
        "  if Data_type == \"Single_Images\":\n",
        "    if not n_channel == 1:\n",
        "        print(bcolors.WARNING +\"!! WARNING: your image has more than one channel, choose which channel you want to use for your predictions !!\")\n",
        "\n",
        "if Channel_to_segment == \"Blue\":\n",
        "  segment_channel = 3\n",
        "\n",
        "if Channel_to_segment == \"Green\":\n",
        "  segment_channel = 2\n",
        "\n",
        "if Channel_to_segment == \"Red\":\n",
        "  segment_channel = 1\n",
        "\n",
        "if Nuclear_channel == \"Blue\":\n",
        "  nuclear_channel = 3\n",
        "\n",
        "if Nuclear_channel == \"Green\":\n",
        "  nuclear_channel = 2\n",
        "\n",
        "if Nuclear_channel == \"Red\":\n",
        "  nuclear_channel = 1\n",
        "\n",
        "if Nuclear_channel == \"None\":\n",
        "  nuclear_channel = 0\n",
        "\n",
        "if model_choice == \"Cytoplasm\":  \n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "  model = models.Cellpose(gpu=True, model_type=\"cyto\")\n",
        "  print(\"Cytoplasm model enabled\")\n",
        "\n",
        "if model_choice == \"Cytoplasm2\":  \n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "  model = models.Cellpose(gpu=True, model_type=\"cyto2\")\n",
        "  print(\"Cytoplasm2 model enabled\")\n",
        "\n",
        "if model_choice == \"Cytoplasm2_Omnipose\":  \n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "  model = models.Cellpose(gpu=True, model_type=\"cyto2_omni\")\n",
        "  print(\"Cytoplasm2_Omnipose model enabled\")\n",
        "  \n",
        "if model_choice == \"Nuclei\":\n",
        "  channels=[segment_channel,0]\n",
        "  model = models.Cellpose(gpu=True, model_type=\"nuclei\")\n",
        "  print(\"Nuclei model enabled\")\n",
        "\n",
        "if model_choice == \"Bacteria_Omnipose\":\n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "  model = models.Cellpose(gpu=True, model_type=\"bact_omni\")\n",
        "  Object_diameter =  0\n",
        "  print(\"Bacteria_omnipose model enabled\")\n",
        "\n",
        "if model_choice == \"Own_model\":\n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "  model = models.CellposeModel(gpu=True, pretrained_model=Prediction_model, torch=True, diam_mean=30.0, net_avg=True, device=None, residual_on=True, style_on=True, concatenation=False)\n",
        "\n",
        "  print(\"Own model enabled\")\n",
        "\n",
        "if Object_diameter is 0:\n",
        "  Object_diameter = None\n",
        "  print(\"The cell size will be estimated automatically for each image\")\n",
        "\n",
        "if Data_type == \"Single_Images\" :\n",
        "\n",
        "  print('--------------------------------------------------------------')\n",
        "  @interact\n",
        "  def preview_results(file = os.listdir(Data_folder)):\n",
        "    source_image = io.imread(os.path.join(Data_folder, file))\n",
        "    \n",
        "    if model_choice == \"Own_model\":\n",
        "      masks, flows, styles = model.eval(source_image, diameter=Object_diameter, flow_threshold=Flow_threshold,mask_threshold=mask_threshold, channels=channels)\n",
        "    \n",
        "    else:\n",
        "      masks, flows, styles, diams = model.eval(source_image, diameter=Object_diameter, flow_threshold=Flow_threshold,mask_threshold=mask_threshold, channels=channels)\n",
        "    \n",
        "    flowi = flows[0]\n",
        "    fig = plt.figure(figsize=(20,10))\n",
        "    plot.show_segmentation(fig, source_image, masks, flowi, channels=channels)\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "  def batch_process():\n",
        "      print(\"Your images are now beeing processed\")\n",
        "\n",
        "      for name in os.listdir(Data_folder):\n",
        "        print(\"Performing prediction on: \"+name)\n",
        "        image = io.imread(Data_folder+\"/\"+name)\n",
        "        short_name = os.path.splitext(name)\n",
        "        \n",
        "        if model_choice == \"Own_model\":\n",
        "          masks, flows, styles = model.eval(image, diameter=Object_diameter, flow_threshold=Flow_threshold,mask_threshold=mask_threshold, channels=channels)\n",
        "        else:\n",
        "          masks, flows, styles, diams = model.eval(image, diameter=Object_diameter, flow_threshold=Flow_threshold,mask_threshold=mask_threshold, channels=channels)\n",
        "            \n",
        "        os.chdir(Result_folder)\n",
        "        imsave(str(short_name[0])+\"_mask.tif\", masks, compress=ZIP_DEFLATED)\n",
        "\n",
        "  im = interact_manual(batch_process)\n",
        "  im.widget.children[0].description = 'Process your images'\n",
        "  im.widget.children[0].style.button_color = 'yellow'\n",
        "  display(im)\n",
        "\n",
        "if Data_type == \"Stacks (2D + t)\" :\n",
        "  print(\"Stacks (2D + t) are now beeing predicted\")\n",
        "  \n",
        "  print('--------------------------------------------------------------')\n",
        "  @interact\n",
        "  def preview_results_stacks(file = os.listdir(Data_folder)):\n",
        "    timelapse = imread(Data_folder+\"/\"+file)\n",
        "\n",
        "    if model_choice == \"Own_model\":\n",
        "      masks, flows, styles = model.eval(timelapse[0], diameter=Object_diameter, flow_threshold=Flow_threshold,mask_threshold=mask_threshold, channels=channels)\n",
        "    else:\n",
        "      masks, flows, styles, diams = model.eval(timelapse[0], diameter=Object_diameter, flow_threshold=Flow_threshold,mask_threshold=mask_threshold, channels=channels)\n",
        "           \n",
        "    flowi = flows[0]\n",
        "    fig = plt.figure(figsize=(20,10))\n",
        "    plot.show_segmentation(fig, timelapse[0], masks, flowi, channels=channels)\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "  def batch_process_stack():\n",
        "      print(\"Your images are now beeing processed\")  \n",
        "      for image in os.listdir(Data_folder):\n",
        "        print(\"Performing prediction on: \"+image)\n",
        "        timelapse = imread(Data_folder+\"/\"+image)\n",
        "        short_name = os.path.splitext(image)\n",
        "        n_timepoint = timelapse.shape[0]\n",
        "        prediction_stack = np.zeros((n_timepoint, timelapse.shape[1], timelapse.shape[2]))\n",
        "        \n",
        "        for t in range(n_timepoint):\n",
        "          print(\"Frame number: \"+str(t))\n",
        "          img_t = timelapse[t]\n",
        "\n",
        "          if model_choice == \"Own_model\":\n",
        "            masks, flows, styles = model.eval(img_t, diameter=Object_diameter, flow_threshold=Flow_threshold,mask_threshold=mask_threshold, channels=channels)\n",
        "          else:\n",
        "            masks, flows, styles, diams = model.eval(img_t, diameter=Object_diameter, flow_threshold=Flow_threshold,mask_threshold=mask_threshold, channels=channels)\n",
        "            \n",
        "              \n",
        "          prediction_stack[t] = masks\n",
        "      \n",
        "        prediction_stack_32 = img_as_float32(prediction_stack, force_copy=False)\n",
        "        os.chdir(Result_folder)\n",
        "        imsave(str(short_name[0])+\".tif\", prediction_stack_32, compress=ZIP_DEFLATED)\n",
        "  \n",
        "  im = interact_manual(batch_process_stack)\n",
        "  im.widget.children[0].description = 'Process your images'\n",
        "  im.widget.children[0].style.button_color = 'yellow'\n",
        "  display(im)          \n",
        "     \n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rk7GNKr5tYBY"
      },
      "source": [
        "\n",
        "\n",
        "## **6.2 Generate prediction(s) from unseen dataset (3D stacks)**\n",
        "---\n",
        "\n",
        "<font size = 4>The current trained model (from section 4.3) can now be used to process images. If an older model needs to be used, please untick the **Use_the_current_trained_model** box and enter the model's name and path to use. Predicted output images are saved in your **Prediction_folder** folder as restored image stacks (ImageJ-compatible TIFF images).\n",
        "\n",
        "<font size = 4>**`Data_folder`:** This folder should contain the images that you want to predict using the network that you will train.\n",
        "\n",
        "<font size = 4>**`Result_folder`:** This folder will contain the predicted output.\n",
        "\n",
        "<font size = 4>**`model_choice`:** Choose the model to use to make predictions. This model needs to be a Cellpose model. You can also use the pretrained models already available in cellpose: \n",
        "\n",
        "- The cytoplasm model in cellpose is trained on two-channel images, where the first channel is the channel to segment, and the second channel is an optional nuclear channel.\n",
        "- The cytoplasm2 model is an updated cytoplasm model trained with user-submitted images.\n",
        "\n",
        "- The nuclear model in cellpose is trained on two-channel images, where the first channel is the channel to segment, and the second channel is always set to an array of zeros.\n",
        "\n",
        "<font size = 4>**`Channel_to_segment`:** Choose the channel to segment. If using single-channel grayscale images, choose \"Grayscale\".\n",
        "\n",
        "<font size = 4>**`Nuclear_channel`:** If you are using a model that segment the \"cytoplasm\", you can use a nuclear channel to aid the segmentation. \n",
        "\n",
        "<font size = 4>**`Object_diameter`:** Indicate the diameter of the objects (cells or Nuclei) you want to segment (in pixel). Do not input \"0\" to perform 3D predictions.\n",
        "\n",
        "<font size = 4>**`Anisotropy`:** Optional rescaling factor to use when the images to segment are not isotropic (e.g. set to 2.0 if Z is sampled half as dense as X or Y). **Default value: 1**\n",
        "\n",
        "<font size = 4>**`Min_size`:** Minimum number of pixels per mask. Can be turned off using -1. **Default value: 15**\n",
        "\n",
        "<font size = 4>**`mask_threshold`:** The pixels greater than the mask_threshold are used to run dynamics and determine masks.  Decrease this threshold if cellpose is not returning as many masks as you'd expect. Similarly, increase this threshold if cellpose is returning too many masks, particularly from dim areas. **Default value: 0.0**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qf2Mn-2Yo7tI",
        "cellView": "form"
      },
      "source": [
        "from cellpose import utils\n",
        "from numba import jitclass, float64\n",
        "from numba import jit\n",
        "\n",
        "\n",
        "#@markdown ### Provide the path to your dataset and to the folder where the predictions are saved, then play the cell to predict outputs from your unseen images.\n",
        "\n",
        "Data_folder = \"\" #@param {type:\"string\"}\n",
        "Result_folder = \"\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown ###What model do you want to use?\n",
        "model_choice = \"Cytoplasm\" #@param [\"Cytoplasm\",\"Cytoplasm2\", \"Nuclei\", \"Own_model\"]\n",
        "\n",
        "\n",
        "#@markdown ####If using your own model, please provide the path to the model (not the folder):\n",
        "\n",
        "Prediction_model = \"\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown ### What channel do you want to segment?\n",
        "\n",
        "Channel_to_segment= \"Grayscale\" #@param [\"Grayscale\", \"Blue\", \"Green\", \"Red\"]\n",
        "\n",
        "# @markdown ###If you chose the model \"cytoplasm\" indicate if you also have a nuclear channel that can be used to aid the segmentation.\n",
        "\n",
        "Nuclear_channel= \"None\" #@param [\"None\", \"Blue\", \"Green\", \"Red\"]\n",
        "\n",
        "#@markdown ###How do you want to generate the 3D labels?\n",
        "\n",
        "#Choose_3D_mode = \"2D predictions and stitching\" #@param [\"3D predictions\", \"2D predictions and stitching\"]\n",
        "\n",
        "Choose_3D_mode = \"3D predictions\" #@param [\"3D predictions\"]\n",
        "\n",
        "#@markdown ### Segmentation parameters:\n",
        "Object_diameter =  40#@param {type:\"number\"}\n",
        "Anisotropy = 2 #@param {type:\"number\"}\n",
        "Min_size = 200#@param {type:\"number\"}\n",
        "mask_threshold=0 #@param {type:\"slider\", min:-6, max:6, step:1}\n",
        "\n",
        "##@markdown ### Additional parameters for 2D predictions and stitching:\n",
        "\n",
        "#Flow_threshold = 0.5 #@param {type:\"slider\", min:0.1, max:1.1, step:0.1}\n",
        "#Stitch_threshold= 0.1#@param {type:\"slider\", min:0, max:1.0, step:0.1}\n",
        "\n",
        "#failsafes\n",
        "if Choose_3D_mode == \"3D predictions\":\n",
        "  do_3D = True\n",
        "  Stitch_threshold= 0\n",
        "\n",
        "  if Object_diameter == 0:  \n",
        "    Object_diameter= 40\n",
        "    print(\"Object_diameter set to 40. If you want to use a different Object_diameter enable it in your segmentation parameters\")\n",
        "  \n",
        "else:\n",
        "  do_3D = False\n",
        "  Anisotropy = 0\n",
        "\n",
        "if Choose_3D_mode == \"2D predictions and stitching\" and Stitch_threshold== 0:\n",
        "  Stitch_threshold= 0.5\n",
        "  print(\"Stitch_threshold has now automatically be enabled with an IoU of 0.5. If you want to use a different threshold enable it in your segmentation parameters\")\n",
        "\n",
        "\n",
        "if Channel_to_segment == \"Grayscale\":\n",
        "  segment_channel = 0\n",
        "  \n",
        "if Channel_to_segment == \"Blue\":\n",
        "  segment_channel = 3\n",
        "\n",
        "if Channel_to_segment == \"Green\":\n",
        "  segment_channel = 2\n",
        "\n",
        "if Channel_to_segment == \"Red\":\n",
        "  segment_channel = 1\n",
        "\n",
        "if Nuclear_channel == \"Blue\":\n",
        "  nuclear_channel = 3\n",
        "\n",
        "if Nuclear_channel == \"Green\":\n",
        "  nuclear_channel = 2\n",
        "\n",
        "if Nuclear_channel == \"Red\":\n",
        "  nuclear_channel = 1\n",
        "\n",
        "if Nuclear_channel == \"None\":\n",
        "  nuclear_channel = 0\n",
        "\n",
        "if model_choice == \"Cytoplasm\":  \n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "  model = models.Cellpose(gpu=True, model_type=\"cyto\")\n",
        "  print(\"Cytoplasm model enabled\")\n",
        "\n",
        "if model_choice == \"Cytoplasm2\":  \n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "  model = models.Cellpose(gpu=True, model_type=\"cyto2\")\n",
        "  print(\"Cytoplasm2 model enabled\")\n",
        "  \n",
        "if model_choice == \"Nuclei\":\n",
        "  channels=[segment_channel,0]\n",
        "  model = models.Cellpose(gpu=True, model_type=\"nuclei\")\n",
        "  print(\"Nuclei model enabled\")\n",
        "\n",
        "if model_choice == \"Cytoplasm2_Omnipose\":  \n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "  model = models.Cellpose(gpu=True, model_type=\"cyto2_omni\")\n",
        "  print(\"Cytoplasm2_Omnipose model enabled\")\n",
        "  \n",
        "if model_choice == \"Bacteria_Omnipose\":\n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "  model = models.Cellpose(gpu=True, model_type=\"bact_omni\")\n",
        "  print(\"Bacteria_omnipose model enabled\")\n",
        "\n",
        "if model_choice == \"Own_model\":\n",
        "  channels=[segment_channel,nuclear_channel]\n",
        "  model = models.CellposeModel(gpu=True, pretrained_model=Prediction_model, torch=True, diam_mean=30.0, net_avg=True, device=None, residual_on=True, style_on=True, concatenation=False)\n",
        "\n",
        "  print(\"Own model enabled\")\n",
        "\n",
        "if Object_diameter is 0:\n",
        "  Object_diameter = None\n",
        "  print(\"The cell size will be estimated automatically for each image\")\n",
        "\n",
        "if Choose_3D_mode == \"2D predictions and stitching\":\n",
        "   \n",
        "  for image in os.listdir(Data_folder):\n",
        "    print(\"Performing prediction on: \"+image)\n",
        "    stack = imread(Data_folder+\"/\"+image)\n",
        "    short_name = os.path.splitext(image)\n",
        "    n_plane = stack.shape[0]\n",
        "    prediction_stack = np.zeros((n_plane, stack.shape[1], stack.shape[2]))\n",
        "        \n",
        "    for t in range(n_plane):\n",
        "      print(\"Z plane number: \"+str(t))\n",
        "      img_t = stack[t]\n",
        "\n",
        "      if model_choice == \"Own_model\":\n",
        "        masks, flows, styles = model.eval(img_t, diameter=Object_diameter, flow_threshold=Flow_threshold,mask_threshold=mask_threshold, channels=channels, do_3D=do_3D, anisotropy = Anisotropy, stitch_threshold=Stitch_threshold, min_size=Min_size)\n",
        "      else:\n",
        "        masks, flows, styles, diams = model.eval(img_t, diameter=Object_diameter, flow_threshold=Flow_threshold,mask_threshold=mask_threshold, channels=channels, do_3D=do_3D, anisotropy = Anisotropy, stitch_threshold=Stitch_threshold, min_size=Min_size)\n",
        "                          \n",
        "      prediction_stack = masks\n",
        "\n",
        "    os.chdir(Result_folder)\n",
        "    imsave(str(short_name[0])+\".tif\", prediction_stack, compress=ZIP_DEFLATED)\n",
        "\n",
        "\n",
        "if Choose_3D_mode == \"3D predictions\":\n",
        "   \n",
        "  for image in os.listdir(Data_folder):\n",
        "    print(\"Performing prediction on: \"+image)\n",
        "    stack = imread(Data_folder+\"/\"+image)\n",
        "    short_name = os.path.splitext(image)\n",
        "\n",
        "    if model_choice == \"Own_model\":\n",
        "      masks, flows, styles = model.eval(stack, diameter=Object_diameter, channels=channels, do_3D=True, anisotropy = Anisotropy, min_size=Min_size, mask_threshold=mask_threshold)\n",
        "    else:\n",
        "      masks, flows, styles, diams = model.eval(stack, diameter=Object_diameter, channels=channels, do_3D=True, anisotropy = Anisotropy, min_size=Min_size, mask_threshold=mask_threshold)\n",
        "    \n",
        "    prediction_stack_32 = img_as_float32(masks, force_copy=False)     \n",
        "    os.chdir(Result_folder)\n",
        "    imsave(str(short_name[0])+\".tif\", prediction_stack_32, compress=ZIP_DEFLATED)\n",
        "\n",
        "\n",
        "  def f(Z_plane):\n",
        "    flowi = flows[0]\n",
        "    fig = plt.figure(figsize=(20,10))\n",
        "    plot.show_segmentation(fig, stack[Z_plane], masks[Z_plane], flowi[Z_plane], channels=channels)\n",
        "    plt.tight_layout()\n",
        "    plt.show()  \n",
        "\n",
        "  print('--------------------------------------------------------------')\n",
        "  interact(f, Z_plane=widgets.IntSlider(min=0, max=masks.shape[0], step=1, value=0));\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hvkd66PldsXB"
      },
      "source": [
        "## **6.3. Download your predictions**\n",
        "---\n",
        "\n",
        "<font size = 4>**Store your data** and ALL its results elsewhere by downloading it from Google Drive and after that clean the original folder tree (datasets, results, trained model etc.) if you plan to train or use new networks. Please note that the notebook will otherwise **OVERWRITE** all files which have the same name."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u4pcBe8Z3T2J"
      },
      "source": [
        "#**Thank you for using Cellpose 2D!**"
      ]
    }
  ]
}