feature_selection/stats.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from netCDF4 import Dataset\n",
    "from itertools import combinations\n",
    "from scipy.stats import f_oneway, kendalltau, pearsonr, spearmanr"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "features = ['TMQ', 'U850', 'V850', 'UBOT', 'VBOT', 'QREFHT', 'PS', 'PSL', 'T200', 'T500', 'PRECT', 'TS', 'TREFHT',\n",
    "                'Z1000', 'Z200', 'ZBOT']\n",
    "\n",
    "here = os.getcwd()\n",
    "#\n",
    "data_dir = os.path.join(here, 'io/data/train/')  # directory with the nc files\n",
    "plots_dir = os.path.join(here, 'io/plots/')\n",
    "stats_dir = os.path.join(here, 'io/stats/')\n",
    "\n",
    "if not os.path.exists(data_dir):\n",
    "    raise FileNotFoundError(\"data directory not found at\", data_dir)\n",
    "\n",
    "if not os.path.exists(stats_dir):\n",
    "    os.makedirs(stats_dir)\n",
    "\n",
    "if not os.path.exists(plots_dir):\n",
    "    os.makedirs(plots_dir)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# calculate all correlations\n",
    "combs = list(combinations(features, 2))\n",
    "for i in range(len(combs)):\n",
    "    comb = combs[i]\n",
    "    print(\"loading data:\", comb[0], comb[1], \"...\")\n",
    "    feat_0_list = []\n",
    "    feat_1_list = []\n",
    "\n",
    "    for file in os.listdir(data_dir):\n",
    "        path = os.path.join(data_dir, file)\n",
    "        nc = Dataset(path)\n",
    "\n",
    "        feat_0_list.append(nc.variables[comb[0]][:][0])\n",
    "        feat_1_list.append(nc.variables[comb[1]][:][0])\n",
    "\n",
    "    n = len(os.listdir(data_dir))\n",
    "\n",
    "    feat_0 = np.vstack(feat_0_list).reshape((n, 768, 1152))\n",
    "    feat_1 = np.vstack(feat_1_list).reshape((n, 768, 1152))\n",
    "\n",
    "    corr = []\n",
    "    assert (np.shape(feat_0) == np.shape(feat_1))\n",
    "    print(\"calculating correlation coefficients for features \", comb[0], comb[1], \"...\")\n",
    "    for row in range(len(feat_0[0, :, 0])):\n",
    "        for col in range(len(feat_0[0, 0])):\n",
    "            p_r = pearsonr(feat_0[:, row, col], feat_1[:, row, col])\n",
    "            # s_r = spearmanr(tmq[:, row, col], u850[:, row, col])\n",
    "            # k_t = kendalltau(tmq[:, row, col], u850[:, row, col])\n",
    "\n",
    "            # pointcorr = ([p_r[0], s_r[0], k_t[0]])\n",
    "            # corr.append(pointcorr)\n",
    "\n",
    "            corr.append(p_r[0])\n",
    "\n",
    "    corr_mat = np.reshape(corr, (768, 1152))\n",
    "    print(\"saving \", comb[0], comb[1], \"...\")\n",
    "    np.savetxt(os.path.join(stats_dir, \"p_corr_\" + comb[0] + \"_\" + comb[1] + \".csv\"), corr_mat, delimiter=',')\n",
    "    sns.heatmap(corr_mat)\n",
    "    plt.savefig(plots_dir + \"p_corr_\" + comb[0] + \"_\" + comb[1] + \".png\")\n",
    "    plt.clf()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# calculate anova scores\n",
    "for feature in features:\n",
    "\n",
    "    feat_0_list = []\n",
    "    labels_list = []\n",
    "\n",
    "    print(\"Loading data for \",feature, \"...\")\n",
    "    for file in os.listdir(data_dir):\n",
    "        path = os.path.join(data_dir, file)\n",
    "\n",
    "        nc = Dataset(path)\n",
    "\n",
    "        feat_0_list.append(nc.variables[feature])\n",
    "        labels_list.append(nc.variables[\"LABELS\"])\n",
    "\n",
    "    n = len(os.listdir(data_dir))\n",
    "\n",
    "    feat_0 = np.vstack(feat_0_list).reshape((n, 768, 1152))\n",
    "    labels = np.vstack(labels_list).reshape((n, 768, 1152))\n",
    "\n",
    "    anova = []\n",
    "\n",
    "    print(\"Calculating anova...\")\n",
    "    for i in range(n):\n",
    "        label_B_idx = np.where(labels[0] == 0)\n",
    "        label_1_idx = np.where(labels[0] == 1)\n",
    "        label_2_idx = np.where(labels[0] == 2)\n",
    "\n",
    "        background = feat_0[i][(label_B_idx[0], label_B_idx[1])]\n",
    "        label_1_data = feat_0[i][(label_1_idx[0], label_1_idx[1])]\n",
    "        label_2_data = feat_0[i][(label_2_idx[0], label_2_idx[1])]\n",
    "\n",
    "        anova.append(f_oneway(background, label_1_data, label_2_data).statistic)\n",
    "    print(\"Saving...\")\n",
    "    np.savetxt(stats_dir + \"anova_\" + feature + \".csv\", anova)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "anova = [file for file in os.listdir(stats_dir) if file.startswith(\"anova\")]\n",
    "anova_pd = pd.DataFrame()\n",
    "for file in anova:\n",
    "    name = file.replace(\".csv\", \"\").replace(\"anova_\", \"\")\n",
    "    data = pd.read_csv(stats_dir + file)\n",
    "    anova_pd[name] = data\n",
    "\n",
    "display(anova_pd.mean().sort_values())"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# calculate kendall coefficient\n",
    "for feature in features:\n",
    "\n",
    "    feat_0_list = []\n",
    "    labels_list = []\n",
    "\n",
    "    print(\"Loading data for \", feature, \"...\")\n",
    "    for file in os.listdir(data_dir):\n",
    "        path = os.path.join(data_dir, file)\n",
    "\n",
    "        nc = Dataset(path)\n",
    "\n",
    "        feat_0_list.append(nc.variables[feature])\n",
    "        labels_list.append(nc.variables[\"LABELS\"])\n",
    "\n",
    "    n = len(os.listdir(data_dir))\n",
    "\n",
    "    feat_0 = np.vstack(feat_0_list).reshape((n, 768 * 1152))\n",
    "\n",
    "    kendall = []\n",
    "\n",
    "    print(\"Calculating kendall...\")\n",
    "    for i in range(n):\n",
    "        f = feat_0[i]\n",
    "        l = labels_list[i]\n",
    "\n",
    "        kendall.append(kendalltau(f, l)[0])\n",
    "    print(\"Saving...\")\n",
    "    np.savetxt(stats_dir + \"kendall_\" + feature + \".csv\", kendall)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "kendall = [file for file in os.listdir(stats_dir) if file.startswith(\"kendall\")]\n",
    "kendall_pd = pd.DataFrame()\n",
    "for file in kendall:\n",
    "    name = file.replace(\".csv\", \"\").replace(\"kendall_\", \"\")\n",
    "    data = pd.read_csv(stats_dir + file)\n",
    "    kendall_pd[name] = data\n",
    "\n",
    "display(kendall_pd.mean().sort_values())"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 120/120 [00:32<00:00,  3.68it/s]\n"
     ]
    }
   ],
   "source": [
    "files = os.listdir(stats_dir)\n",
    "corrs = [file for file in files if file.startswith(\"p_corr\")]\n",
    "corr_mat_std = pd.DataFrame(columns=features, index=features, data=np.eye(16))\n",
    "corr_mat_mean = pd.DataFrame(columns=features, index=features, data=np.eye(16))\n",
    "corr_mat_med = pd.DataFrame(columns=features, index=features, data=np.eye(16))\n",
    "for data in corrs:\n",
    "    names = data.replace(\".csv\", \"\").replace(\"p_corr_\", \"\").split(sep='_')\n",
    "    corr_file = pd.read_csv(stats_dir + data)\n",
    "    corr_mat_std.at[names[0], names[1]] = corr_file.abs().std().std()\n",
    "    corr_mat_std.at[names[1], names[0]] = corr_file.abs().std().std()\n",
    "    corr_mat_mean.at[names[0], names[1]] = corr_file.abs().mean().mean()\n",
    "    corr_mat_mean.at[names[1], names[0]] = corr_file.abs().mean().mean()\n",
    "    corr_mat_med.at[names[0], names[1]] = corr_file.abs().median().median()\n",
    "    corr_mat_med.at[names[1], names[0]] = corr_file.abs().median().median()\n",
    "corr_mat_std.to_csv(stats_dir + \"corr_mat_std.csv\")\n",
    "corr_mat_mean.to_csv(stats_dir + \"corr_mat_mean.csv\")\n",
    "corr_mat_med.to_csv(stats_dir + \"corr_mat_med.csv\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 2 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = pd.read_csv(stats_dir+\"corr_mat_med.csv\")\n",
    "# plot heatmap\n",
    "ax = sns.heatmap(data.get(features), yticklabels=features, xticklabels=features)\n",
    "ax.xaxis.tick_top()\n",
    "for item in ax.get_xticklabels():\n",
    "    item.set_rotation(90)\n",
    "\n",
    "plt.savefig(plots_dir+'med_heatmap.png', dpi=100)\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}