noise_free_FFP10.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "noise-free FFP10.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/M-torki/C-S-NN/blob/master/noise_free_FFP10.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y0FqJ5G2eLUT"
      },
      "source": [
        "%tensorflow_version 1.x"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jdDE1cHNzu7V",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "08f9b301-ad1d-4a65-b411-2908eeb4f75d"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/gdrive')"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /gdrive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DBRApUn60GW-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a891b8b1-4b46-4a93-bc9b-d6fcc334a3cd"
      },
      "source": [
        "cd /gdrive/My\\ Drive/"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/gdrive/My Drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jlzeLeyD0O9O",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4864d983-cb35-4a4c-c39d-3a8bed71b45c"
      },
      "source": [
        "!pip install git+https://github.com/vafaei-ar/ccgpack.git"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting git+https://github.com/vafaei-ar/ccgpack.git\n",
            "  Cloning https://github.com/vafaei-ar/ccgpack.git to /tmp/pip-req-build-uld18eu7\n",
            "  Running command git clone -q https://github.com/vafaei-ar/ccgpack.git /tmp/pip-req-build-uld18eu7\n",
            "Building wheels for collected packages: ccgpack\n",
            "  Building wheel for ccgpack (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for ccgpack: filename=ccgpack-0.1.0-cp37-cp37m-linux_x86_64.whl size=910057 sha256=33dbd5080e450b2993d926eac1c8c00301d791d627bd5e3ec10a3e34ecf3d64b\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-zut5r0wa/wheels/a8/3c/86/3720d002b7c606972520b7468f7b9daf3da3acc3052facac45\n",
            "Successfully built ccgpack\n",
            "Installing collected packages: ccgpack\n",
            "Successfully installed ccgpack-0.1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "olxnYZCw0ROW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cb85202c-0adf-4dc9-8648-e7bb4397aa0a"
      },
      "source": [
        "!pip install git+https://github.com/vafaei-ar/Ngene.git"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting git+https://github.com/vafaei-ar/Ngene.git\n",
            "  Cloning https://github.com/vafaei-ar/Ngene.git to /tmp/pip-req-build-c4mijchy\n",
            "  Running command git clone -q https://github.com/vafaei-ar/Ngene.git /tmp/pip-req-build-c4mijchy\n",
            "Building wheels for collected packages: ngene\n",
            "  Building wheel for ngene (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for ngene: filename=ngene-0.1.0-cp37-none-any.whl size=11659 sha256=506c4c3133e42c2c420fd3d03993c0e4c2e1f6174a4fc884fe56b0cda69e68fe\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-4btw3prp/wheels/f7/d2/a8/1dae975d187b4a9790d83da45caaef0d018b41ffc0ab7fceb7\n",
            "Successfully built ngene\n",
            "Installing collected packages: ngene\n",
            "Successfully installed ngene-0.1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nfu7npzh0XwH"
      },
      "source": [
        "import sys\n",
        "sys.path.append('/gdrive/My\\ Drive/git_reps/ccgpack')\n",
        "sys.path.append('/gdrive/My\\ Drive/git_reps/Ngene')"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hxvYtMsz0aGd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a45211b9-daa2-4f81-c361-04e782244093"
      },
      "source": [
        "import os\n",
        "import ngene as ng\n",
        "import numpy as np\n",
        "import pylab as plt\n",
        "from glob import glob\n",
        "import tensorflow as tf\n",
        "from random import choice,shuffle\n",
        "import cv2 as cv\n",
        "# import healpy as hp"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:From /tensorflow-1.15.2/python3.7/tensorflow_core/python/compat/v2_compat.py:68: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "non-resource variables are not supported in the long term\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WaffeWZR0ccF"
      },
      "source": [
        "def conf_plotter(y_true, y_pred, classes,\n",
        "                      normalize=0,\n",
        "                      title=None,\n",
        "                      cmap=plt.cm.pink_r,\n",
        "                      mode = 'train',\n",
        "                      save = 0,\n",
        "                      name = 'conf.jpg'):\n",
        "\n",
        "    if not title:\n",
        "        if mode == 'train':\n",
        "            title = 'Normalized confusion matrix on train dataset'\n",
        "        if mode == 'test':\n",
        "            title = 'Normalized confusion matrix on test dataset'\n",
        "        if mode == 'prob':\n",
        "            title = 'Normalized confusion matrix on Non-Overlapping test dataset'\n",
        "            \n",
        "\n",
        "    from sklearn.metrics import confusion_matrix\n",
        "    \n",
        "    cm = confusion_matrix(y_true, y_pred)\n",
        "\n",
        "    if normalize:\n",
        "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
        "\n",
        "\n",
        "    fig, ax = plt.subplots(figsize=(9,9))\n",
        "    im = ax.imshow(cm, cmap=cmap)\n",
        "    ax.figure.colorbar(im, ax=ax ,fraction=0.046, pad=0.04)\n",
        "    ax.set(xticks=np.arange(cm.shape[0]),\n",
        "           yticks=np.arange(cm.shape[1]),\n",
        "           xticklabels=classes, yticklabels=classes,\n",
        "           title=title,\n",
        "           ylabel= 'True label',\n",
        "           xlabel='Predicted label')\n",
        "    \n",
        "    for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] ):\n",
        "                    \n",
        "        item.set_fontsize(15)\n",
        "     \n",
        "    for item in (ax.get_xticklabels() + ax.get_yticklabels()):\n",
        "        \n",
        "        item.set_fontsize(12)\n",
        "\n",
        "                \n",
        "    plt.gca().invert_yaxis()\n",
        "    plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\",\n",
        "             rotation_mode=\"anchor\")\n",
        "\n",
        "    fmt = '.2f' if normalize else 'd'\n",
        "    thresh = cm.max() / 2.\n",
        "    for i in range(cm.shape[0]):\n",
        "        for j in range(cm.shape[1]):\n",
        "            ax.text(j, i, format(cm[i, j], fmt),\n",
        "                    ha=\"center\", va=\"center\",\n",
        "                    color=\"white\" if cm[i, j] > thresh else \"black\")\n",
        "    fig.tight_layout()\n",
        "    if save == 1:\n",
        "        plt.savefig(name)\n",
        "    return ax"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rr1SXKWM0eya",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5c0c7694-643e-464d-c24b-b4c8488782a7"
      },
      "source": [
        "(np.load('./data/test/string_p/24.npy')).std()"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14.9875145"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ooyC8ptE0j4G",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d2c63cd6-11ea-4135-ee03-a6ec59ea30c2"
      },
      "source": [
        "(np.load('./data/ffp10_p/401.npy')).std()"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.00010234469"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UMBFFBuu0lSh"
      },
      "source": [
        "def get_slice(data,nx,ny):\n",
        "    \"\"\"Slice matrix in x and y direction\"\"\"\n",
        "    lx,ly = data.shape  \n",
        "    if nx==0 or nx==lx:\n",
        "        slx = slice(0, lx)                \n",
        "    else:\n",
        "        idx = np.random.randint(0, lx - nx)            \n",
        "        slx = slice(idx, (idx+nx))       \n",
        "    if ny==0 or ny==ly:\n",
        "        sly = slice(0, ly)                \n",
        "    else:\n",
        "        idy = np.random.randint(0, ly - ny)            \n",
        "        sly = slice(idy, (idy+ny))\n",
        "    return slx, sly"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z_R1hzhU0pyQ"
      },
      "source": [
        "\n",
        "class OrganizedDataProvider(object):\n",
        "    def __init__(self,n_files,s_files,gmus,\n",
        "                 nx=0,ny=0,n_buffer=10,\n",
        "                 reload_rate=100,filt=None , test=0):\n",
        "\n",
        "        self.n_files = n_files\n",
        "        self.s_files = s_files\n",
        "        self.test = test\n",
        "\n",
        "        nmin = min(len(n_files),len(s_files))\n",
        "        if n_buffer>= nmin:\n",
        "            n_buffer = nmin\n",
        "            self.reload_rate = 0\n",
        "        else:\n",
        "            self.reload_rate = reload_rate\n",
        "\n",
        "        self.nx,self.ny = nx,ny\n",
        "        self.n_buffer = n_buffer\n",
        "        self.gmus = gmus\n",
        "        if filt is None:\n",
        "            def filt(x):\n",
        "                return x\n",
        "        self.filt = filt\n",
        "        self.counter = 0\n",
        "        self.reload()\n",
        "\n",
        "    def reload(self):\n",
        "        print('Data provider is reloading...')\n",
        "        self.n_set = []\n",
        "        self.s_set = []\n",
        "    #        self.d_set = []\n",
        "        nind = np.random.randint(0,len(self.n_files))\n",
        "        \n",
        "        if self.test:\n",
        "            sind = (nind%12)\n",
        "        else:\n",
        "\n",
        "            sind = np.random.randint(1,3)\n",
        "            if sind==1:\n",
        "                sind = (nind%12)\n",
        "            elif sind==2:\n",
        "                sind = (nind%12)+12\n",
        "            \n",
        "#         print('sind' , sind , 'nind' , nind)\n",
        "\n",
        "\n",
        "\n",
        "    #        ninds = np.arange(len(self.n_files))\n",
        "    #        sinds = np.arange(len(self.s_files))\n",
        "    #        shuffle(ninds)\n",
        "    #        shuffle(sinds)\n",
        "        for i in range(self.n_buffer):\n",
        "            filen = self.n_files[nind]\n",
        "            files = self.s_files[sind]\n",
        "            self.n_set.append(np.load(filen))\n",
        "            signal = np.load(files)\n",
        "            self.s_set.append(signal)\n",
        "    #            if self.filt:\n",
        "    #                self.d_set.append(self.filt(signal))\n",
        "    #            else:\n",
        "    #                self.d_set.append(signal)\n",
        "    #            \n",
        "\n",
        "    def get_data(self): \n",
        "        self.counter += 1\n",
        "        if self.reload_rate:\n",
        "            if self.counter%self.reload_rate==0: \n",
        "                self.reload() \n",
        "    #        n = choice(self.n_set)\n",
        "        ind = choice(np.arange(self.n_buffer))\n",
        "        s = self.s_set[ind]\n",
        "        n = self.n_set[ind]\n",
        "#         print('ind' , ind)\n",
        "\n",
        "\n",
        "    #        d = self.d_set[sind]\n",
        "        return n,s#,d\n",
        "\n",
        "\n",
        "    def pre_process(self, n, s, gmu):\n",
        "        sn = n + gmu*s\n",
        "        snslice = get_slice(sn,self.nx,self.ny)\n",
        "        sn = sn[snslice]\n",
        "        #        sslice = get_slice(s,self.nx,self.ny)\n",
        "        #        s = s[sslice]\n",
        "        # sn = self.filt(sn)\n",
        "        sn = cv.bilateralFilter(sn,5,1e-3,1e-3)\n",
        "        # sn = self.filt(sn)\n",
        "\n",
        "        #        d = d[sslice]\n",
        "        sn = np.expand_dims(sn,-1)\n",
        "        #        d = np.expand_dims(d,-1)\n",
        "        return sn#,d\n",
        "\n",
        "    def __call__(self, n, gmus=None): \n",
        "\n",
        "        if gmus is None:\n",
        "            gmus = self.gmus\n",
        "        n_class = len(gmus)\n",
        "        #        x,y = self.get_data()\n",
        "        X = []\n",
        "        Y = []\n",
        "        for i in range(n):                \n",
        "            n,s = self.get_data()\n",
        "            inds = np.arange(n_class)\n",
        "            shuffle(inds)\n",
        "            gmu = gmus[inds[0]]\n",
        "            #            gmu = choice(gmus)\n",
        "            sn = self.pre_process(n,s,gmu)\n",
        "            #            rand = np.random.randint(0,2)\n",
        "            #            sn = sn-sn+rand\n",
        "\n",
        "#             sn = (sn - np.min(sn))/(np.max(sn) - np.min(sn))\n",
        "\n",
        "            sn = (sn - np.mean(sn))/(np.std(sn) + 1e-30)\n",
        "\n",
        "\n",
        "            X.append(sn)\n",
        "            #            Y.append(-np.log10(gmu+1e-30))\n",
        "            lbl = n_class*[0]\n",
        "            lbl[inds[0]] = 1\n",
        "            Y.append(lbl)\n",
        "\n",
        "\n",
        "\n",
        "        X = np.array(X)\n",
        "        Y = np.array(Y)\n",
        "\n",
        "        return X,Y"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6lAZJ5io0snC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "82cc876b-1d27-4584-df62-4cc954d727bb"
      },
      "source": [
        "gmus = [0]+list(5* 10**np.linspace(-8 , -5 , 10))\n",
        "n_class = len(gmus)\n",
        "print(gmus)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 5e-08, 1.0772173450159411e-07, 2.320794416806391e-07, 5e-07, 1.0772173450159411e-06, 2.3207944168063863e-06, 4.9999999999999996e-06, 1.0772173450159412e-05, 2.3207944168063865e-05, 5e-05]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5HrA5vxg02BQ"
      },
      "source": [
        "dofilt = 'y'\n",
        "\n",
        "if dofilt[0]=='y':\n",
        "    import ccgpack as ccg\n",
        "    def filt(x):\n",
        "        return ccg.filters(x,edd_method='sch')\n",
        "else:\n",
        "    filt = None"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pdli9fM10y_W",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6d30aa6c-c611-460e-e91f-b2e52748a912"
      },
      "source": [
        "g_files = sorted(glob('./data/ffp10_p/*.npy'))\n",
        "s_files = sorted(glob('./data/string_p/*.npy'))\n",
        "\n",
        "if len(g_files)*len(s_files)==0:\n",
        "    print('Somthing is wrong with initiation.')\n",
        "    #exit()\n",
        "print(len(g_files),len(s_files))"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "480 24\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8eYtOh6e1BmM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "751a2f45-8da9-480b-f706-905c969fc4a8"
      },
      "source": [
        "g_test = sorted(glob('./data/test/ffp/ffp_ptest/*.npy'))\n",
        "s_test = sorted(glob('./data/test/string_p/*.npy'))\n",
        "\n",
        "# s_test = s_files\n",
        "\n",
        "if len(g_test)*len(s_test)==0:\n",
        "    print('Somthing is wrong with initiation.')\n",
        "#     exit()\n",
        "    \n",
        "print(len(g_test) , len(s_test))"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "99 12\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DSR3tKE8090Q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2fc695c2-eabc-4299-b52b-cc9b60df9a7b"
      },
      "source": [
        "odp = OrganizedDataProvider(g_files,s_files,\n",
        "                              gmus=gmus,\n",
        "                              nx=256,ny=256,n_buffer=10,\n",
        "                              reload_rate=1e5,filt=filt,test=0)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Data provider is reloading...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "49wKTkKB1FAT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "76bff3d6-be64-441d-e5fe-5f94cc8193e8"
      },
      "source": [
        "odp_test = OrganizedDataProvider(g_test,s_test,\n",
        "                                 gmus=gmus,\n",
        "                                 nx=256,ny=256,n_buffer=10,\n",
        "                                 reload_rate=1e5,filt=filt,test=1)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Data provider is reloading...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z-X6xM-M8B2Q",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 340
        },
        "outputId": "ebced689-85a1-401b-8c1e-208f5fe89773"
      },
      "source": [
        "plt.figure(figsize = (5,5))\n",
        "plt.imshow(odp(1)[0][0,:,:,0] , cmap='jet')"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7ff21b767c50>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3jslElUf04fM"
      },
      "source": [
        "def arch_maker(x,n_conv,n_class):\n",
        "\n",
        "    print(\"\\033[91m ============================= Begin ========================= \\033[0m\")\n",
        "    \n",
        "    for _ in range(4):\n",
        "\n",
        "        \n",
        "        x = tf.layers.conv2d(x,filters=4,kernel_size=5,\n",
        "                              strides=(1, 1),padding='same')\n",
        "        print(x)\n",
        "        x = tf.layers.batch_normalization(x)\n",
        "        print(x)\n",
        "        x = tf.nn.crelu(x)\n",
        "        print(x)\n",
        "\n",
        "    for _ in range(n_conv):\n",
        "\n",
        "        x = tf.layers.conv2d(x,filters=8,kernel_size=5,\n",
        "                              strides=(1, 1),padding='same')\n",
        "        print(x)\n",
        "        x = tf.layers.batch_normalization(x)\n",
        "        print(x)\n",
        "        x = tf.nn.crelu(x)\n",
        "        print(x)\n",
        "\n",
        "        x = tf.layers.conv2d(x,filters=16,kernel_size=5,\n",
        "                              strides=(2, 2),padding='same')\n",
        "        print(x)\n",
        "        x = tf.layers.batch_normalization(x)\n",
        "        print(x)\n",
        "        x = tf.nn.crelu(x)\n",
        "        print(x)\n",
        "        x = tf.layers.max_pooling2d(x,pool_size=2,strides=1)\n",
        "        print(x)\n",
        "\n",
        "\n",
        "    x = tf.contrib.layers.flatten(x)\n",
        "    print(x)\n",
        "    x = tf.nn.dropout( x, keep_prob=0.5)\n",
        "    print(x)\n",
        "    x = tf.layers.dense(x, 20 , activation=tf.nn.crelu)\n",
        "    print(x)\n",
        "    x = tf.nn.dropout( x, keep_prob=0.5)\n",
        "    print(x)\n",
        "    y = tf.layers.dense(x, n_class, activation=tf.nn.softmax)\n",
        "    print(y)\n",
        "\n",
        "    print(\"\\033[91m ============================ END ============================= \\033[0m\")\n",
        "\n",
        "    return y"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MLrcs5vq1Kdd"
      },
      "source": [
        "restore = os.path.isdir('./models/model_noisefree_FFP')\n",
        "restore = 1"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pohDirMN13wo"
      },
      "source": [
        "def arch(x):\n",
        "    return arch_maker(x,6,n_class)    "
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kon8OoNV16Rm"
      },
      "source": [
        "def loss(y_true,x_out):\n",
        "    return tf.losses.huber_loss(y_true,x_out)  "
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iLcJkAES18zV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1f6ab132-14ae-46b4-a22e-cb0f2fb8835e"
      },
      "source": [
        "conv = ng.Model(data_provider= odp,\n",
        "                 optimizer=tf.train.AdamOptimizer,\n",
        "                 loss = loss,\n",
        "                 restore=restore,\n",
        "                 model_add= './models/model_noisefree_FFP',\n",
        "                 arch=arch)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[91m ============================= Begin ========================= \u001b[0m\n",
            "WARNING:tensorflow:From <ipython-input-22-41ea81b35345>:9: conv2d (from tensorflow.python.layers.convolutional) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use `tf.keras.layers.Conv2D` instead.\n",
            "WARNING:tensorflow:From /tensorflow-1.15.2/python3.7/tensorflow_core/python/layers/convolutional.py:424: Layer.apply (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Please use `layer.__call__` method instead.\n",
            "Tensor(\"conv2d/BiasAdd:0\", shape=(?, 256, 256, 4), dtype=float32)\n",
            "WARNING:tensorflow:From <ipython-input-22-41ea81b35345>:11: batch_normalization (from tensorflow.python.layers.normalization) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use keras.layers.BatchNormalization instead.  In particular, `tf.control_dependencies(tf.GraphKeys.UPDATE_OPS)` should not be used (consult the `tf.keras.layers.batch_normalization` documentation).\n",
            "Tensor(\"batch_normalization/FusedBatchNormV3:0\", shape=(?, 256, 256, 4), dtype=float32)\n",
            "Tensor(\"CRelu/Relu:0\", shape=(?, 256, 256, 8), dtype=float32)\n",
            "Tensor(\"conv2d_1/BiasAdd:0\", shape=(?, 256, 256, 4), dtype=float32)\n",
            "Tensor(\"batch_normalization_1/FusedBatchNormV3:0\", shape=(?, 256, 256, 4), dtype=float32)\n",
            "Tensor(\"CRelu_1/Relu:0\", shape=(?, 256, 256, 8), dtype=float32)\n",
            "Tensor(\"conv2d_2/BiasAdd:0\", shape=(?, 256, 256, 4), dtype=float32)\n",
            "Tensor(\"batch_normalization_2/FusedBatchNormV3:0\", shape=(?, 256, 256, 4), dtype=float32)\n",
            "Tensor(\"CRelu_2/Relu:0\", shape=(?, 256, 256, 8), dtype=float32)\n",
            "Tensor(\"conv2d_3/BiasAdd:0\", shape=(?, 256, 256, 4), dtype=float32)\n",
            "Tensor(\"batch_normalization_3/FusedBatchNormV3:0\", shape=(?, 256, 256, 4), dtype=float32)\n",
            "Tensor(\"CRelu_3/Relu:0\", shape=(?, 256, 256, 8), dtype=float32)\n",
            "Tensor(\"conv2d_4/BiasAdd:0\", shape=(?, 256, 256, 8), dtype=float32)\n",
            "Tensor(\"batch_normalization_4/FusedBatchNormV3:0\", shape=(?, 256, 256, 8), dtype=float32)\n",
            "Tensor(\"CRelu_4/Relu:0\", shape=(?, 256, 256, 16), dtype=float32)\n",
            "Tensor(\"conv2d_5/BiasAdd:0\", shape=(?, 128, 128, 16), dtype=float32)\n",
            "Tensor(\"batch_normalization_5/FusedBatchNormV3:0\", shape=(?, 128, 128, 16), dtype=float32)\n",
            "Tensor(\"CRelu_5/Relu:0\", shape=(?, 128, 128, 32), dtype=float32)\n",
            "WARNING:tensorflow:From <ipython-input-22-41ea81b35345>:33: max_pooling2d (from tensorflow.python.layers.pooling) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use keras.layers.MaxPooling2D instead.\n",
            "Tensor(\"max_pooling2d/MaxPool:0\", shape=(?, 127, 127, 32), dtype=float32)\n",
            "Tensor(\"conv2d_6/BiasAdd:0\", shape=(?, 127, 127, 8), dtype=float32)\n",
            "Tensor(\"batch_normalization_6/FusedBatchNormV3:0\", shape=(?, 127, 127, 8), dtype=float32)\n",
            "Tensor(\"CRelu_6/Relu:0\", shape=(?, 127, 127, 16), dtype=float32)\n",
            "Tensor(\"conv2d_7/BiasAdd:0\", shape=(?, 64, 64, 16), dtype=float32)\n",
            "Tensor(\"batch_normalization_7/FusedBatchNormV3:0\", shape=(?, 64, 64, 16), dtype=float32)\n",
            "Tensor(\"CRelu_7/Relu:0\", shape=(?, 64, 64, 32), dtype=float32)\n",
            "Tensor(\"max_pooling2d_1/MaxPool:0\", shape=(?, 63, 63, 32), dtype=float32)\n",
            "Tensor(\"conv2d_8/BiasAdd:0\", shape=(?, 63, 63, 8), dtype=float32)\n",
            "Tensor(\"batch_normalization_8/FusedBatchNormV3:0\", shape=(?, 63, 63, 8), dtype=float32)\n",
            "Tensor(\"CRelu_8/Relu:0\", shape=(?, 63, 63, 16), dtype=float32)\n",
            "Tensor(\"conv2d_9/BiasAdd:0\", shape=(?, 32, 32, 16), dtype=float32)\n",
            "Tensor(\"batch_normalization_9/FusedBatchNormV3:0\", shape=(?, 32, 32, 16), dtype=float32)\n",
            "Tensor(\"CRelu_9/Relu:0\", shape=(?, 32, 32, 32), dtype=float32)\n",
            "Tensor(\"max_pooling2d_2/MaxPool:0\", shape=(?, 31, 31, 32), dtype=float32)\n",
            "Tensor(\"conv2d_10/BiasAdd:0\", shape=(?, 31, 31, 8), dtype=float32)\n",
            "Tensor(\"batch_normalization_10/FusedBatchNormV3:0\", shape=(?, 31, 31, 8), dtype=float32)\n",
            "Tensor(\"CRelu_10/Relu:0\", shape=(?, 31, 31, 16), dtype=float32)\n",
            "Tensor(\"conv2d_11/BiasAdd:0\", shape=(?, 16, 16, 16), dtype=float32)\n",
            "Tensor(\"batch_normalization_11/FusedBatchNormV3:0\", shape=(?, 16, 16, 16), dtype=float32)\n",
            "Tensor(\"CRelu_11/Relu:0\", shape=(?, 16, 16, 32), dtype=float32)\n",
            "Tensor(\"max_pooling2d_3/MaxPool:0\", shape=(?, 15, 15, 32), dtype=float32)\n",
            "Tensor(\"conv2d_12/BiasAdd:0\", shape=(?, 15, 15, 8), dtype=float32)\n",
            "Tensor(\"batch_normalization_12/FusedBatchNormV3:0\", shape=(?, 15, 15, 8), dtype=float32)\n",
            "Tensor(\"CRelu_12/Relu:0\", shape=(?, 15, 15, 16), dtype=float32)\n",
            "Tensor(\"conv2d_13/BiasAdd:0\", shape=(?, 8, 8, 16), dtype=float32)\n",
            "Tensor(\"batch_normalization_13/FusedBatchNormV3:0\", shape=(?, 8, 8, 16), dtype=float32)\n",
            "Tensor(\"CRelu_13/Relu:0\", shape=(?, 8, 8, 32), dtype=float32)\n",
            "Tensor(\"max_pooling2d_4/MaxPool:0\", shape=(?, 7, 7, 32), dtype=float32)\n",
            "Tensor(\"conv2d_14/BiasAdd:0\", shape=(?, 7, 7, 8), dtype=float32)\n",
            "Tensor(\"batch_normalization_14/FusedBatchNormV3:0\", shape=(?, 7, 7, 8), dtype=float32)\n",
            "Tensor(\"CRelu_14/Relu:0\", shape=(?, 7, 7, 16), dtype=float32)\n",
            "Tensor(\"conv2d_15/BiasAdd:0\", shape=(?, 4, 4, 16), dtype=float32)\n",
            "Tensor(\"batch_normalization_15/FusedBatchNormV3:0\", shape=(?, 4, 4, 16), dtype=float32)\n",
            "Tensor(\"CRelu_15/Relu:0\", shape=(?, 4, 4, 32), dtype=float32)\n",
            "Tensor(\"max_pooling2d_5/MaxPool:0\", shape=(?, 3, 3, 32), dtype=float32)\n",
            "WARNING:tensorflow:\n",
            "The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
            "For more information, please see:\n",
            "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
            "  * https://github.com/tensorflow/addons\n",
            "  * https://github.com/tensorflow/io (for I/O related ops)\n",
            "If you depend on functionality not listed there, please file an issue.\n",
            "\n",
            "WARNING:tensorflow:From /tensorflow-1.15.2/python3.7/tensorflow_core/contrib/layers/python/layers/layers.py:1634: flatten (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use keras.layers.flatten instead.\n",
            "Tensor(\"Flatten/flatten/Reshape:0\", shape=(?, 288), dtype=float32)\n",
            "WARNING:tensorflow:From <ipython-input-22-41ea81b35345>:39: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
            "Tensor(\"dropout/mul_1:0\", shape=(?, 288), dtype=float32)\n",
            "WARNING:tensorflow:From <ipython-input-22-41ea81b35345>:41: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use keras.layers.Dense instead.\n",
            "Tensor(\"dense/CRelu/Relu:0\", shape=(?, 40), dtype=float32)\n",
            "Tensor(\"dropout_1/mul_1:0\", shape=(?, 40), dtype=float32)\n",
            "Tensor(\"dense_1/Softmax:0\", shape=(?, 11), dtype=float32)\n",
            "\u001b[91m ============================ END ============================= \u001b[0m\n",
            "WARNING:tensorflow:From /tensorflow-1.15.2/python3.7/tensorflow_core/python/ops/losses/losses_impl.py:121: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
            "INFO:tensorflow:Restoring parameters from ./model/bilater2/noiseless/model\n",
            "\u001b[1;34;40m Model is restored! \u001b[0m\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a7wFk4dJhWcN"
      },
      "source": [
        "# conv.train(data_provider=odp,training_epochs=100000, \n",
        "#             iterations=100, n_s=120,\n",
        "#             learning_rate = 0.001, verbose=1 , time_limit = 20)\n",
        "\n",
        "# Y_t  = [] \n",
        "# pr_t = []\n",
        "\n",
        "# for _ in range(500):\n",
        "#     x,y = odp_test(1)\n",
        "#     pred = conv.predict(x)\n",
        "#     Y_t.append(np.argmax(y))\n",
        "#     pr_t.append(np.argmax(pred))\n",
        "    \n",
        "# conf_plotter(Y_t , pr_t , labels , normalize=1, cmap = plt.cm.gnuplot_r ,mode='test', save=0 , name='overlapping_test.jpg')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JX-NvqmZpmrc"
      },
      "source": [
        "#Correction of labels :"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HvBbMRCQTS3M"
      },
      "source": [
        "String simulated maps are delta(T)/T . CMB simulations are just delta(T)...\n",
        "So we have to divide gaussian maps to T (ie. Sky temperature which is 2.7 kelvin)\n",
        "We could do this in our data provider but there is no difference whether we divide Gaussian map to T or divide gmu value to it because at the end we multiply G maps by the gmu. So : "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vLm4mklHTYW9",
        "outputId": "b87dcf8e-fec9-4fb3-bd77-84b2de26f836"
      },
      "source": [
        "gmus_ = [gmus[i]/2.7 for i in range(n_class)]\n",
        "print(gmus_)   \n",
        "labels = []\n",
        "for gmu in gmus_:\n",
        "    labels.append('{:3.1e}'.format(gmu)) "
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.0, 1.8518518518518515e-08, 3.9896938704294115e-08, 8.595534877060707e-08, 1.8518518518518516e-07, 3.989693870429411e-07, 8.595534877060689e-07, 1.8518518518518517e-06, 3.989693870429411e-06, 8.59553487706069e-06, 1.8518518518518518e-05]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NndOOdGYXZxI"
      },
      "source": [
        "def get_slice_seq(data,nx,ny):\n",
        "    cp = []\n",
        "    for i in range(8):\n",
        "        for j in range(8):          \n",
        "            cp.append(data[i*nx:(i+1)*nx , j*ny:(j+1)*ny])\n",
        "    cp = np.array(cp)\n",
        "    return cp"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ui8_KzX6T2xu"
      },
      "source": [
        "class non_overlap_dp(object):\n",
        "    def __init__(self,n_files,s_files,gmus,s2n=None,\n",
        "                 nx=0,ny=0,n_buffer=10,\n",
        "                 reload_rate=100,filt=None , test=0 , noisy=1):\n",
        "\n",
        "        self.n_files = n_files\n",
        "        self.s_files = s_files\n",
        "        self.test = test\n",
        "        self.noisy = noisy\n",
        "        self.s2n = s2n\n",
        "\n",
        "        nmin = min(len(n_files),len(s_files))\n",
        "        if n_buffer>= nmin:\n",
        "            n_buffer = nmin\n",
        "            self.reload_rate = 0\n",
        "        else:\n",
        "            self.reload_rate = reload_rate\n",
        "\n",
        "        self.nx,self.ny = nx,ny\n",
        "        self.n_buffer = n_buffer\n",
        "        self.gmus = gmus\n",
        "        if filt is None:\n",
        "            def filt(x):\n",
        "                return x\n",
        "        self.filt = filt\n",
        "        self.counter = 0\n",
        "        self.reload()\n",
        "\n",
        "    def reload(self):\n",
        "        print('Data provider is reloading...')\n",
        "        self.n_set = []\n",
        "        self.s_set = []\n",
        "    #        self.d_set = []\n",
        "        nind = np.random.randint(0,len(self.n_files))\n",
        "        \n",
        "        if self.test:\n",
        "            sind = (nind%12)\n",
        "        else:\n",
        "\n",
        "            sind = np.random.randint(1,3)\n",
        "            if sind==1:\n",
        "                sind = (nind%12)\n",
        "            elif sind==2:\n",
        "                sind = (nind%12)+12\n",
        "            \n",
        "        for i in range(self.n_buffer):\n",
        "            filen = self.n_files[nind]\n",
        "            files = self.s_files[sind]\n",
        "            self.n_set.append(np.load(filen))\n",
        "            signal = np.load(files)\n",
        "            self.s_set.append(signal)\n",
        "\n",
        "    def get_data(self): \n",
        "        self.counter += 1\n",
        "        if self.reload_rate:\n",
        "            if self.counter%self.reload_rate==0: \n",
        "                self.reload() \n",
        "    #        n = choice(self.n_set)\n",
        "        ind = choice(np.arange(self.n_buffer))\n",
        "        s = self.s_set[ind]\n",
        "        n = self.n_set[ind]\n",
        "\n",
        "        return n,s\n",
        "\n",
        "    \n",
        "    def pre_process(self, n, s, gmu):\n",
        "        \n",
        "        sn = []\n",
        "                    \n",
        "        sky = n + gmu*(s)\n",
        "\n",
        "        sky = cv.bilateralFilter(sky,5,1e-3,1e-3)\n",
        "\n",
        "        snslice = get_slice_seq(sky,self.nx,self.ny)\n",
        "        # print(snslice.shape)\n",
        "        for i in range(len(snslice)):                    \n",
        "            sn1 = snslice[i]\n",
        "            sn1 = (sn1 - np.mean(sn1))/(np.std(sn1) + 1e-30)\n",
        "            # print(sn1.shape)\n",
        "            sn.append(sn1[:,:])\n",
        "\n",
        "        sn = np.array(sn)\n",
        "#         print(sn.shape)\n",
        "            \n",
        "        sn = np.expand_dims(sn,-1)\n",
        "\n",
        "        return sn#,d\n",
        "\n",
        "    def __call__(self, n, gmus=None): \n",
        "\n",
        "        if gmus is None:\n",
        "            gmus = self.gmus\n",
        "        n_class = len(gmus)\n",
        "        #        x,y = self.get_data()\n",
        "        X = []\n",
        "        Y = []\n",
        "        for i in range(n):                \n",
        "            n,s = self.get_data()\n",
        "            # print(n.shape)\n",
        "            inds = np.arange(n_class)\n",
        "            shuffle(inds)\n",
        "            gmu = gmus[inds[0]]\n",
        "            #            gmu = choice(gmus)\n",
        "            sn  = self.pre_process(n,s,gmu)\n",
        "            #            rand = np.random.randint(0,2)\n",
        "            #            sn = sn-sn+rand\n",
        "\n",
        "#             sn = (sn - np.min(sn))/(np.max(sn) - np.min(sn))\n",
        "\n",
        "            #            Y.append(-np.log10(gmu+1e-30))\n",
        "\n",
        "            lbl = n_class*[0]\n",
        "            lbl[inds[0]] = 1\n",
        "            Y.append(lbl)\n",
        "            X.append(sn)\n",
        "\n",
        "        X = np.array(X)\n",
        "        Y = np.array(Y)\n",
        "\n",
        "        return X,Y"
      ],
      "execution_count": 38,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E1C3-VLuXf3q",
        "outputId": "e9f8a4f6-a65f-4d2e-c24d-f80d0ef3d9cb"
      },
      "source": [
        "nodp_test = non_overlap_dp(g_test,s_files,\n",
        "                            gmus=gmus,\n",
        "                            nx=256,ny=256,n_buffer=10,\n",
        "                            reload_rate=1e5,filt=filt,test=1 , noisy=0)"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Data provider is reloading...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 302
        },
        "id": "MiDrp5mjdXV6",
        "outputId": "2a28ba3a-5324-4d08-872e-2022847e8b64"
      },
      "source": [
        "x,y=nodp_test(1)\n",
        "print(x.shape , y.shape)\n",
        "plt.imshow(x[0,0,:,:,0] , 'jet')"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(1, 64, 256, 256, 1) (1, 11)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7ff2041ef650>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        },
        {
          "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": "code",
      "metadata": {
        "id": "Mnrmp2EGejt9"
      },
      "source": [
        "Xs = {\n",
        "'x0' : [],\n",
        "'x1' : [],\n",
        "'x2' : [],\n",
        "'x3' : [],\n",
        "'x4' : [],\n",
        "'x5' : [],\n",
        "'x6' : [],\n",
        "'x7' : [],\n",
        "'x8' : [],\n",
        "'x9' : [],\n",
        "'x10' : []\n",
        "}\n"
      ],
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 618
        },
        "id": "GKWBp-VoeOth",
        "outputId": "2bc1766b-5417-4f2f-fb97-9f9a75bd252a"
      },
      "source": [
        "Y_t  = [] \n",
        "pr_t = []\n",
        "\n",
        "for _ in range(500):\n",
        "    \n",
        "    x, y = nodp_test(1)\n",
        "    b = 'x{}'.format(np.argmax(y))\n",
        "\n",
        "    pred = []\n",
        "    \n",
        "    for i in range(6):\n",
        "        pred.append(conv.predict(x[:,i,:,:,:]))\n",
        "#     print(np.array(pred).shape)  \n",
        "\n",
        "    preds = np.prod(np.vstack(pred), axis=0)\n",
        "    preds = preds/(sum(preds)+1e-30)\n",
        "#     print(preds)    \n",
        "\n",
        "    (Xs[b]).append( float(np.dot(preds , gmus_)) ) \n",
        "# Xs\n",
        "        \n",
        "    Y_t.append(np.argmax(y))\n",
        "    pr_t.append(np.argmax(preds))\n",
        "\n",
        "\n",
        "conf_plotter(Y_t , pr_t , labels , normalize=1, cmap = plt.cm.YlGn ,\n",
        "             title ='' , save=1 , name='Final CM_noisefree_ffp.png')"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7ff2041dc610>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 45
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 648x648 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-jOBLLqgixmD",
        "outputId": "6f81d71e-f43a-491d-b73e-33147b275298"
      },
      "source": [
        "from scipy.stats import ttest_ind\n",
        "\n",
        "dist_0 = Xs['x0']\n",
        "pv_d = [1]\n",
        "\n",
        "for i in range(1,n_class):\n",
        "    dist = Xs['x{}'.format(i)]\n",
        "    tt , pval = ttest_ind(dist , dist_0 )\n",
        "    pv_d.append(pval)\n",
        "    \n",
        "    if pval<= 0.05:\n",
        "        print('{:3.2e}'.format(gmus_[i]) , ':' , pval)\n",
        "print('pv_det:' , pv_d)\n",
        "\n",
        "\n",
        "from scipy.interpolate import interp1d\n",
        "\n",
        "f = interp1d(pv_d[:6],gmus_[:6], kind='linear')\n",
        "pv_det = f(0.05)\n",
        "print('pv_det:' , pv_det)"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.99e-08 : 7.203061703842449e-19\n",
            "8.60e-08 : 1.3463081826643575e-129\n",
            "1.85e-07 : 7.01077916926613e-170\n",
            "3.99e-07 : 5.98093929812437e-172\n",
            "8.60e-07 : 1.7512086829458065e-224\n",
            "1.85e-06 : 2.9633874302193804e-235\n",
            "3.99e-06 : 2.753e-320\n",
            "8.60e-06 : 4.755545885182521e-297\n",
            "1.85e-05 : 0.0\n",
            "pv_det: [1, 0.09026466675290906, 7.203061703842449e-19, 1.3463081826643575e-129, 7.01077916926613e-170, 5.98093929812437e-172, 1.7512086829458065e-224, 2.9633874302193804e-235, 2.753e-320, 4.755545885182521e-297, 0.0]\n",
            "pv_det: 2.805486308665682e-08\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "id": "ruQQCM0Bjm7S",
        "outputId": "9a82d529-3dca-4a9b-9ff5-9efe7915b100"
      },
      "source": [
        "pv_d = [1, 0.09026466675290906, 7.203061703842449e-19, 1.3463081826643575e-129, 7.01077916926613e-170, 5.98093929812437e-172, 1.7512086829458065e-224, 2.9633874302193804e-235, 2.753e-320, 4.755545885182521e-297, 0.0]\n",
        "plt.axes(xscale='log' , yscale='log')\n",
        "plt.xlabel('$G\\mu$' ,   fontsize=15)\n",
        "plt.ylabel('$\\it{P}$-value' , fontsize=15)\n",
        "plt.plot(gmus_[1:-2] , pv_d[1:-2] , 'bo' , gmus_[1:-2] , pv_d[1:-2] , 'g--')\n",
        "plt.axvline(2.8e-8, color='red', ls=':')#, label='$\\it{P}$-value = 0.05' )\n",
        "\n",
        "plt.text(3.1e-8, 1e-265 ,r'$G\\mu$ $\\geq$ $2.8\\times 10^{-8}$' , color='r' ,fontsize=14)\n",
        "plt.tight_layout()\n",
        "plt.savefig('final_pv_noisefree_ffp.png')\n",
        "plt.savefig('final_pv_noisefree_ffp.pdf')"
      ],
      "execution_count": 66,
      "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"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N_u4lfCUk1A_"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}