Tests_Pooling_Epidemie_PARCY_DESBOIS.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "celltoolbar": "Aucun(e)",
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.4"
    },
    "colab": {
      "name": "Bon-notebook revu!.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FQc184aTWsfK",
        "colab_type": "text"
      },
      "source": [
        "# Comment tester le plus efficacement possible une population en cas d’épidémie ?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x4251d04wp-0",
        "colab_type": "text"
      },
      "source": [
        "&nbsp;&nbsp;&nbsp;&nbsp; Pour notre projet de programmation, nous avons choisi de répondre à une question cruciale lors d’épidémies de grande ampleur, en nous interrogeant sur les **méthodes de dépistage qui permettraient d’utiliser le moins de tests possibles**. Le but est ainsi d’identifier les personnes contaminées, pour les isoler et empêcher la formation de nouveaux clusters.\n",
        "Nous sommes partis du constat que les **méthodes de « pooling »** menées en Allemagne pour détecter les patients atteints du Covid-19 étaient très efficaces. Ces méthodes consistent à rassembler des échantillons de plusieurs individus dans un seul tube. Si le résultat de l'analyse du *pool* est positif, alors au moins un individu est contaminé, et les échantillons sont donc testés individuellement.\n",
        "\n",
        "\n",
        "&nbsp;&nbsp;&nbsp;&nbsp;Nous avons mis en place **trois méthodes de « pooling »** : \n",
        "*   Le **pooling naïf**, qui consiste à regrouper les échantillons, les tester une première fois groupés, puis à les tester individuellement si le résultat est positif. \n",
        "*   Le **pooling en carré**, qui consiste à placer les échantillons de chaque individu dans une matrice, puis à tester chaque ligne et chaque colonne. Lorsque des pools sont positifs, on peut relier les informations et identifier la personne infectée, ou tester de nouveau s’il y a plusieurs lignes et colonnes positives. \n",
        "*   La **méthode par dichotomie**, qui consiste à diviser successivement par deux le groupe d'individus pour trouver les cas positifs.\n",
        "\n",
        "\n",
        "&nbsp;&nbsp;&nbsp;&nbsp;Pour retranscrire nos résultats, nous avons choisi de présenter, pour une population donnée, le nombre de tests nécessaires pour chacune des trois méthodes, en fonction du taux de contamination. Globalement, on observe que la méthode naïve est moins efficace que les méthodes plus avancées, mais sa simplicité constitue un avantage pratique.\n",
        "\n",
        "\n",
        "&nbsp;&nbsp;&nbsp;&nbsp;Un facteur clé à étudier pour mettre en pratique ces méthodes est la taille des pools choisie. En effet, regrouper les individus en pools de différentes tailles change grandement l'efficacité finale de la méthode. On peut donc s'intéresser à **la recherche de taille de pools optimales**, en fonction du taux d'infection. Intuitivement, on peut en effet voir que si une seule personne sur mille est touchée, rassembler les gens par pools de 2 sera très inefficace, et il vaudra mieux faire des pools plus grands. De même, si une personne sur 5 est touchée, faire des pools de 100 donne un résultat encore moins efficace que de tester tout le monde un à un.\n",
        "\n",
        "En calculant ces tailles de pools optimales pour la méthode naïve, on extrait une loi mathématique reliant taux de contamination et taille de pool, qui aide grandement au calcul de ces tailles optimales. \n",
        "\n",
        "\n",
        "&nbsp;&nbsp;&nbsp;&nbsp;Pour affiner nos modèles, nous avons décidé de prendre en compte les clusters (groupes séparés plus ou moins contaminés) et les regroupements en famille, comme lors d’un confinement. \n",
        "\n",
        "\n",
        "*   **les clusters** : pour une méthode donnée (ici le pooling simple), nous avons comparé le nombre de tests nécessaires pour le cas où l’on sépare le cluster de la population générale et pour le cas où l’on mélange les individus des deux populations dans les échantillons constituants les pools. Le résultat de l’algorithme nous montre qu’il est toujours préférable de tester ces groupes de manière séparée, sans les mélanger dans les échantillons avec le reste de la population.\n",
        "*   **les familles** : On suppose ici que les individus vivant ensemble ont de fortes chances de se transmettre le virus. Ainsi, adapter les méthodes de tests à cette hypothèse permet d'améliorer considérablement les performances des algorithmes de tests.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x9q7A2NxWsfM",
        "colab_type": "text"
      },
      "source": [
        "## Les importations\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yr2dC2D9WsfO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from math import floor, sqrt\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import random as rd"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_vQot6xLWsfV",
        "colab_type": "text"
      },
      "source": [
        "## Quelques réglages en fonction des données sur l'épidémie"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9_S1aiYgWsfX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "N = 10000 # nombre d'individus\n",
        "p = 1e-2 # taux de contamination\n",
        "tests = 0\n",
        "gens = [rd.choices([0,1], [1-p, p])[0] for i in range(N)] # liste des individus"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GyCKJwvWWsfa",
        "colab_type": "text"
      },
      "source": [
        "# I] Les trois principales méthodes de pooling"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AyHWYBg6Wsfb",
        "colab_type": "text"
      },
      "source": [
        "### 1) Le test par pooling naïf, ou pooling simple"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N0iLZyY1XP4G",
        "colab_type": "text"
      },
      "source": [
        "Après avoir fait des groupes de Np individus, on teste l'echantillon du groupe entier pour savoir si au moins une personne est contaminée. Si c'est le cas, on teste individuellement chaque individu du groupe."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "em4FVi5rWsfc",
        "colab_type": "code",
        "outputId": "ed1d9ec2-a8b1-4f78-8031-e8ca16a20ffc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "def simplepools(Np, p, gens=gens, N=N, tests=tests): # Np=taille des pools, p taux de contamination\n",
        "    gens = [rd.choices([0,1], [1-p, p])[0] for i in range(N)]\n",
        "    tests = 0\n",
        "    N = len(gens)\n",
        "    for i in range(N//Np):\n",
        "        tests += 1\n",
        "        if 1 in gens[Np*i:Np*(i+1)]: # on teste les Np individus rassemblés\n",
        "            for i in range(Np*i, Np*(i+1)):\n",
        "                tests += 1 # si pool positif, on les teste tous\n",
        "    if N%Np != 0: # s'il reste des gens à la fin\n",
        "        lasts = gens[Np*(N//Np):]\n",
        "        tests += 1\n",
        "        if len(lasts) > 1:\n",
        "            if 1 in lasts: # on fait un pool avec tous ces gens\n",
        "                tests += len(lasts)\n",
        "    return(100*tests/len(gens)) # on renvoie le taux de tests par rapport à la taille de la population\n",
        "\n",
        "res = round(simplepools(11, 0.01),2)\n",
        "print(res)\n",
        "print('Lecture : on peut tester 100 personnes en effectuant seulement {} tests en moyenne'.format(res))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "20.32\n",
            "Lecture : on peut tester 100 personnes en effectuant seulement 20.32 tests en moyenne\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uSQmKjN3Wsfj",
        "colab_type": "text"
      },
      "source": [
        "### 2) Le pooling en carré"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CZW2jMfct8vS",
        "colab_type": "text"
      },
      "source": [
        "![Schema carrés](https://i.imgur.com/MqXWJRc.png)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_ymn4R8SWsfj",
        "colab_type": "code",
        "outputId": "7b0f97d2-69a3-4dfc-e5ce-29782cd9c51c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "sq = 10\n",
        "\n",
        "def testmat(gens=gens, sq=sq, tests=tests):# fonction qui traite une matrice sq*sq\n",
        "    col = []\n",
        "    lin = []\n",
        "    for i in range(sq):\n",
        "        tests += 1\n",
        "        if 1 in gens[i]: # on teste toute la ligne\n",
        "            lin.append(i)\n",
        "    if lin != []: # on continue que si il y a au moins un cas positif\n",
        "        for j in range(sq):\n",
        "            if 1 in gens[:, j]: # on teste toute la colonne\n",
        "                col.append(j)\n",
        "    if len(lin) == 1 or len(col) == 1: # si une seule ligne positive, on peut conclure\n",
        "        return(tests)\n",
        "    else:\n",
        "        possibles = []\n",
        "        for i in lin:\n",
        "            for j in col:\n",
        "                possibles.append((i, j)) # on ajoute aux possibles les intersections\n",
        "        for i in possibles:\n",
        "            tests += 1 #on fait un test par intersection (les ? dans le schéma)\n",
        "    return(tests)\n",
        "\n",
        "def mat_to_list(i): # donner le numéro dans la liste d'un élément d'une matrice\n",
        "    return(10*i[0]+i[1])\n",
        "\n",
        "def squarepools(sq, p, N=N): # fonction qui traite toute la liste en appelant successivement testmat\n",
        "    gens = [rd.choices([0,1], [1-p,p])[0] for i in range(N)]\n",
        "    Np = sq**2 # sq la taille du coté, Np la taille du pool\n",
        "    pools = int(N/Np)\n",
        "    tests = 0\n",
        "    for k in range(pools):\n",
        "        square = np.reshape(gens[Np*k:Np*(k+1)], (sq,sq)) # on fait une matrice carré sq*sq\n",
        "        t = testmat(square, sq)\n",
        "        tests += t\n",
        "    if N%Np != 0: # s'il reste des gens\n",
        "        fin = gens[Np*pools:]\n",
        "        testsfin = annexe(10, fin) # on utilise le pooling naïf sur la fin\n",
        "        tests += testsfin\n",
        "    return(100*tests/len(gens))\n",
        "\n",
        "def annexe(Np, gens=gens): # Fonction annexe pour faire du pooling naïf dans les autres fonctions\n",
        "    anntests = 0\n",
        "    N = len(gens)\n",
        "    for i in range(N//Np):\n",
        "        anntests += 1\n",
        "        if 1 in gens[Np*i:Np*(i+1)]: # on teste les Np individus rassemblés\n",
        "            for i in range(Np*i,Np*(i+1)):\n",
        "                anntests += 1 # si pool positif, on les teste tous\n",
        "    if N%Np != 0: # s'il reste des gens à la fin\n",
        "        lasts = gens[Np*(N//Np):]\n",
        "        anntests += 1\n",
        "        if len(lasts) > 1:\n",
        "            if 1 in lasts: # on fait un pool avec tous ces gens\n",
        "                anntests += len(lasts)\n",
        "    return(anntests)\n",
        "\n",
        "res = round(squarepools(10, 0.01), 2)\n",
        "print(res)\n",
        "print('Lecture : on peut tester 100 personnes en effectuant seulement {} tests en moyenne'.format(res))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "11.0\n",
            "Lecture : on peut tester 100 personnes en effectuant seulement 11.0 tests en moyenne\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BVC0UTHjQ82U",
        "colab_type": "text"
      },
      "source": [
        "On observe que cette méthode est bien plus efficace que la dernière, permettant de diviser par presque 10 le nombre de tests nécessités."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e2L6UlRTWsfn",
        "colab_type": "text"
      },
      "source": [
        "### 3) Le pooling par dichotomie"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VynOMoU3aep4",
        "colab_type": "text"
      },
      "source": [
        "![Schéma du fonctionnement du pooling par dichotomie](https://members.loria.fr/ADeleforge/wp-content/blogs.dir/192/files/sites/192/2020/04/pool-testing1-768x628.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tEE4UotVa7eH",
        "colab_type": "text"
      },
      "source": [
        "Schéma du fonctionnement du pooling par dichotomie ( [source: Antoine Deleforge,  LORIA](https://members.loria.fr/ADeleforge/les-maths-du-group-testing-melanger-des-prelevements-pour-accelerer-la-detection-du-covid-19/) )\n",
        "\n",
        "Remarque: On n'a pas besoin de tester le pool 5, car le pool 4 est négatif, on est ainsi sur que le/les cas positifs se trouvent dans le reste des échantillons."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tL-2b-xhWsfo",
        "colab_type": "code",
        "outputId": "6be82da4-237b-49b7-96bb-e11d1d717613",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "def dichotest(gens): # test un pool de 2^k gens recursivement\n",
        "    if len(gens) == 1 or max(gens) == 0:\n",
        "        return(1)\n",
        "    else:\n",
        "        l = len(gens)\n",
        "        if max(gens[:l//2]) == 0:\n",
        "            return(dichotest(gens[l//2:]) + 1)\n",
        "        else:\n",
        "            return(dichotest(gens[l//2:]) + dichotest(gens[:l//2]) + 1)\n",
        "        \n",
        "def dichopools(k, p, N=N): # on appelle dichotest successivement, pools de 2**k gens, taux de contamination p\n",
        "    Np = 2**k\n",
        "    pools = N//2**k\n",
        "    tests = 0\n",
        "    gens = [rd.choices([0,1], [1-p,p])[0] for i in range(N)]\n",
        "    for i in range(pools):\n",
        "        tests += dichotest(gens[Np*i:Np*(i+1)])\n",
        "    if N%(2**k) != 0: # Si la taille de la population n'est pas un multiple de Np, on traite la fin avec annexe\n",
        "        fin = gens[Np*pools:]\n",
        "        testsfin = annexe(10, fin)\n",
        "        tests += testsfin\n",
        "    return(100*tests/len(gens))\n",
        "\n",
        "res = round(dichopools(6, 0.01),2)\n",
        "print(res)\n",
        "print('Lecture : on peut tester 100 personnes en effectuant seulement {} tests en moyenne'.format(res))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8.95\n",
            "Lecture : on peut tester 100 personnes en effectuant seulement 8.95 tests en moyenne\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RQ8Zo22vR-Is",
        "colab_type": "text"
      },
      "source": [
        "On voit que le résultat est encore meilleur, avec yne efficacité plus que décuplée. Cependant, cette méthode est plus dure à appliquer en pratique. En effet, dans ce cas ci, elle nécessite de faire des pools de 64 personnes, ce qui ne permet pas toujours une détection de chaque cas, les échantillons individuels étant trop dilués."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "46vKWcF2Wsfs",
        "colab_type": "text"
      },
      "source": [
        "# II] Les résultats des tests en graphique"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8QtF3B4ZWsfs",
        "colab_type": "text"
      },
      "source": [
        "### 1) Les résultats du pooling simple en fonction du taux de contamination et de la taille des pools"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DXgBMajoWsfu",
        "colab_type": "code",
        "outputId": "74ec5a88-7662-4b49-99ab-a896f699ae9e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 317
        }
      },
      "source": [
        "def efficacite_func(func): # Une fonction pour différents p et Np\n",
        "    minpool = 2\n",
        "    maxpool = 24\n",
        "    pools = [int(1.5**Np) for Np in range(minpool, maxpool)] # echantillon de tailles de pools pour graphique semi-log\n",
        "    ntest = []\n",
        "    print('taille des pools:', pools)\n",
        "    a=[]\n",
        "    for p in range(4):\n",
        "        ntest = []\n",
        "        for Np in pools:\n",
        "            ntest.append(func(Np, 10**(-p-1)))\n",
        "        a.append(ntest)\n",
        "    for i in range(4):\n",
        "        plt.plot(pools, a[i], label = 'taux 1e-{}'.format(i+1))\n",
        "    plt.xscale('log')\n",
        "    plt.ylabel('nombre de tests nécessaires')\n",
        "    plt.xlabel('taille des pools')\n",
        "    plt.legend(loc = 'best')\n",
        "    plt.show()\n",
        "    return()\n",
        "\n",
        "efficacite_func(simplepools)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "taille des pools: [2, 3, 5, 7, 11, 17, 25, 38, 57, 86, 129, 194, 291, 437, 656, 985, 1477, 2216, 3325, 4987, 7481, 11222]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "()"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TOICWB-YchHs",
        "colab_type": "text"
      },
      "source": [
        "Lecture : Pour un taux de contamination de 1%, en choisissant des pools de 11 personnes, on peut tester 100 personnes en environ 20 tests"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I5af4L_UWsfy",
        "colab_type": "text"
      },
      "source": [
        "### 2) Comparaison  sur  l'efficacité des différentes sorte de pooling en fonction de la taille des pools"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_tUT8QtiWsfz",
        "colab_type": "code",
        "outputId": "f7acb35c-0e13-498b-d8d3-17549c6c06c6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 368
        }
      },
      "source": [
        "def comparer_funcs(p): # les trois fonctions pour un taux de contamination et (différentes tailles de pools)\n",
        "    minpool = 2\n",
        "    maxpool = 16\n",
        "    pools = [int(1.4**Np) for Np in range(minpool, maxpool)]\n",
        "    # pools=range(minpool,maxpool)\n",
        "    ntest = []\n",
        "    for func in [simplepools, squarepools, dichopools]:\n",
        "        ntest = []\n",
        "        for Np in pools:\n",
        "            ntest.append(func(Np, p))\n",
        "        plt.plot(pools, ntest, label = '{}'.format(func.__name__)) \n",
        "        print('Le nombre de tests mininimum pour ' + str(func.__name__) + ' est ' + str(round(min(ntest),2)))\n",
        "    plt.xscale('log')\n",
        "    plt.ylabel('nombre de tests nécessaires')\n",
        "    plt.xlabel('taille des pools')\n",
        "    plt.legend(loc = 'best')\n",
        "    print('taille des pools:', pools)\n",
        "    plt.show()\n",
        "    return()\n",
        "\n",
        "comparer_funcs(0.01)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Le nombre de tests mininimum pour simplepools est 20.0\n",
            "Le nombre de tests mininimum pour squarepools est 8.8\n",
            "Le nombre de tests mininimum pour dichopools est 10.74\n",
            "taille des pools: [1, 2, 3, 5, 7, 10, 14, 20, 28, 40, 56, 79, 111, 155]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "()"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6vOd8eoXe32g",
        "colab_type": "text"
      },
      "source": [
        "Lecture: La fonction squarepools atteint une efficacité de 9% avec des pools de taille 16.\n",
        "\n",
        "Remarque: la fonction dichopools atteint un plateau. En effet, quand Np est trop grand, on a $2^{Np} > N$, donc on ne peut pas faire de pool et toute la liste est traitée avec le pooling naïf, qui a une efficacité autour de 20%.\n",
        "\n",
        "Le même phénomène est observé avec la fonction squarepools, mais pour des Np plus grands ($Np^2 > N$)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qx3812OrMqqX",
        "colab_type": "text"
      },
      "source": [
        "# III] Optimisation de la taille des pools pour la méthode naïve"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u3mB2O0yEkMK",
        "colab_type": "text"
      },
      "source": [
        "Pour toutes les méthodes qui rassemblent un certains nombre d'individus, on a vu dans les graphiques que la taille de pool choisie influence grandement le résultat. C'est pourquoi il est utile de trouver, pour chaque fonction, et pour un taux de contamination donné, **la taille de pool optimale à utiliser en pratique.**\n",
        "\n",
        "Pour trouver ce minimum, on utilise ici une méthode assez simple et peu efficace constistant à tester toutes les tailles de pools jusqu'à observer une efficacité qui diminue significativement. En effet, les courbes \"*efficacité en fonction de Np*\" sont initialement concave, avec une partie decroissante puis une partie croissante. Il est donc simple d'opérer en s'arrêtant une fois ce creux atteint. Pour être sûr d'avoir trouvé le minimum et non une section croissante simplement due à une coincidence, on continue un peu après le creux trouvé."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cFs-yMV0Wsgx",
        "colab_type": "code",
        "outputId": "fab1a9dd-2134-4b33-c161-58c3ea3a7140",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 313
        }
      },
      "source": [
        "from math import inf\n",
        "\n",
        "def optipool(p, func, graph = False): # trouve la meilleure taille de pool pour un taux p, func=dichopools, squarepools, simplepools\n",
        "    mini = inf\n",
        "    minp = 1\n",
        "    courbe=[]\n",
        "    for i in range(1,100): \n",
        "        s = func(i, p)\n",
        "        courbe.append(s)\n",
        "        if s < mini:\n",
        "            mini = s\n",
        "            minp = i\n",
        "        if s > mini+2: # seuil de sensibilité\n",
        "            if graph: #on affiche ou non la courbe, pour pouvoir réutiliser ça après\n",
        "              plt.plot(range(1, len(courbe)+1), courbe, color='blue')\n",
        "              plt.ylabel('nombre de tests nécessaires')\n",
        "              plt.xlabel('taille de pool')\n",
        "              plt.axvline(minp, color='red')\n",
        "              plt.show\n",
        "            return(minp)\n",
        "    return(minp)\n",
        "func=simplepools\n",
        "a=optipool(0.02, func, True)\n",
        "print(a)\n",
        "print('Lecture: Pour un taux de positifs de 2%, il faut choisir des pools de taille 2^{} pour utiliser la fonction {} optimalement'.format(a,func.__name__))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n",
            "Lecture: Pour un taux de positifs de 2%, il faut choisir des pools de taille 2^7 pour utiliser la fonction simplepools optimalement\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wMJKS2X3kqM9",
        "colab_type": "text"
      },
      "source": [
        "Cette méthode n'est pas la plus efficace, mais elle trouve bien le minimum. Cependant, à cause de la nature aléatoire de la génération de la population, le résultat varie légèrement entre chaque calcul. On voit que ce n'est pas très grave, car la courbe est généralement assez plate autour du minimum, ce qui indique que même si l'on est pas exactement au minimum, on a à peu près la même efficacité."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZAdFk3yFHebA",
        "colab_type": "code",
        "outputId": "9b38a8c4-574f-4cee-b871-e89e219a86a7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        }
      },
      "source": [
        "taux = [.2, .1, .05, .01, .005, .001, .0001] #on choisit un echantillon de taux\n",
        "N=1000 # on prend un N petit car sinon la méthode est trop lente, mais on y perd en précision\n",
        "def optigen(taux, func): # on calcule le Np optimal pour tous ces taux\n",
        "    optis = []\n",
        "    for p in taux:\n",
        "        optis.append(optipool(p, func))\n",
        "    return(optis)\n",
        "op = optigen(taux,simplepools)\n",
        "plt.yscale('log')\n",
        "plt.xscale('log')\n",
        "plt.plot(taux, op)\n",
        "plt.ylabel('taille de pool optimale')\n",
        "plt.xlabel('taux de contamination')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3, 4, 7, 10, 12, 26, 66]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 103
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xd-BwmH9IKef",
        "colab_type": "text"
      },
      "source": [
        "On observe une courbe quasi linéaire, ce qui suggère qu'il existerait une relation linéaire entre le log du Np optimal et le log du taux de contamination. De plus, la courbe varie considérablement entre les exécutions: cela vient des variations du Np optimal entre chaque exécution.\n",
        "\n",
        "Comme la courbe est proche d'une droite, il est intéressant d'effectuer une régression linéaire sur ces données pour tenter de trouver une relation intrinsèque entre les tailles de pools optimales et le taux de contamination.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tgxd_WM-Gcge",
        "colab_type": "code",
        "outputId": "136705b2-ff77-4f66-beee-08b54d3ffbff",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 319
        }
      },
      "source": [
        "bonsNp = [3, 4, 5, 12, 17, 32, 86] # tailles obtenues avec N = 100 000\n",
        "#On utilise ces données car elles sont plus précises que celles obtenues avec N=1000, ceci accélère le processus\n",
        "from scipy.stats import linregress\n",
        "from math import log, exp\n",
        "tauxlog = [log(x) for x in taux]\n",
        "Nplog = [log(y) for y in bonsNp]\n",
        "slope, intercept, r_value, p_value, std_err = linregress(tauxlog, Nplog)\n",
        "print('r**2 = ', round(r_value**2, 5))\n",
        "print('p valeur = ', p_value)\n",
        "x=np.linspace(1e-4, .2)\n",
        "y=[exp(slope*log(i) + intercept) for i in x]\n",
        "plt.plot(x, y, label = 'régression linéaire')\n",
        "plt.plot(taux, bonsNp, label = 'données théoriques')\n",
        "plt.yscale('log')\n",
        "plt.xscale('log')\n",
        "plt.legend(loc = 'best')\n",
        "\n",
        "plt.ylabel('taille de pool optimale')\n",
        "plt.xlabel('taux de contamination')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "r**2 =  0.99738\n",
            "p valeur =  1.195595538861953e-07\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MU_BYxIHra4A",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "On voit que la regression linéaire est extrêmement précise: on a un $r^2$ de 0,997, très proche de 1, et une p-valeur de $1.2*10^{-7}$, ce qui est quasi nul. Ainsi, ceci suggère qu'il existe en effet, pour le cas du pooling naïf, une relation mathématique linéaire entre le log du Np optimal et le log du taux de contamination.\n",
        "\n",
        "Ces résultats peuvent donc être utilisés pour nous donner instantanément la taille de pool à utiliser en fonction du taux de positifs observé, avec la fonction suivante.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cyrqv5_KKl52",
        "colab_type": "code",
        "outputId": "47c77950-dcc7-49a7-83d8-c8d75069c03d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "def pool_optimal(p):\n",
        "  Np=exp(slope*log(p) + intercept)\n",
        "  return(int(round(Np)))\n",
        "\n",
        "\n",
        "print('taille de pool optimale pour un taux de contamination de 1%:', pool_optimal(.01))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "taille de pool optimale pour un taux de contamination de 1%: 11\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tMSaBzJyVY_q",
        "colab_type": "text"
      },
      "source": [
        "Test unitaire du succés de la regression linéaire"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XTUNFfruVXrF",
        "colab_type": "code",
        "outputId": "18ea8800-d411-419a-b3a6-e3fa875e18fc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        }
      },
      "source": [
        "import unittest\n",
        "\n",
        "class TestStringMethods(unittest.TestCase):\n",
        "\n",
        "    def test_pool_optimal(self):\n",
        "      self.assertEqual(pool_optimal(0.01), 11)\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    unittest.main(argv=['first-arg-is-ignored'], exit=False)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            ".\n",
            "----------------------------------------------------------------------\n",
            "Ran 1 test in 0.001s\n",
            "\n",
            "OK\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ld6GnBJdWsf9",
        "colab_type": "text"
      },
      "source": [
        "# VI] Comment prendre en compte les clusters?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wf8_ITQQWsf-",
        "colab_type": "text"
      },
      "source": [
        "### Quelques réglages"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CSDC3a0-Wsf_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "N1 = 50000 # nombre d'individus du groupe 1 (= pop générale)\n",
        "N2 = 1000 # nombre d'individus du groupe 2 (cluster)\n",
        "N = N1 + N2 # pop totale\n",
        "p1 = 0.01 # taux de contamination du groupe 1\n",
        "p2 = 0.2 # taux de contamination du groupe 2\n",
        "tests = 0\n",
        "gens1 = [rd.choices([0,1], [1-p1,p1])[0] for i in range(N1)] # liste des gens du groupe 1\n",
        "gens2 = [rd.choices([0,1], [1-p2,p2])[0] for i in range(N2)] # liste des gens du groupe 2\n",
        "Np1 = pool_optimal(p1) # La taille des pools, obtenue avec la regression linéaire\n",
        "Np2 = pool_optimal(p2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7xLSn6ZwWsgD",
        "colab_type": "text"
      },
      "source": [
        "### 1) Le pooling simple en mélangeant les individus des deux groupes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3kJoWLHsWsgE",
        "colab_type": "code",
        "outputId": "f7871e44-9734-4cdf-9d8d-c08ecdd47690",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "def melange_groupe (Np, gens1, gens2):\n",
        "    gens = gens1 + gens2 \n",
        "    rd.shuffle(gens) # mélange des deux populations\n",
        "    tests = 0\n",
        "    for i in range(N//Np):\n",
        "        tests += 1\n",
        "        if max(gens[Np*i:Np*(i+1)]) == 1: # on teste tous individus rassemblés dans les pools\n",
        "            for i in range(Np*i, Np*(i+1)):\n",
        "                tests += 1 # si pool positif, on les teste tous\n",
        "    if N%Np != 0: # s'il reste des gens à la fin\n",
        "        lasts = gens[Np*(N//Np):]\n",
        "        tests += 1\n",
        "        if len(lasts) > 1:\n",
        "            if max(lasts) == 1: # on fait un pool avec tous ces gens\n",
        "                tests += len(lasts)\n",
        "    return(100*tests/len(gens))\n",
        "\n",
        "res = round(melange_groupe(Np1, gens1, gens2),2)\n",
        "print(res)\n",
        "print('Lecture : on peut tester 100 personnes en effectuant seulement {} tests en moyenne'.format(res))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "22.66\n",
            "Lecture : on peut tester 100 personnes en effectuant seulement 22.66 tests en moyenne\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v-voa-ESWsgH",
        "colab_type": "text"
      },
      "source": [
        "### 2) Le pooling simple en séparant les individus de la population générale et des clusters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZVXuT77ZWsgI",
        "colab_type": "code",
        "outputId": "a0a30d10-8442-4dbd-b642-912b756aa08c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "# Le nombre de tests pour la population générale :\n",
        "def pop_gen(Np, p1, gens1, N1):\n",
        "    tests = 0\n",
        "    N = len(gens1)\n",
        "    for i in range(N1//Np):\n",
        "        tests += 1\n",
        "        if max(gens1[Np*i:Np*(i+1)]) == 1: # on teste tous individus rassemblés\n",
        "            for i in range(Np*i, Np*(i+1)):\n",
        "                tests += 1 # si pool positif, on les teste tous\n",
        "    if N%Np != 0: # s'il reste des gens à la fin\n",
        "        lasts = gens1[Np*(N//Np):]\n",
        "        tests += 1\n",
        "        if len(lasts)>1:\n",
        "            if max(lasts) == 1: # on fait un pool avec tous ces gens\n",
        "                tests += len(lasts)\n",
        "    return(tests)\n",
        "\n",
        "# Le nombre de tests pour le cluster :\n",
        "def clus(Np, p2, gens2, N2):\n",
        "    tests = 0\n",
        "    N = len(gens2)\n",
        "    for i in range(N2//Np):\n",
        "        tests += 1\n",
        "        if max(gens2[Np*i:Np*(i+1)]) == 1: # on teste tous individus rassemblés\n",
        "            for i in range(Np*i,Np*(i+1)):\n",
        "                tests += 1 # si pool positif, on les teste tous\n",
        "    if N%Np != 0: # s'il reste des gens à la fin\n",
        "        lasts = gens2[Np*(N//Np):]\n",
        "        tests += 1\n",
        "        if len(lasts) > 1:\n",
        "            if max(lasts) == 1: # on fait un pool avec tous ces gens\n",
        "                tests += len(lasts)\n",
        "    return(tests)\n",
        "\n",
        "# Le nombre de test en tout\n",
        "test_sep = pop_gen(Np1, p1, gens1, N1) + clus(Np2, p2, gens2, N2)\n",
        "res = round((100*test_sep)/len(gens1+gens2),2)\n",
        "print(res)\n",
        "print('Lecture : on peut tester 100 personnes en effectuant seulement {} tests en moyenne'.format(res))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "20.76\n",
            "Lecture : on peut tester 100 personnes en effectuant seulement 20.76 tests en moyenne\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S6RLdFd6WsgK",
        "colab_type": "text"
      },
      "source": [
        "### 3) Résultats de la comparaison"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2qHphWArWsgL",
        "colab_type": "text"
      },
      "source": [
        "&nbsp;&nbsp;&nbsp;&nbsp;En effectuant plusieurs fois les deux programmes avec différents paramètres, on remarque qu'il est toujours préférable de tester les deux groupes séparément. \n",
        "La méthode séparée permet certes d'économiser des tests, mais la différence d'efficacité n'est pas très élevée, et  l'écart n'est en moyenne pas plus élevé que 3 points de pourcentage.\n",
        "\n",
        "&nbsp;&nbsp;&nbsp;&nbsp;Ce résultat s'avère logique. En effet, en testant séparément, on peut utiliser des tailles de pools optimales pour chacune des populations, et avoir ainsi un meilleur résultat. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bXMDRyPbWsgL",
        "colab_type": "text"
      },
      "source": [
        "# IV] Prendre en compte les familles dans la conception des pools de tests"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p4gfZqC29uLH",
        "colab_type": "text"
      },
      "source": [
        "Pour modéliser le fait que les individus sont confinés en groupes fixes, on procède de la manière suivante: on effectue des groupes de taille aléatoire variant entre 1 et 5 dans la population totale, et on distingue 2 types de familles (*cocons*): les cocons sains, où chaque individu a une probabilité *ps* faible d'être malade, et les cocons contaminés, où cette probabilité est *pc*, bien plus proche de 1. On fait l'hypothèse qu'une fois le virus entré dans un ménage, il se répand rapidement entre ses habitants.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ndhDtyVeWsgM",
        "colab_type": "text"
      },
      "source": [
        "### 1) Lister les familles"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ER5GVotnWsgM",
        "colab_type": "code",
        "outputId": "239aedf4-f9f1-471b-8fd2-cff1093373ce",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# quelques réglages\n",
        "N = 100000 # nombre d'individus\n",
        "ps = 0.01 # taux de contamination dans les concons sains\n",
        "c = 0.02 # taux de cocons contaminés\n",
        "s = 1-c\n",
        "pc = 0.9 # taux de contamination dans les cocons contaminés\n",
        "p = c*pc + s*ps # taux global\n",
        "tests = 0\n",
        "sq = 10\n",
        "print('taux de contamination global:', round(p, 5))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "taux de contamination global: 0.0278\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GoHFw2JhWsgR",
        "colab_type": "text"
      },
      "source": [
        "Des fonctions annexes pour les listes de familles :\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i4aYYOdZWsgS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def infs(gens):\n",
        "    return(sum([sum(i) for i in gens]))\n",
        "def long(gens):\n",
        "    return(sum([len(i) for i in gens]))\n",
        "\n",
        "def taux(gens):\n",
        "    return(infs(gens)/long(gens))\n",
        "\n",
        "def bettermax(L): # cherche s'il y a un 1 dans une des sous listes\n",
        "    a = True\n",
        "    N = len(L)\n",
        "    i = 0\n",
        "    while a and i < N:\n",
        "        if 1 in L[i]:\n",
        "            return(True) # on s'arrête dès le premier cas trouvé\n",
        "        i += 1\n",
        "    return(False)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lZxExJ7-Wsga",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def cocons(N=N, ps=ps, pc=pc, c=c): # on génère la liste des familles\n",
        "    g = 0\n",
        "    gens = []\n",
        "    while g < N:\n",
        "        k = rd.randint(1,5) # familles de taille aléatoire entre 1 et 5\n",
        "        g += k\n",
        "        a = rd.choices([0,1], [1-c,c])[0] # décide si une famille est contaminée ou non\n",
        "        if a == 1:\n",
        "            cocon = rd.choices([0,1], [1-pc, pc], k=k)\n",
        "        else:\n",
        "            cocon = rd.choices([0,1], [1-ps, ps], k=k)\n",
        "        gens.append(cocon)\n",
        "    return(gens)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W-MHQEfFWsge",
        "colab_type": "text"
      },
      "source": [
        "On teste la famille regroupée dans un seul *pool*, et si le résultat est positif, on teste tous les membres de la famille."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RdvjEg_yWsgf",
        "colab_type": "code",
        "outputId": "41fce54e-8ad2-4d67-ade1-3f74bfa9268e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "def coconpooling(N=N, ps=ps, pc=pc, c=c):\n",
        "    gens = cocons(N, ps, pc, c)\n",
        "    tests = 0\n",
        "    for i in gens:\n",
        "        tests += 1\n",
        "        if 1 in i:\n",
        "            if len(i) > 1:\n",
        "                tests += len(i)\n",
        "    return(100*tests/long(gens))\n",
        "\n",
        "coconpooling()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "38.419"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 98
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XFlvjbnBWsgk",
        "colab_type": "text"
      },
      "source": [
        "On fait la même chose, mais en ayant rassemblé 3 familles avant"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g383en8EWsgl",
        "colab_type": "code",
        "outputId": "4380b866-5acf-4afc-a8a7-0d7f34b58e66",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "def cocongrouping(g, N=N, ps=ps, pc=pc, c=c):\n",
        "    p = c*pc + s*ps\n",
        "    gens = cocons(N, ps, pc, c)\n",
        "    tests = 0\n",
        "    f = len(gens)\n",
        "    for i in range(f//g):\n",
        "        tests += 1\n",
        "        if bettermax(gens[g*i:g*(i+1)]):\n",
        "            tests += long(gens[g*i:g*(i+1)])\n",
        "    if f%g != 0:\n",
        "        tests += 1\n",
        "        if bettermax(gens[f//g*g:]):\n",
        "            tests += long(gens[f//g*g:])\n",
        "    return(100*tests/long(gens))\n",
        "\n",
        "round(cocongrouping(3), 4)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "25.736"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 99
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gq1c5-mPWsgs",
        "colab_type": "text"
      },
      "source": [
        "### 2) Le square pooling adapté au familles"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B7Ut5RDFCWRJ",
        "colab_type": "text"
      },
      "source": [
        "On effectue ici du square pooling en remplaçant les individus par des familles entières."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8P25gpGcWsgs",
        "colab_type": "code",
        "outputId": "40a40655-49c0-4f50-f230-0312abf8a07e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "def testmatsquare(gens=gens, sq=sq, tests=tests):\n",
        "    col = []\n",
        "    lin = []\n",
        "    for i in range(sq):\n",
        "        tests += 1\n",
        "        if bettermax(gens[i]): # on teste toute la ligne\n",
        "            lin.append(i)\n",
        "    if lin != []: # on continue que si y'a au moins un positif\n",
        "        for j in range(sq):\n",
        "            if bettermax(gens[:,j]): # on teste toute la colonne\n",
        "                col.append(j)\n",
        "    if len(lin) == 1: # si une seule ligne positive, on peut conclure\n",
        "        a = lin[0]\n",
        "        for j in col:\n",
        "            tests += len(gens[a,j])\n",
        "    elif len(col) == 1:# si une seule colonne positive, on peut conclure\n",
        "        b = col[0]\n",
        "        for i in lin:\n",
        "            tests += len(gens[i,b])\n",
        "    else:\n",
        "        possibles = []\n",
        "        for i in lin:\n",
        "            for j in col:\n",
        "                possibles.append((i,j))# on ajoute aux possibles les intersection\n",
        "        for i in possibles:\n",
        "            tests += len(i)\n",
        "    return(tests)\n",
        "\n",
        "def squarefam(sq, N=N):\n",
        "    gens = cocons(N, ps, pc, c)\n",
        "    N = len(gens)\n",
        "    Np = sq**2 # sq la taille du coté, Np la taille du pool\n",
        "    pools = int(N/Np)\n",
        "    tests = 0\n",
        "    for k in range(pools):\n",
        "        square = np.reshape(gens[Np*k:Np*(k+1)], (sq,sq)) # on fait une matrice carré sq*sq\n",
        "        t = testmatsquare(square, sq)\n",
        "        tests += t\n",
        "    if N%Np != 0: # s'il reste des gens\n",
        "        fin = gens[Np*pools:]\n",
        "        testsfin = coconpoolingannexe(fin, 10, p, fin) # on utilise l'annexe sur la fin\n",
        "        tests += testsfin\n",
        "    return(100*tests/long(gens))\n",
        "\n",
        "def coconpoolingannexe(fin, N=N, ps=ps, pc=pc, c=c): # fonction annexe pour faire du coconpooling dans l'autre\n",
        "    tests = 0\n",
        "    for i in fin:\n",
        "        tests += 1\n",
        "        if 1 in i:\n",
        "            if len(i)>1:\n",
        "                tests += len(i)\n",
        "    return(tests)\n",
        "\n",
        "res = round(squarefam(5),2)\n",
        "print(res)\n",
        "print('Lecture : on peut tester 100 personnes en effectuant seulement {} tests en moyenne'.format(res))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "13.03\n",
            "Lecture : on peut tester 100 personnes en effectuant seulement 13.03 tests en moyenne\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3eY8jZP6ZZgX",
        "colab_type": "text"
      },
      "source": [
        "# Conclusion"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i1oSrLGZPIlt",
        "colab_type": "text"
      },
      "source": [
        "&nbsp;&nbsp;&nbsp;&nbsp;En nous inspirant de la situation actuelle d’épidémie et des nouvelles problématiques qu’elle engendre, nous avons essayé de résoudre une question concrète en nous penchant sur les tests effectués. Nous avons montré qu’en mettant en place des méthodes de pooling et en utilisant les tailles de pools les plus adaptées possibles, le nombre de test pouvait être réduit. Ainsi, en adoptant la méthode la plus efficace, pour un taux de contamination et une taille de population donnés, toute la population peut être testée avec 10 fois moins de tests que si on testait chaque individu.\n",
        "\n",
        "&nbsp;&nbsp;&nbsp;&nbsp;Ces méthodes ont cependant des limites techniques. Dans les faits, les pools ne peuvent rassembler plus d'environ 30 échantillons, selon la méthode de test choisie. En effet, si trop d’échantillons sont regroupés, le test n’est plus assez sensible et risque de ne pas détecter une personne infectée. De plus, la gestion de méthodes comme le pooling en carré ou la méthode par dichotomie peut, en pratique, être difficile à mener. Il faut que le laboratoire suive très précisément les trajectoires de chaque échantillon, et ces méthodes demandent beaucoup de manipulations. En effet, chaque échantillon peut être utilisé plusieurs fois et doit être conservé un certain temps.\n",
        "\n",
        "&nbsp;&nbsp;&nbsp;&nbsp;Bien qu’elles ne soient pas parfaites, ces méthodes restent un atout dans la lutte contre les épidémies. Si ces méthodes étaient mises en place, elles permettraient de tester plus d’individus plus rapidement. A travers notre projet, nous voulions montrer que les débutants en programmation pouvaient être utiles, en évaluant virtuellement le nombre de tests nécessaires avant de l’appliquer aux individus."
      ]
    }
  ]
}