Neuvisys.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Neuvisys notebook\n",
    "\n",
    "Display multiple information from a spiking neural network experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import os\n",
    "import shutil\n",
    "import pprint\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from pdf2image import convert_from_path\n",
    "from src.spiking_network.network.neuvisys import SpikingNetwork\n",
    "from src.spiking_network.analysis.network_display import (\n",
    "    display_network,\n",
    "    load_array_param,\n",
    "    complex_cells_directions,\n",
    "    complex_cell_disparities,\n",
    ")\n",
    "from src.spiking_network.analysis.rl_analysis import (\n",
    "    value_plot,\n",
    "    policy_plot,\n",
    ")\n",
    "from src.spiking_network.analysis.network_statistics import (\n",
    "    event_vs_network_activity,\n",
    "    rf_matching,\n",
    "    direction_norm_length,\n",
    "    orientation_norm_length,\n",
    "    direction_selectivity,\n",
    "    orientation_selectivity,\n",
    "    update_dataframe,\n",
    "    disparity_histogram,\n",
    "    inhibition_weight_against_orientation,\n",
    "    inhibition_weight_against_disparity,\n",
    "    lateral_inhibition_weight_sum,\n",
    "    weight_variation,\n",
    ")\n",
    "from src.spiking_network.gabor.gabor_fit import gabor_fit_one_patch\n",
    "from src.spiking_network.analysis.spike_train import (\n",
    "    spike_trains,\n",
    "    raster_plot,\n",
    "    event_plot,\n",
    "    time_histogram,\n",
    "    fast_time_histogram,\n",
    "    spike_rate_histogram,\n",
    "    isi_histogram,\n",
    "    instantaneous_rates,\n",
    "    correlation_coeficient_matrix,\n",
    "    activity_comparison,\n",
    "    kernel_convolution,\n",
    ")\n",
    "from src.spiking_network.analysis.rl_analysis import (\n",
    "    full_validation_tracking,\n",
    "    full_validation_orientation,\n",
    "    plot_validation_critic_actor,\n",
    "    plot_validation_actor_critic_evolution,\n",
    ")\n",
    "from src.spiking_network.gabor.gabbor_fitting import (\n",
    "    create_gabor_basis,\n",
    "    hists_preferred_orientations,\n",
    "    plot_preferred_orientations,\n",
    ")\n",
    "from src.spiking_network.analysis.parameter_analysis import (\n",
    "    correlation_matrix,\n",
    "    scatter_mat,\n",
    ")\n",
    "\n",
    "os.chdir(\"/home/thomas/neuvisys-analysis/src\")\n",
    "home = \"/home/thomas/\"\n",
    "\n",
    "SMALL_SIZE = 25\n",
    "MEDIUM_SIZE = 35\n",
    "BIGGER_SIZE = 40\n",
    "\n",
    "plt.rc('figure', figsize=(30, 8))\n",
    "plt.rc('font', size=MEDIUM_SIZE)  # controls default text sizes\n",
    "plt.rc('axes', titlesize=BIGGER_SIZE,\n",
    "       labelsize=BIGGER_SIZE)  # fontsize of the axes title, fontsize of the x and y labels\n",
    "plt.rc('xtick', labelsize=SMALL_SIZE)  # fontsize of the tick labels\n",
    "plt.rc('ytick', labelsize=SMALL_SIZE)  # fontsize of the tick labels\n",
    "plt.rc('legend', fontsize=MEDIUM_SIZE)  # legend fontsize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Network\n",
    "\n",
    "loads various information of the spiking neural network into a SpikingNetwork instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "network_path = \"/home/thomas/Networks/simulation/rl/tracking_task/1D/test/test_1/\"\n",
    "spinet = SpikingNetwork(network_path, loading=[True, True, True, True])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Weights analysis\n",
    "\n",
    "Display of the learned receptive fields of the different neuronal layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "display_network([spinet])\n",
    "\n",
    "print(\"Simple cells weights\")\n",
    "if spinet.conf[\"nbCameras\"] == 2:\n",
    "    display(convert_from_path(network_path + \"figures/0/weight_sharing_combined.pdf\")[0])\n",
    "else:\n",
    "    display(convert_from_path(network_path + \"figures/0/weight_sharing_0.pdf\")[0])\n",
    "\n",
    "print(\"Complex cells weights (average over all simple cells)\")\n",
    "for i in range(spinet.l_shape[1, 2]):\n",
    "    display(convert_from_path(network_path + \"figures/1/complex_weights_depth_\" + str(i) + \".pdf\")[0])\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "network_path = \"/home/thomas/Networks/natural/intermediate_weights/network/\"\n",
    "spinet = SpikingNetwork(network_path, loading=[True, True, False, False])\n",
    "weight_variation(spinet, network_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inhibition_weight_against_orientation(spinet)\n",
    "# inhibition_weight_against_disparity(spinet)\n",
    "lateral_inhibition_weight_sum(spinet)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Load and create gabor basis"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "basis = spinet.generate_weight_mat()\n",
    "res = gabor_fit_one_patch(basis, rf_size=(10, 10), nb_cameras=2)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "spinet.generate_weight_images()\n",
    "gabor_params_l = create_gabor_basis(spinet, res, 0, nb_ticks=8, error_thresh=220)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Sparsity analysis"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "outputs": [],
   "source": [
    "network_path = \"/home/thomas/Networks/natural/activity_recording/pavin/learned_basis/\"\n",
    "spinet_learned = SpikingNetwork(network_path, loading=[True, True, False, False])\n",
    "network_path = \"/home/thomas/Networks/natural/activity_recording/pavin/random_basis/\"\n",
    "spinet_random = SpikingNetwork(network_path, loading=[True, True, False, False])\n",
    "video = \"/home/thomas/Videos/natural/pavin_aquisitions/pavin.h5\""
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "event_vs_network_activity(spinet_learned, video, bins=100, thresh=0)\n",
    "event_vs_network_activity(spinet_random, video, bins=100, thresh=0)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [],
   "source": [
    "from src.events.Events import Events\n",
    "bins = 50\n",
    "\n",
    "events = Events(video)\n",
    "events.shift_timestamps_to_0()\n",
    "events.crop(93, 50, 160, 160)\n",
    "hist_bin = np.arange(0, events.get_timestamps()[-1], int(1e3 * bins))\n",
    "event_variation, _ = np.histogram(events.get_timestamps(), bins=hist_bin)\n",
    "event_variation = event_variation / np.max(event_variation)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "activity_variation_learned = fast_time_histogram(spinet_learned.spikes[0], bins)\n",
    "activity_variation_random = fast_time_histogram(spinet_random.spikes[0], bins)\n",
    "\n",
    "activity_variation_learned = activity_variation_learned / np.max(activity_variation_learned)\n",
    "activity_variation_random = activity_variation_random / np.max(activity_variation_random)\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(event_variation[:activity_variation_random.shape[0]])\n",
    "plt.plot(activity_variation_random)\n",
    "plt.plot(activity_variation_learned)\n",
    "\n",
    "print(events.get_nb_events())\n",
    "\n",
    "print(spinet_random.spikes[0][spinet_random.spikes[0] != 0].size)\n",
    "print(spinet_random.spikes[1][spinet_random.spikes[1] != 1].size)\n",
    "\n",
    "print(spinet_learned.spikes[0][spinet_learned.spikes[0] != 0].size)\n",
    "print(spinet_learned.spikes[1][spinet_learned.spikes[1] != 1].size)\n",
    "\n",
    "diff_random = (event_variation[:activity_variation_random.shape[0]] - activity_variation_random)**2\n",
    "diff_learned = (event_variation[:activity_variation_learned.shape[0]] - activity_variation_learned)**2\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(diff_random)\n",
    "plt.plot(diff_learned)\n",
    "print(np.sqrt(np.sum(diff_random)), np.sqrt(np.sum(diff_learned)))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "is_executing": true
    }
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Spike analysis\n",
    "\n",
    "Displaying information related to spike timings in the network.\n",
    "\n",
    "This includes:\n",
    "- Eventplots\n",
    "- Time histograms\n",
    "- Inter-spike histograms\n",
    "- Raster plots\n",
    "- Instantaneous rates\n",
    "- Correlation coefficient matrices\n",
    "- spike rate histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "for layer, layer_spike_train in enumerate(spinet.spikes):\n",
    "    print(\"Layer \" + str(layer + 1) + \", nb neurons = \" + str(len(spinet.neurons[layer])) + \":\")\n",
    "    sts = spike_trains(layer_spike_train)\n",
    "    path = network_path + \"figures/\"\n",
    "    raster_plot(sts, layer, path)\n",
    "    # event_plot(sts, layer, path)\n",
    "    # time_histogram(sts, layer, 100, path)\n",
    "    # spike_rate_histogram(layer_spike_train, layer, path)\n",
    "    # isi_histogram(sts, layer, path)\n",
    "    # instantaneous_rates(sts, layer, path, 100, 100)\n",
    "    # correlation_coeficient_matrix(sts, layer, 50, path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "sts = spike_trains(spinet.spikes[0])\n",
    "rates = kernel_convolution(sts, 10, 10)\n",
    "variation = []\n",
    "for i in range(rates.shape[0]):\n",
    "    for j in range(rates.shape[0]):\n",
    "        variation.append(np.sum(np.abs(rates[j] - rates[i])))\n",
    "    plt.figure()\n",
    "    plt.title(\"Activity difference for two temporal simple cells responses on oriented bars\")\n",
    "    plt.xlabel(\"Bars orientation from 0° to 360°\")\n",
    "    plt.ylabel(\"Instantaneous activity\")\n",
    "    plt.plot(variation)\n",
    "    plt.savefig(\"/home/thomas/Bureau/figures/\" + str(i), bbox_inches=\"tight\")\n",
    "    plt.show()\n",
    "    variation = []"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compare activity between 2 networks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "outputs": [],
   "source": [
    "# spinet1 = SpikingNetwork(\"/home/thomas/Networks/simulation/inhibition_learning/orientation_task/base_static/\", loading=[True, True, False, False])\n",
    "# spinet2 = SpikingNetwork(\"/home/thomas/Networks/simulation/inhibition_learning/orientation_task/horizontal_degree_03/\", loading=[True, True, False, False])\n",
    "\n",
    "# spinet1 = SpikingNetwork(\"/home/thomas/Networks/simulation/inhibition_learning/orientation_task/article/network_control/\",\n",
    "#                          loading=[True, True, False, False])\n",
    "# spinet2 = SpikingNetwork(\"/home/thomas/Networks/simulation/inhibition_learning/orientation_task/article/network_experiment/\",\n",
    "#                          loading=[True, True, False, False])\n",
    "\n",
    "spinet1 = SpikingNetwork(\"/home/thomas/Networks/simulation/rl_inhibition/orientation_task/network_control/\", loading=[True, True, False, False])\n",
    "spinet2 = SpikingNetwork(\"/home/thomas/Networks/simulation/rl_inhibition/orientation_task/network/\", loading=[True, True, False, False])"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "outputs": [],
   "source": [
    "from scipy.stats import laplace, norm\n",
    "# distribution = laplace(0, 1.5).rvs(size=2000)\n",
    "# distribution = np.round(distribution)\n",
    "# hist = np.histogram(distribution, bins=np.arange(-9.5, 8.5), density=True)\n",
    "# distribution = np.roll(hist[0], 8)\n",
    "\n",
    "distribution = norm(0, 1.5).rvs(size=2000)\n",
    "distribution = np.round(distribution)\n",
    "hist = np.histogram(distribution, bins=np.arange(-9.5, 8.5), density=True)[0]\n",
    "distribution = np.roll(hist, -1)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "activity_comparison(spinet1, spinet2, 20, 17, distribution=distribution)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Direction and Orientation selectivity"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "rotations = np.array([0, 23, 45, 68, 90, 113, 135, 158, 180, 203, 225, 248, 270, 293, 315, 338])\n",
    "dir_vec, ori_vec = complex_cells_directions(spinet, rotations)\n",
    "\n",
    "angles = np.pi * rotations / 180\n",
    "\n",
    "dirs = []\n",
    "dis = []\n",
    "for i in range(len(spinet.neurons[1])):\n",
    "    dirs.append(direction_norm_length(spinet.directions[:, i], angles))\n",
    "    dis.append(direction_selectivity(spinet.directions[:, i]))\n",
    "oris = []\n",
    "ois = []\n",
    "for i in range(len(spinet.neurons[1])):\n",
    "    oris.append(orientation_norm_length(spinet.orientations[:, i], angles[0:8]))\n",
    "    ois.append(orientation_selectivity(spinet.orientations[:, i]))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "oris, oris_r = hists_preferred_orientations(spinet)\n",
    "plot_preferred_orientations(spinet, oris, oris_r)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Compute receptive field disparities"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "plt.imshow(spinet.disparities)\n",
    "plt.colorbar(orientation='horizontal')\n",
    "\n",
    "plt.figure()\n",
    "mean = np.mean(spinet.disparities, axis=1)\n",
    "plt.plot(mean)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "is_executing": true
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "disparities = np.array([-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8])\n",
    "\n",
    "dir_vec, ori_vec = complex_cell_disparities(spinet, spinet.disparities, disparities)\n",
    "\n",
    "# angles = np.pi * rotations / 180\n",
    "#\n",
    "# dirs = []\n",
    "# dis = []\n",
    "# for i in range(len(spinet.neurons[1])):\n",
    "#     dirs.append(direction_norm_length(spinet.directions[:, i], angles))\n",
    "#     dis.append(direction_selectivity(spinet.directions[:, i]))\n",
    "# oris = []\n",
    "# ois = []\n",
    "# for i in range(len(spinet.neurons[1])):\n",
    "#     oris.append(orientation_norm_length(spinet.orientations[:, i], angles[0:8]))\n",
    "#     ois.append(orientation_selectivity(spinet.orientations[:, i]))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "disparities, residuals = rf_matching(spinet)\n",
    "disparity_histogram(spinet, disparities)\n",
    "\n",
    "monocular_count = np.count_nonzero(np.isnan(disparities[:, 0]))\n",
    "print(\"There is : \", monocular_count, \"monocular cells (left right ratio imbalance of more than 90 %), which is \", 100 * monocular_count / disparities.shape[0], \"%\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "is_executing": true
    }
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Network training information"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Value plot"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "value_plot(spinet, display_score=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Policy plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "policy_plot(spinet, 50, [\"clockwise\", \"counterclockwise\"])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "is_executing": true
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Validation scenarios\n",
    "### Evolution during training"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "outputs": [],
   "source": [
    "network_path = \"/home/thomas/Networks/simulation/rl/orientation_task/article/save/\"\n",
    "# network_path = \"/media/thomas/165d07d7-bae4-4607-945a-e66ac3c9d538/article/save/\"\n",
    "# actions = [\"left\", \"right\"]\n",
    "actions = [\"Clockwise\", \"Counter-clockwise\"]\n",
    "\n",
    "plot_validation_actor_critic_evolution(network_path, actions, \"tracking\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### One scenario"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "network_path = \"/home/thomas/Networks/simulation/rl/orientation_task/5_exp/validation/validation_1/\"\n",
    "spinet = SpikingNetwork(network_path, loading=[True, True, True, True])\n",
    "plot_validation_critic_actor(spinet, [\"Clockwise\", \"Counter-clockwise\"], \"orientation\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "is_executing": true
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Multiple scenarios"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# full_validation(\"/home/thomas/Networks/simulation/rl/tracking_task/3actions/validation/\")\n",
    "full_validation_orientation(\"/home/thomas/Networks/simulation/rl_inhibition/orientation_task/5_exp/validation/\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Exploitation scenario"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "distance = np.load(\"/home/thomas/distance.npy\")\n",
    "distance[distance > np.pi / 2] -= np.pi\n",
    "# distance[distance < -np.pi / 2] += np.pi\n",
    "\n",
    "# distance = np.sqrt((-0.5 * 0.1**2) * np.log(distance / 100))\n",
    "# distance = np.concatenate((distance[1:7000], distance[8000:]))\n",
    "# distance = distance[10000:24000]\n",
    "# distance = np.degrees(distance)\n",
    "t = np.arange(0, distance.size) * 1e-3\n",
    "\n",
    "plt.figure()\n",
    "plt.title(\"Angular error over time\")\n",
    "plt.xlabel(\"Time (s)\")\n",
    "plt.ylabel(\"Angular error (degree)\")\n",
    "plt.plot(t, distance, color=\"#5DA9E9\")\n",
    "plt.vlines(np.arange(0, t[-1], 2), np.min(distance), np.max(distance), color=\"red\", linestyles=\"dashed\", alpha=0.4)\n",
    "plt.axhline(0, color=\"#6D326D\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "is_executing": true
    }
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Critic and Actor neurons weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "w0 = np.load(\"/home/thomas/Networks/simulation/rl/tracking_task/3actions/validation/weights/2/0_0.npy\")\n",
    "shape = w0.shape\n",
    "w0 = w0.flatten(order=\"F\")\n",
    "\n",
    "mat = np.zeros((shape[1], shape[0]))\n",
    "sum = 0\n",
    "for i in range(shape[0]):\n",
    "    for j in range(shape[1]):\n",
    "        for k in range(shape[2]):\n",
    "            sum += w0[k + j * shape[2] + i * shape[2] * shape[1]]\n",
    "        mat[j, i] = sum\n",
    "        sum = 0\n",
    "\n",
    "plt.imshow(mat)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "is_executing": true
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "nb_layers = len(spinet.neurons)\n",
    "w = np.zeros((spinet.neurons[nb_layers-2][0].weights.shape[0], spinet.neurons[nb_layers-2][0].weights.shape[1]))\n",
    "for neuron in spinet.neurons[nb_layers-2]:\n",
    "    w += np.sum(neuron.weights, axis=2)\n",
    "plt.figure(figsize=(18, 8))\n",
    "plt.title(\"Critic neurons summed weights\")\n",
    "plt.imshow(w.T)\n",
    "plt.colorbar(orientation=\"horizontal\")\n",
    "plt.show()\n",
    "\n",
    "nb_actions = len(spinet.rl_conf[\"actionMapping\"])\n",
    "nb_neurons_per_action = spinet.l_shape[-1][0] // nb_actions\n",
    "w = np.zeros((nb_actions, spinet.neurons[nb_layers-1][0].weights.shape[0], spinet.neurons[nb_layers-1][0].weights.shape[1]))\n",
    "for i in range(nb_actions):\n",
    "    for j in range(nb_neurons_per_action):\n",
    "        w[i] += np.sum(spinet.neurons[nb_layers-1][i*nb_neurons_per_action+j].weights, axis=2)\n",
    "\n",
    "    plt.figure(figsize=(18, 8))\n",
    "    plt.title(\"Actor neurons summed weights\")\n",
    "    plt.imshow(w[i].T)\n",
    "    plt.colorbar(orientation=\"horizontal\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network configuration parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Network config:\\n\")\n",
    "pprint.pprint(spinet.conf)\n",
    "for layer in range(len(spinet.neurons)):\n",
    "    print(\"\\nLayer \" + str(layer) + \":\\n\")\n",
    "    pprint.pprint(spinet.neurons[layer][0].conf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load various neuron informations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "simpa_decay, compa_decay = load_array_param(spinet, \"learning_decay\")\n",
    "simpa_spike, compa_spike = load_array_param(spinet, \"count_spike\")\n",
    "\n",
    "# Plot correlations\n",
    "\n",
    "df = pd.read_csv(home + \"Bureau/test/df\")\n",
    "temp = df.drop(columns=[\"TRACKING\", \"SYNAPSE_DELAY\", \"STDP_LEARNING\", \"MIN_THRESH\"])\n",
    "\n",
    "correlation_matrix(temp.iloc[:, 25:])\n",
    "scatter_mat(temp.iloc[:, 25:])"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Event analysis"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "from src.events.analysis.event_analysis import quantity_variation\n",
    "from src.events.Events import Events\n",
    "\n",
    "receptive_field = (346, 260)  # px\n",
    "\n",
    "events = Events(\"/home/thomas/Videos/natural/office/office_hovering.h5\")\n",
    "variation = quantity_variation(events, 50)\n",
    "\n",
    "plt.plot(variation)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}