DatasetsVisualization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Datasets Visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "from sklearn import neighbors, datasets\n",
    "import pandas as pd\n",
    "import os\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn import preprocessing\n",
    "from scipy import stats\n",
    "import collections\n",
    "%matplotlib inline\n",
    "\n",
    "# set float precision at 2 digits\n",
    "np.set_printoptions(precision=2)\n",
    "\n",
    "# increase font size in matplotlib\n",
    "import matplotlib\n",
    "matplotlib.rcParams.update({'font.size': 11})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def summarize_dataset(ds, ds_name):\n",
    "    X = ds.get_X()\n",
    "    y = ds.get_y()\n",
    "    \n",
    "    print(\"Summary of the dataset %s \" % ds_name)\n",
    "    print(\"X : \", end=\"\")\n",
    "    print(stats.describe(X))\n",
    "    print(\" \")\n",
    "    print(\" \")\n",
    "    print(\"y : \", end=\"\")\n",
    "    print(stats.describe(y))\n",
    "    \n",
    "    print(\"Number of classes: %s\" % len(set(y)))\n",
    "    print(\"Number of samples: %s\" % len(X))\n",
    "    print(\"Number of genes: %s\" % len(X[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def plot_hist(ds, ds_name):\n",
    "    #WARNING: disabled because I dont think that it is useful to\n",
    "    # print the mean X values\n",
    "    return\n",
    "\n",
    "    X = ds.get_X()\n",
    "    X_mean = np.mean(X, axis=0)\n",
    "    y = ds.get_y()\n",
    "    \n",
    "    genes = range(len(X_mean))\n",
    "    \n",
    "    fig = plt.figure(figsize=(8,6))\n",
    "    ax = fig.add_subplot(111)\n",
    "    \n",
    "    ax.bar(genes, X_mean, align='center', alpha=0.5)\n",
    "    \n",
    "    ax.set_ylabel('Value')\n",
    "    ax.set_xlabel('Genes')\n",
    "    \n",
    "    # add some padding\n",
    "    ax.set_xlim([-100, max(genes) + 100])\n",
    "    ax.set_ylim([0, max(X_mean) * 1.1])\n",
    "    \n",
    "    plt.title('Mean value per gene - %s' % ds_name)\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def plot_classes_repartition(ds, ds_name, ds_encoder=None):   \n",
    "    y = ds.get_y()\n",
    "    \n",
    "    N_classes = len(set(y))\n",
    "    N_samples = len(y)\n",
    "    \n",
    "    ind = np.arange(N_classes)  # the x locations for the groups\n",
    "    width = 0.35       # the width of the bars\n",
    "    \n",
    "    # list of tuple as (class_name, count)\n",
    "    counter=collections.Counter(y).most_common()\n",
    "    \n",
    "    classes_names = [c[0] for c in counter]\n",
    "    classes_count = [c[1] for c in counter]\n",
    "\n",
    "    fig = plt.figure(figsize=(16,6))\n",
    "    ax = fig.add_subplot(111)\n",
    "    \n",
    "    ax.bar(classes_names, classes_count, align='center', width=width, alpha=0.5)\n",
    "    \n",
    "    ax.set_ylabel('Samples')\n",
    "    ax.set_xlabel('Classes')\n",
    "    \n",
    "    # add some padding\n",
    "    ax.set_xlim([min(classes_names) - 0.5, max(classes_names) + 0.5])\n",
    "    ax.set_ylim([0, max(classes_count) * 1.1])\n",
    "    \n",
    "    # add values above the bars\n",
    "    for a,b in counter:\n",
    "        plt.text(a, b, str(b), ha='center', va='bottom')\n",
    "    \n",
    "    \n",
    "    if ds_encoder is not None:\n",
    "        le = ds_encoder.get_label_encoder()\n",
    "        classes_names = le.inverse_transform(classes_names)\n",
    "    \n",
    "    ax.set_xticks(ind)\n",
    "    ax.set_xticklabels(classes_names)\n",
    "    \n",
    "    \n",
    "    plt.title('Number of samples per class - %s\\nTotal samples: %d' % (ds_name, N_samples))\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def describe_dataset(ds, ds_name, ds_encoder=None):\n",
    "    print(\"Description of dataset %s\" % ds_name)\n",
    "    print(\"===================================\")\n",
    "    \n",
    "    summarize_dataset(ds, ds_name)\n",
    "    plot_hist(ds, ds_name)\n",
    "    plot_classes_repartition(ds, ds_name, ds_encoder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Golub 99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from datasets.Golub99.GolubDataset import GolubDataset\n",
    "from datasets.DatasetEncoder import DatasetEncoder\n",
    "\n",
    "ds = GolubDataset()\n",
    "\n",
    "# encode Dataset string classes into numbers\n",
    "ds_encoder = DatasetEncoder(ds)\n",
    "ds = ds_encoder.encode()\n",
    "\n",
    "describe_dataset(ds, \"Golub 99\", ds_encoder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def plot_hist_two_feat(ds, ds_name, ds_encoder):\n",
    "    X = ds.get_X()\n",
    "    mean_feat_0 = X[:, 10]\n",
    "    mean_feat_1 = X[:, 100]\n",
    "    mean_feat_2 = X[:, 1000]\n",
    "    \n",
    "    plt.figure(figsize=(8, 4))\n",
    "    plt.hist(mean_feat_0, bins=10, alpha=0.5, label='feat0')\n",
    "    plt.hist(mean_feat_1, bins=10, alpha=0.5, label='feat1')\n",
    "    plt.hist(mean_feat_2, bins=10, alpha=0.5, label='feat2')\n",
    "    plt.legend(loc='best')\n",
    "    plt.show()\n",
    "    \n",
    "plot_hist_two_feat(ds, \"Golub 99\", ds_encoder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ds.get_X()[:, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EGEOD22619"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from datasets.EGEOD22619.EGEOD22619Dataset import EGEOD22619Dataset\n",
    "from datasets.DatasetEncoder import DatasetEncoder\n",
    "\n",
    "ds = EGEOD22619Dataset()\n",
    "\n",
    "# encode Dataset string classes into numbers\n",
    "ds_encoder = DatasetEncoder(ds)\n",
    "ds = ds_encoder.encode()\n",
    "\n",
    "describe_dataset(ds, \"EGEOD22619\", ds_encoder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GSE13425"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from datasets.GSE13425.GSE13425Dataset import GSE13425Dataset\n",
    "from datasets.DatasetEncoder import DatasetEncoder\n",
    "\n",
    "ds = GSE13425Dataset()\n",
    "\n",
    "# encode Dataset string classes into numbers\n",
    "ds_encoder = DatasetEncoder(ds)\n",
    "ds = ds_encoder.encode()\n",
    "\n",
    "describe_dataset(ds, \"GSE13425\", ds_encoder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NCI60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from datasets.nci60.NCI60Dataset import NCI60Dataset\n",
    "from datasets.DatasetEncoder import DatasetEncoder\n",
    "\n",
    "ds = NCI60Dataset()\n",
    "\n",
    "# encode Dataset string classes into numbers\n",
    "ds_encoder = DatasetEncoder(ds)\n",
    "ds = ds_encoder.encode()\n",
    "\n",
    "describe_dataset(ds, \"NCI60\", ds_encoder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MILE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from datasets.MILE.MileDataset import MileDataset\n",
    "from datasets.DatasetEncoder import DatasetEncoder\n",
    "from datasets.DatasetBalancer import DatasetBalancer\n",
    " \n",
    "#ds = MileDataset(samples_limit=200)\n",
    "ds = MileDataset()\n",
    "\n",
    "# encode Dataset string classes into numbers\n",
    "ds_encoder = DatasetEncoder(ds)\n",
    "ds = ds_encoder.encode()\n",
    "\n",
    "describe_dataset(ds, \"MILE\", ds_encoder)\n",
    "\n",
    "\n",
    "# balance the classe using random oversampling\n",
    "ds_balancer = DatasetBalancer(ds)\n",
    "ds = ds_balancer.balance()\n",
    "\n",
    "describe_dataset(ds, \"MILE\", ds_encoder)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}