cf_inception_inspect_model_cam_etc.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# In[10]:\n",
    "\n",
    "\n",
    "# def plot_concentrations(y):\n",
    "#     fig, axs = plt.subplots(2, 2, sharey=False, tight_layout=True)\n",
    "#     for ip in range(0,4):\n",
    "#         axs[np.unravel_index(ip, axs.shape)].hist(y[:,ip])\n",
    "# plot_concentrations(y_test)\n",
    "# plot_concentrations(y_pred)\n",
    "\n",
    "def plot_compare_test_pred(yt, yp):\n",
    "    fig, axs = plt.subplots(2, 4, sharey=False, tight_layout=True, figsize=(12, 5))\n",
    "    for ip in range(0,8):\n",
    "        axsidx = np.unravel_index(ip, axs.shape)\n",
    "        if ip < 4:\n",
    "            axs[axsidx].hist(yt[:,ip])\n",
    "        else:\n",
    "            axs[axsidx].hist(yp[:,ip-4])\n",
    "\n",
    "plot_compare_test_pred(yt, yp)\n",
    "plt.show()\n",
    "\n",
    "\n",
    "# In[11]:\n",
    "\n",
    "\n",
    "# best_model.summary()\n",
    "\n",
    "\n",
    "# In[12]:\n",
    "\n",
    "\n",
    "model = best_model\n",
    "\n",
    "idxs = np.random.permutation(x_val.shape[0])\n",
    "x_cam = x_val[idxs[:1000],:,:]\n",
    "y_cam = y_val[idxs[:1000], :]\n",
    "\n",
    "w_k_c = model.layers[-1].get_weights()[0] # weights for each filter k for each class c \n",
    "\n",
    "new_input_layer = model.inputs # same input of the original model\n",
    "\n",
    "new_outpu_layer = [model.get_layer(\"conv1d_31\").output, model.layers[-1].output] # output is both the original as well as the before last layer \n",
    "# new_outpu_layer = [model.get_layer(\"activation_8\").output, model.layers[-1].output] # output is both the original as well as the before last layer \n",
    "\n",
    "new_function = keras.backend.function(new_input_layer,new_outpu_layer)\n",
    "\n",
    "new_feed_forward = new_function\n",
    "\n",
    "[conv_out, y_pred] = new_feed_forward((x_cam,))\n",
    "\n",
    "metrics = classifier._calculate_metrics(y_cam, y_pred, 0.0)\n",
    "display(HTML(metrics.to_html()))\n",
    "print(conv_out.shape)\n",
    "\n",
    "\n",
    "# In[13]:\n",
    "\n",
    "\n",
    "print(w_k_c.shape)\n",
    "print(conv_out.shape)\n",
    "print(x_cam.shape)\n",
    "\n",
    "\n",
    "# In[14]:\n",
    "\n",
    "\n",
    "# plot_data = []\n",
    "# for isample in range(conv_out.shape[0]):\n",
    "#     conv_out_i = conv_out[isample,:,:]\n",
    "#     one_plot_data = []\n",
    "#     for j in range(y_val.shape[1]):\n",
    "\n",
    "#         axsidx = np.unravel_index(j, axs.shape)\n",
    "\n",
    "#         cas = np.zeros(dtype=np.float, shape = (conv_out.shape[1]))\n",
    "#         for k,w in enumerate(w_k_c[:,j]):\n",
    "#             cas += w * conv_out_i[:,k]\n",
    "#         minimum = np.min(cas)\n",
    "#         cas = cas - minimum\n",
    "#         cas = cas/max(cas)\n",
    "#         cas = cas * 100\n",
    "#         cas = cas.astype(int)\n",
    "\n",
    "#     #     axs[axsidx].plot(cas)\n",
    "\n",
    "#         one_plot_data.append( (np.squeeze(x_cam[isample,:,:]), np.array(range(y.shape[0])), cas) )\n",
    "#     plot_data.append(one_plot_data)\n",
    "\n",
    "# import ipywidgets as widgets\n",
    "# from matplotlib.collections import LineCollection\n",
    "# from matplotlib.colors import ListedColormap, BoundaryNorm\n",
    "\n",
    "# plt.ioff()\n",
    "# fig, axs = plt.subplots(2, 2, sharey=False, tight_layout=True, figsize=(12, 5))\n",
    "# plt.ion()\n",
    "\n",
    "# def show_image(one_plot_data):\n",
    "#     for j in range(y_val.shape[1]):\n",
    "\n",
    "#         axsidx = np.unravel_index(j, axs.shape)\n",
    "# #         axs[axsidx].clear()\n",
    "\n",
    "#         y = one_plot_data[j][0]\n",
    "#         x = one_plot_data[j][1]\n",
    "#         dydx = one_plot_data[j][2]\n",
    "\n",
    "#         # def plot_line_multicolor(x, y, dydx):\n",
    "#         # Create a set of line segments so that we can color them individually\n",
    "#         # This creates the points as a N x 1 x 2 array so that we can stack points\n",
    "#         # together easily to get the segments. The segments array for line collection\n",
    "#         # needs to be (numlines) x (points per line) x 2 (for x and y)\n",
    "#         points = np.array([x, y]).T.reshape(-1, 1, 2)\n",
    "#         segments = np.concatenate([points[:-1], points[1:]], axis=1)\n",
    "\n",
    "#         # Create a continuous norm to map from data points to colors\n",
    "#         norm = plt.Normalize(dydx.min(), dydx.max())\n",
    "#         lc = LineCollection(segments, cmap='jet', norm=norm)\n",
    "#         # Set the values used for colormapping\n",
    "#         lc.set_array(dydx)\n",
    "#         lc.set_linewidth(4)\n",
    "#         line = axs[axsidx].add_collection(lc)\n",
    "# #         fig.colorbar(line, ax=axs[axsidx])\n",
    "        \n",
    "#         axs[axsidx].set_xlim(x.min(), x.max())\n",
    "#         axs[axsidx].set_ylim(y.min(), y.max())\n",
    "#         axs[axsidx].set_title(names[j])\n",
    "\n",
    "# show_image(plot_data[0])\n",
    "\n",
    "\n",
    "\n",
    "# def update(change):\n",
    "#     idx = change['new']\n",
    "#     show_image(plot_data[idx])\n",
    "#     fig.canvas.draw_idle()\n",
    "    \n",
    "# slider = widgets.IntSlider(value=0, min=0, max=conv_out.shape[0]-1)\n",
    "# slider.observe(update, names='value')\n",
    "# widgets.VBox([slider, fig.canvas])\n",
    "\n",
    "# # plt.show()\n",
    "\n",
    "\n",
    "# In[15]:\n",
    "\n",
    "\n",
    "from matplotlib.collections import LineCollection\n",
    "from matplotlib.colors import ListedColormap, BoundaryNorm\n",
    "\n",
    "# print(\"original_label: \"+str(encoder.inverse_transform(np.argmax(original_binary_class))))\n",
    "# print(\"original_shape: \"+str(time_series_original.shape))\n",
    "# print(\"predicted_label:\"+str(encoder.inverse_transform(np.argmax(predicted))))\n",
    "# print(\"predicted_shape:\"+str(conv_out.shape))\n",
    "\n",
    "# print(w_k_c.shape)\n",
    "# print(conv_out.shape)\n",
    "\n",
    "fig, axs = plt.subplots(2, 2, sharey=False, tight_layout=True, figsize=(12, 5))\n",
    "\n",
    "ix = np.random.randint(0,conv_out.shape[0]-1)\n",
    "conv_out_0 = conv_out[ix,:,:]\n",
    "# conv_out_avg = np.squeeze(np.mean(conv_out, axis=0))\n",
    "\n",
    "for j in range(y_val.shape[1]):\n",
    "\n",
    "    axsidx = np.unravel_index(j, axs.shape)\n",
    "\n",
    "    cas = np.zeros(dtype=np.float, shape = (conv_out.shape[1]))\n",
    "    for k,w in enumerate(w_k_c[:,j]):\n",
    "        cas += w * conv_out_0[:,k]\n",
    "    minimum = np.min(cas)\n",
    "    cas = cas - minimum\n",
    "    cas = cas/max(cas)\n",
    "    cas = cas * 100\n",
    "    cas = cas.astype(int)\n",
    "\n",
    "#     axs[axsidx].plot(cas)\n",
    "\n",
    "    y = np.squeeze(x_cam[ix,:,:])\n",
    "    x = np.array(range(y.shape[0]))\n",
    "    dydx = cas\n",
    "\n",
    "    # Create a set of line segments so that we can color them individually\n",
    "    # This creates the points as a N x 1 x 2 array so that we can stack points\n",
    "    # together easily to get the segments. The segments array for line collection\n",
    "    # needs to be (numlines) x (points per line) x 2 (for x and y)\n",
    "    points = np.array([x, y]).T.reshape(-1, 1, 2)\n",
    "    segments = np.concatenate([points[:-1], points[1:]], axis=1)\n",
    "\n",
    "    # Create a continuous norm to map from data points to colors\n",
    "    norm = plt.Normalize(dydx.min(), dydx.max())\n",
    "    lc = LineCollection(segments, cmap='jet', norm=norm)\n",
    "    # Set the values used for colormapping\n",
    "    lc.set_array(dydx)\n",
    "    lc.set_linewidth(4)\n",
    "    line = axs[axsidx].add_collection(lc)\n",
    "    fig.colorbar(line, ax=axs[axsidx])\n",
    "\n",
    "    # # Use a boundary norm instead\n",
    "    # cmap = ListedColormap(['r', 'g', 'b'])\n",
    "    # norm = BoundaryNorm([-1, -0.5, 0.5, 1], cmap.N)\n",
    "    # lc = LineCollection(segments, cmap=cmap, norm=norm)\n",
    "    # lc.set_array(dydx)\n",
    "    # lc.set_linewidth(2)\n",
    "    # line = axs[1].add_collection(lc)\n",
    "    # fig.colorbar(line, ax=axs[1])\n",
    "\n",
    "    axs[axsidx].set_xlim(x.min(), x.max())\n",
    "    axs[axsidx].set_ylim(y.min(), y.max())\n",
    "    axs[axsidx].set_title(names[j])\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "jitter = None\n",
    "# jitter = 500\n",
    "epochs = 100\n",
    "hold_probe = 'CF025'\n",
    "output_directory = f'/mnt/nfs/proj/in-vitro/Leonardo/inception/results/cf/J{jitter}/E{epochs}/{hold_probe}/'\n",
    "\n",
    "if not (os.path.exists(output_directory)):\n",
    "    os.makedirs(output_directory, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}