jarvez/Object_representation_model-api
0
1{2 "cells": [3 {4 "cell_type": "markdown",5 "metadata": {6 "id": "view-in-github",7 "colab_type": "text"8 },9 "source": [10 "<a href=\"https://colab.research.google.com/github/jarvez31/Object_representation_model/blob/main/Moser_code_graph_FF_loop_local.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"11 ]12 },13 {14 "cell_type": "markdown",15 "metadata": {16 "id": "9V4wWaXFcBy5"17 },18 "source": [19 "# SETUP"20 ]21 },22 {23 "cell_type": "markdown",24 "metadata": {25 "id": "HBHyBKF5HoTS"26 },27 "source": [28 "### Install the extra modules"29 ]30 },31 {32 "cell_type": "code",33 "source": [34 "import tensorflow as tf\n",35 "tf.test.is_gpu_available()"36 ],37 "metadata": {38 "id": "HOxs8ALXmAjg",39 "colab": {40 "base_uri": "https://localhost:8080/"41 },42 "outputId": "105aadc1-4d6b-4abe-8e51-0f6e1a997e94"43 },44 "execution_count": 149,45 "outputs": [46 {47 "output_type": "execute_result",48 "data": {49 "text/plain": [50 "True"51 ]52 },53 "metadata": {},54 "execution_count": 14955 }56 ]57 },58 {59 "cell_type": "code",60 "execution_count": 150,61 "metadata": {62 "id": "HFUY067WALhG"63 },64 "outputs": [],65 "source": [66 "###############------------------- FOR AZRA ---------------------#############\n",67 "\n",68 "# !pip install -q tensorflow-model-optimization\n",69 "# !pip install -q unrar \n",70 "# !pip install -q keras_bert\n",71 "# !pip install -q google.colab \n",72 "# !pip install -q keras-gcn\n",73 "# from google.colab import drive\n",74 "# drive.mount('/content/drive',force_remount=True)\n",75 "# data_fol = \"G:/.shortcut-targets-by-id/1UpJ5JeLKsI591svXPy5X8lzFEgdC3tYe/LEC_MEC_CA/\"\n",76 "# data_fol = \"G:\\.shortcut-targets-by-id\\1UpJ5JeLKsI591svXPy5X8lzFEgdC3tYe\\LEC_MEC_CA\"\n",77 "# data_fol = \"/content/drive/MyDrive/sachin_deshmukh_proj/StripedData/\"\n",78 "\n",79 "from tensorflow.keras.models import model_from_yaml, model_from_json\n",80 "from tensorflow import keras\n",81 "import pickle, shapely\n",82 "import numpy as np\n",83 "import math as mt\n",84 "import tempfile\n",85 "import tensorflow as tf\n",86 "import pickle\n",87 "from scipy import misc\n",88 "import glob, csv\n",89 "from tensorflow.keras import layers\n",90 "from shapely.geometry import box, Polygon, Point, LinearRing\n",91 "#from tensorflow.keras.datasets import mnist\n",92 "from tensorflow.keras.models import Sequential\n",93 "from tensorflow.keras.models import Model\n",94 "from tensorflow.keras.layers import Dense, Activation, Flatten, Input, Reshape, Lambda\n",95 "from tensorflow.keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, UpSampling2D, concatenate, Concatenate\n",96 "import matplotlib.pyplot as plt\n",97 "from tensorflow.keras import backend as K \n",98 "# from keras_gcn import GraphConv\n",99 "import numpy as np\n",100 "from tensorflow.keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img\n",101 "import os\n",102 "from sklearn import preprocessing\n",103 "from numpy import linalg as LA\n",104 "import pandas as pd\n",105 "from tensorflow.keras.utils import plot_model\n",106 "from numpy import matlib\n",107 "import tensorflow_model_optimization as tfmot\n",108 "from matplotlib import cm\n",109 "main = \"Bharat_local_runs/\""110 ]111 },112 {113 "cell_type": "code",114 "execution_count": 151,115 "metadata": {116 "cellView": "form",117 "id": "_Ziyoa5hp5nb"118 },119 "outputs": [],120 "source": [121 "#@title Setup Parameters\n",122 "fol1 = \"new_graph\" #@param {type:\"string\"}\n",123 "traj1 = \"traj_obj(sh3)_20k.pk1\" #@param {type:\"string\"}\n",124 "imgs = \"frames_traj(col_obj)(sh3)_bw_20k.pk1\" #@param {type:\"string\"}\n",125 "# test_p = 7#@param {type:\"number\"}\n",126 "# img_fol = \"traj_four_objs_diffW\" #@param {type:\"string\"}\n",127 "\n",128 "#@markdown ### Standard deviation for population code for x,y\n",129 "std_dev = 0.3 #@param {type:\"slider\", min:0, max:1, step:0.1}\n",130 "\n",131 "#@markdown ### Model Params\n",132 "Retrain = True #@param {type:\"boolean\"}\n",133 "Train = False #@param {type:\"boolean\"}\n",134 "Analysis = False #@param {type:\"boolean\"}\n",135 "pre_conv = True #@param {type:\"boolean\"}\n",136 "obj_pres = True #@param {type:\"boolean\"}\n",137 "stat_ful = False #@param {type:\"boolean\"}\n",138 "pi_use = \"no_osc\" #@param [\"osc\", \"no_osc\"]\n",139 "act_func = \"relu\" #@param {type:\"string\"}\n",140 "learn_rate = 0.0001 #@param {type:\"number\"}\n",141 "random_state = 42 #@param {type:\"number\"}"142 ]143 },144 {145 "cell_type": "markdown",146 "metadata": {147 "id": "Z6bQ4-5q7oXV"148 },149 "source": [150 "### Functions"151 ]152 },153 {154 "cell_type": "code",155 "execution_count": 152,156 "metadata": {157 "id": "jjpuMDvo7qWT"158 },159 "outputs": [],160 "source": [161 "def rew_new(x, y, obj_boun, present=False):\n",162 " rew = []\n",163 " if present:\n",164 " for i in range(len(x)):\n",165 " kk = Point(x[i],y[i])\n",166 " for ii in obj_boun:\n",167 " bb = box(ii[0], ii[1], ii[2], ii[3])\n",168 " if bb.contains(kk):\n",169 " rew.append(1)\n",170 " else:\n",171 " rew.append(0)\n",172 " else:\n",173 " rew = [0]*len(x)\n",174 "\n",175 " return np.asarray(rew)\n",176 "\n",177 "\n",178 "def rew(x, y, theta, objs, obj_boun, env, env_boun, present=False):\n",179 " reward = []\n",180 " # obj = k2\n",181 " # obj_boun = k3\n",182 " for i in range(len(x)): \n",183 " if present:\n",184 " if present:\n",185 " for pp in range(len(objs)):\n",186 " k2 = obj[pp]\n",187 " k3 = obj_boun[pp]\n",188 " if((max(k3)[0] >= x[i] >= max(k2)[0]) and (max(k2)[1] >= y[i] >= min(k2)[1]) and (90 < theta[i] < 270)):\n",189 " reward.append(1)\n",190 " elif((min(k3)[0] <= x[i] <= min(k2)[0]) and (max(k2)[1] >= y[i] >= min(k2)[1]) and (90>theta[i] or theta[i]>270)):\n",191 " reward.append(1)\n",192 " elif((min(k3)[1] <= y[i] <= min(k2)[1]) and (max(k2)[0] >= x[i] >= min(k2)[0]) and (180>theta[i]>0 )):\n",193 " reward.append(1)\n",194 " elif((max(k3)[1] >= y[i] >= max(k2)[1]) and (max(k2[0]) >= x[i] >= min(k2)[0]) and (360>theta[i]>180)):\n",195 " reward.append(1)\n",196 "\n",197 " elif((min(k3)[0] <= x[i] <= min(k2)[0]) and (max(k3)[1] >= y[i] >= max(k2)[1]) and (15>theta[i] or theta[i]>255)):\n",198 " reward.append(1)\n",199 " elif((min(k3)[0] <= x[i] <= min(k2)[0]) and (min(k3)[1] <= y[i] <= min(k2[1])) and (105>theta[i] or theta[i]>335)):\n",200 " reward.append(1)\n",201 " elif((max(k3)[0] >= x[i] >= max(k2)[0]) and (min(k3)[1] <= y[i] <= min(k2)[1]) and (195>theta[i]>75)):\n",202 " reward.append(1)\n",203 " elif((max(k3)[0] >= x[i] >= max(k2)[0]) and (max(k3)[1] >= y[i] >= max(k2)[1]) and (285>theta[i]>165)):\n",204 " reward.append(1)\n",205 "\n",206 " if len(reward) != i+1:\n",207 " if((max(k1_env[0]) >= x[i] >= max(k1)[0]) and (90>theta[i] or theta[i]>270)):\n",208 " reward.append(0)\n",209 " elif((min(k1_env[0]) <= x[i] <= min(k1)[0]) and (270>theta[i]>90)):\n",210 " reward.append(0) \n",211 " elif((max(k1_env[1]) >= y[i] >= max(k1)[1]) and (180>theta[i]>0)):\n",212 " reward.append(0)\n",213 " elif((min(k1_env)[1] <= y[i] <= min(k1)[1]) and (360>theta[i]>180)):\n",214 " reward.append(0)\n",215 " elif len(reward) != i+1:\n",216 " reward.append(0)\n",217 " \n",218 " else:\n",219 " if((max(k1_env[0]) >= x[i] >= max(k1)[0]) and (90>theta[i] or theta[i]>270)):\n",220 " reward.append(0)\n",221 " elif((min(k1_env[0]) <= x[i] <= min(k1)[0]) and (270>theta[i]>90)):\n",222 " reward.append(0) \n",223 " elif((max(k1_env[1]) >= y[i] >= max(k1)[1]) and (180>theta[i]>0)):\n",224 " reward.append(0)\n",225 " elif((min(k1_env)[1] <= y[i] <= min(k1)[1]) and (360>theta[i]>180)):\n",226 " reward.append(0)\n",227 " elif len(reward) != i+1:\n",228 " reward.append(0)\n",229 " \n",230 " reward = np.asarray(reward)\n",231 " return reward\n",232 "\n",233 "\n",234 "#%% HD\n",235 "def HD(s, t):\n",236 " with open(main + 'hd_som_wt2.pk1', 'rb') as k:\n",237 " wt2 = pickle.load(k)\n",238 " \n",239 " # phase1d = np.zeros((100, 1))\n",240 " PI2d = np.zeros((10, 10))\n",241 " k = PI2d.shape \n",242 " trj_hd_resp = []\n",243 "\n",244 " for j in range(len(s)):\n",245 " if (j%10000 == 0):\n",246 " print(j)\n",247 " X1 = [mt.cos(mt.radians(t[0])), mt.sin(mt.radians(t[0]))]\n",248 " X2 = [mt.cos(mt.radians(t[j])), mt.sin(mt.radians(t[j]))]\n",249 " s1 = X2[0]*X1[1] - X1[0]*X2[1]\n",250 " s2 = X2[0]*X1[0] + X1[1]*X2[1]\n",251 " # print(s2)\n",252 " X = [s1, s2]\n",253 " y_p = repsom2dlinear(X, wt2)\n",254 " trj_hd_resp.append(y_p)\n",255 " print(\"HD response computed\")\n",256 " return trj_hd_resp\n",257 "\n",258 "#%%\n",259 "def PI(resp, s):\n",260 " X, Y, theta = np.zeros((100,1)), np.ones((100,1)), [[0]*100] \n",261 " bf = 2*6*mt.pi\n",262 " dt = np.divide(1, 100)\n",263 " betaa, t, Xbg, Ybg = 50, 0, 1, 0\n",264 " tarr = []\n",265 " for ii in range(1,len(resp)):\n",266 " if (ii%10000 == 0):\n",267 " print(ii)\n",268 " \n",269 "\n",270 " y_q = resp[ii]\n",271 " inp1d = np.reshape(np.transpose(y_q),(100,1))\n",272 " theta_dot = [(bf + betaa * s[ii] * k[0] * 10) for k in inp1d]\n",273 " theta_dot[:] = [x*dt for x in theta_dot]\n",274 " theta.append([i+j for i,j in zip(theta[ii-1], theta_dot)])\n",275 "\n",276 " theta = np.transpose(np.asarray(theta))\n",277 " # print(theta.shape)\n",278 " Xarr = np.cos(theta)\n",279 " PI1d = Xarr\n",280 " return PI1d\n",281 "\n",282 "\n",283 "def repsom2dlinear(x, wt):\n",284 " sz_wt = list(wt.shape)\n",285 " y = np.zeros((sz_wt[0], sz_wt[1]))\n",286 " if(sz_wt[2] != len(x)):\n",287 " print('Invalid input size in repsom2d()\\n')\n",288 " return\n",289 "\n",290 " for i in range(sz_wt[0]):\n",291 " for j in range(sz_wt[1]):\n",292 " v = wt[i][j].reshape(sz_wt[2], 1) \n",293 " # print(v)\n",294 " y[i][j] = np.dot(x,v)\n",295 " return y\n",296 "\n",297 "\n",298 "def unitvec(pos_corr):\n",299 " temp1 = np.subtract(pos_corr[1:, :], pos_corr[:-1, :])\n",300 " temp2 = np.sqrt((temp1*temp1).sum(axis=1))\n",301 " temp3 = temp1 / temp2.reshape(temp1.shape[0],1)\n",302 " return temp3\n",303 "\n",304 "\n",305 "def relu(input):\n",306 " if input > 0:\n",307 "\t return input\n",308 " else:\n",309 "\t return 0\n",310 "\n",311 "\n",312 "def test_train(dat, p):\n",313 " train_dat = np.asarray([dat[k] for k in range(len(dat)) if not k%p==0])\n",314 " test_dat = np.asarray([dat[k] for k in range(len(dat)) if k%p==0])\n",315 " return [train_dat, test_dat]\n",316 "\n",317 "\n",318 "def mse(data, pred_data):\n",319 " mse_ = np.sum(np.square(data - pred_data))/len(data)\n",320 " return mse_\n",321 "\n",322 "\n",323 "def seq_data(data, seq_len):\n",324 " temp1 = []\n",325 "\n",326 " for i in range(seq_len, data.shape[0]):\n",327 " temp3 = data[i-seq_len:i]\n",328 " temp1.append(temp3)\n",329 " temp1 = np.asarray(temp1)\n",330 " \n",331 " return temp1\n",332 "\n",333 "\n",334 "class FF(tf.keras.layers.Layer):\n",335 "\n",336 " def __init__(self, units, **kwargs):\n",337 " super(FF, self).__init__(**kwargs)\n",338 " self.units = units\n",339 " self.state_size = units\n",340 " self.j_h = tf.keras.layers.Dense(self.units)\n",341 " self.j_x = tf.keras.layers.Dense(self.units)\n",342 " self.k_h = tf.keras.layers.Dense(self.units)\n",343 " self.k_x = tf.keras.layers.Dense(self.units)\n",344 "\n",345 " def build(self, input_shape):\n",346 " self.built = True\n",347 "\n",348 " def get_config(self):\n",349 " return {'units': self.units}\n",350 " \n",351 " def call(self, inputs, states):\n",352 " #print(\"FF:\", inputs, states)\n",353 " prev_output = states[0]\n",354 " j = tf.sigmoid(self.j_x(inputs) + self.j_h(prev_output))\n",355 " k = tf.sigmoid(self.k_x(inputs) + self.k_h(prev_output))\n",356 " output = j * (1 - prev_output) + (1 - k) * prev_output\n",357 " return output, [output]\n",358 "\n",359 "def firing_rate_map(firposgrid, ot, firr, title):\n",360 " res = 45\n",361 " #firr = list(firr[0])\n",362 " x = np.arange(-1, 1, 1/res)\n",363 " y = np.arange(-1, 1, 1/res)\n",364 " fx,fy = np.meshgrid(x, y)\n",365 " firingmap = np.zeros(fx.shape)\n",366 " #gridpoint_x = np.asarray(np.reshape(fx, np.size(fx), 1))\n",367 " #gridpoint_y = np.asarray(np.reshape(fx, np.size(fx), 1))\n",368 " #gridpoint = np.transpose([gridpoint_x, gridpoint_y])\n",369 " #roundinggridpoint = np.round(gridpoint)\n",370 " #firposround = np.round(firposgrid)\n",371 " firingvalue = ot[firr]\n",372 " for ii in range(len(firposgrid)):\n",373 " q1 = np.argmin(abs(firposgrid[ii,0] - fx[1,:]))\n",374 " q2 = np.argmin(abs(firposgrid[ii,1] - fx[1,:]))\n",375 " firingmap[q1,q2] = firingvalue[ii]\n",376 " firingmap = firingmap/max(np.max(firingmap),1)\n",377 " gaussian = matlab_style_gauss2D([10, 10], 1.5)\n",378 " spikes_smooth = scipy.signal.convolve2d(gaussian, firingmap) \n",379 " rotated_img = ndimage.rotate(spikes_smooth, 1*270)\n",380 " #np.rot90([spikes_smooth], 2)\n",381 " plt.imshow(rotated_img, origin= 'upper')\n",382 " plt.title(title)\n",383 " plt.colorbar()\n",384 " ax=plt.gca() # get the axis\n",385 " ax.set_ylim(ax.get_ylim()[::-1]) # invert the axis\n",386 " ax.set_xlim(ax.get_xlim()[::-1]) # invert the axis\n",387 " ax.xaxis.tick_bottom() # and move the X-Axis \n",388 " ax.set_yticklabels([])\n",389 " ax.set_xticklabels([])\n",390 " \n",391 "def matlab_style_gauss2D(shape,sigma):\n",392 " \"\"\"\n",393 " 2D gaussian mask - should give the same result as MATLAB's\n",394 " fspecial('gaussian',[shape],[sigma])\n",395 " \"\"\"\n",396 " m,n = [(ss-1.)/2. for ss in shape]\n",397 " y,x = np.ogrid[-m:m+1,-n:n+1]\n",398 " h = np.exp( -(x*x + y*y) / (2.*sigma*sigma) )\n",399 " h[ h < np.finfo(h.dtype).eps*h.max() ] = 0\n",400 " sumh = h.sum()\n",401 " if sumh != 0:\n",402 " h /= sumh\n",403 " return h\n",404 "\n",405 "class GraphLayer(keras.layers.Layer):\n",406 "\n",407 " def __init__(self,\n",408 " step_num=1,\n",409 " activation=None,\n",410 " **kwargs):\n",411 " \"\"\"Initialize the layer.\n",412 " :param step_num: Two nodes are considered as connected if they could be reached in `step_num` steps.\n",413 " :param activation: The activation function after convolution.\n",414 " :param kwargs: Other arguments for parent class.\n",415 " \"\"\"\n",416 " self.supports_masking = True\n",417 " self.step_num = step_num\n",418 " self.activation = keras.activations.get(activation)\n",419 " self.supports_masking = True\n",420 " super(GraphLayer, self).__init__(**kwargs)\n",421 "\n",422 " def get_config(self):\n",423 " config = {\n",424 " 'step_num': self.step_num,\n",425 " 'activation': self.activation,\n",426 " }\n",427 " base_config = super(GraphLayer, self).get_config()\n",428 " return dict(list(base_config.items()) + list(config.items()))\n",429 "\n",430 " def _get_walked_edges(self, edges, step_num):\n",431 " \"\"\"Get the connection graph within `step_num` steps\n",432 " :param edges: The graph in single step.\n",433 " :param step_num: Number of steps.\n",434 " :return: The new graph that has the same shape with `edges`.\n",435 " \"\"\"\n",436 " if step_num <= 1:\n",437 " return edges\n",438 " deeper = self._get_walked_edges(K.batch_dot(edges, edges), step_num // 2)\n",439 " if step_num % 2 == 1:\n",440 " deeper += edges\n",441 " return K.cast(K.greater(deeper, 0.0), K.floatx())\n",442 "\n",443 " def call(self, inputs, **kwargs):\n",444 " features, edges = inputs\n",445 " edges = K.cast(edges, K.floatx())\n",446 " if self.step_num > 1:\n",447 " edges = self._get_walked_edges(edges, self.step_num)\n",448 " outputs = self.activation(self._call(features, edges))\n",449 " return outputs\n",450 "\n",451 " def _call(self, features, edges):\n",452 " raise NotImplementedError('The class is not intended to be used directly.')\n",453 "\n",454 "\n",455 "class GraphConv(GraphLayer):\n",456 " r\"\"\"Graph convolutional layer.\n",457 " h_i^{(t)} = \\sigma \\left ( \\frac{ G_i^T (h_i^{(t - 1)} W + b)}{\\sum G_i} \\right )\n",458 " \"\"\"\n",459 "\n",460 " def __init__(self,\n",461 " units,\n",462 " kernel_initializer='glorot_uniform',\n",463 " kernel_regularizer=None,\n",464 " kernel_constraint=None,\n",465 " use_bias=True,\n",466 " bias_initializer='zeros',\n",467 " bias_regularizer=None,\n",468 " bias_constraint=None,\n",469 " **kwargs):\n",470 " \"\"\"Initialize the layer.\n",471 " :param units: Number of new states. If the input shape is (batch_size, node_num, feature_len), then the output\n",472 " shape is (batch_size, node_num, units).\n",473 " :param kernel_initializer: The initializer of the kernel weight matrix.\n",474 " :param kernel_regularizer: The regularizer of the kernel weight matrix.\n",475 " :param kernel_constraint: The constraint of the kernel weight matrix.\n",476 " :param use_bias: Whether to use bias term.\n",477 " :param bias_initializer: The initializer of the bias vector.\n",478 " :param bias_regularizer: The regularizer of the bias vector.\n",479 " :param bias_constraint: The constraint of the bias vector.\n",480 " :param kwargs: Other arguments for parent class.\n",481 " \"\"\"\n",482 " self.units = units\n",483 " self.kernel_initializer = keras.initializers.get(kernel_initializer)\n",484 " self.kernel_regularizer = keras.regularizers.get(kernel_regularizer)\n",485 " self.kernel_constraint = keras.constraints.get(kernel_constraint)\n",486 " self.use_bias = use_bias\n",487 " self.bias_initializer = keras.initializers.get(bias_initializer)\n",488 " self.bias_regularizer = keras.regularizers.get(bias_regularizer)\n",489 " self.bias_constraint = keras.constraints.get(bias_constraint)\n",490 "\n",491 " self.W, self.b = None, None\n",492 " super(GraphConv, self).__init__(**kwargs)\n",493 "\n",494 " def get_config(self):\n",495 " config = {\n",496 " 'units': self.units,\n",497 " 'kernel_initializer': keras.initializers.serialize(self.kernel_initializer),\n",498 " 'kernel_regularizer': keras.regularizers.serialize(self.kernel_regularizer),\n",499 " 'kernel_constraint': keras.constraints.serialize(self.kernel_constraint),\n",500 " 'use_bias': self.use_bias,\n",501 " 'bias_initializer': keras.initializers.serialize(self.bias_initializer),\n",502 " 'bias_regularizer': keras.regularizers.serialize(self.bias_regularizer),\n",503 " 'bias_constraint': keras.constraints.serialize(self.bias_constraint),\n",504 " }\n",505 " base_config = super(GraphConv, self).get_config()\n",506 " return dict(list(base_config.items()) + list(config.items()))\n",507 "\n",508 " def build(self, input_shape):\n",509 " feature_dim = int(input_shape[0][-1])\n",510 " self.W = self.add_weight(\n",511 " shape=(feature_dim, self.units),\n",512 " initializer=self.kernel_initializer,\n",513 " regularizer=self.kernel_regularizer,\n",514 " constraint=self.kernel_constraint,\n",515 " name='{}_W'.format(self.name),\n",516 " )\n",517 " if self.use_bias:\n",518 " self.b = self.add_weight(\n",519 " shape=(self.units,),\n",520 " initializer=self.bias_initializer,\n",521 " regularizer=self.bias_regularizer,\n",522 " constraint=self.bias_constraint,\n",523 " name='{}_b'.format(self.name),\n",524 " )\n",525 " super(GraphConv, self).build(input_shape)\n",526 "\n",527 " def compute_output_shape(self, input_shape):\n",528 " return input_shape[0][:2] + (self.units,)\n",529 "\n",530 " def compute_mask(self, inputs, mask=None):\n",531 " if mask is None:\n",532 " mask = [None]\n",533 " return mask[0]\n",534 "\n",535 " def _call(self, features, edges):\n",536 " proj = K.dot(features, self.W)\n",537 " if self.use_bias:\n",538 " proj += self.b\n",539 " if self.step_num > 1:\n",540 " edges = self._get_walked_edges(edges, self.step_num)\n",541 " # aggr = proj/2\n",542 " aggr = tf.math.divide((K.sum(proj, axis=1, keepdims=True) + K.epsilon()), 3)\n",543 " # aggr = K.batch_dot(K.permute_dimensions(edges, (0, 2, 1)), proj) \\\n",544 " # / (K.sum(edges, axis=2, keepdims=True) + K.epsilon())\n",545 " return features + aggr\n",546 " # return features\n"547 ]548 },549 {550 "cell_type": "markdown",551 "metadata": {552 "id": "uD32ZfCvcQuM"553 },554 "source": [555 "---------------------------------\n",556 "---------------------------------\n",557 "---------------------------------"558 ]559 },560 {561 "cell_type": "markdown",562 "metadata": {563 "id": "g9amC5ajXYev"564 },565 "source": [566 "# DATA"567 ]568 },569 {570 "cell_type": "markdown",571 "metadata": {572 "id": "hU8Xl5PdU1IB"573 },574 "source": [575 "### Trajectory"576 ]577 },578 {579 "cell_type": "code",580 "execution_count": 153,581 "metadata": {582 "id": "ObpSNafp4iuj",583 "colab": {584 "base_uri": "https://localhost:8080/",585 "height": 329586 },587 "outputId": "0edbae20-8072-423e-be82-4e112c0fcb44"588 },589 "outputs": [590 {591 "output_type": "stream",592 "name": "stdout",593 "text": [594 "[(-0.55, -0.55, -0.25, -0.25)]\n",595 "359.9822242593575\n",596 "20000\n",597 "20000\n"598 ]599 },600 {601 "output_type": "execute_result",602 "data": {603 "text/plain": [604 "[<matplotlib.lines.Line2D at 0x1fbbe7bd9d0>]"605 ]606 },607 "metadata": {},608 "execution_count": 153609 },610 {611 "output_type": "display_data",612 "data": {613 "text/plain": [614 "<Figure size 2160x360 with 1 Axes>"615 ],616 "image/png": "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\n"617 },618 "metadata": {619 "needs_background": "light"620 }621 }622 ],623 "source": [624 "###--------------------- LOAD TRAJECTORY --------------------###\n",625 "\n",626 "fol = main + fol1 + \"/\"\n",627 "traj = traj1\n",628 "with open(traj, \"rb\") as f:\n",629 " d = pickle.load(f)\n",630 " f.close()\n",631 "locals().update(d)\n",632 "\n",633 "x = np.asarray(x)\n",634 "y = np.asarray(y)\n",635 "pos = np.column_stack((x,y))\n",636 "# x = x[:-1]\n",637 "# y = y[:-1]\n",638 "# theta = theta[:-1]\n",639 "env = [(1.0, -1.0), (1.0, 1.0), (-1.0, 1.0), (-1.0, -1.0), (1.0, -1.0)]\n",640 "obj_c = [(-0.4, -0.4)]#, (0.4, 0.4)]\n",641 "\n",642 "hf_sz = 0.15\n",643 "out_bound = 0.25\n",644 "obj_ver = [(c[0]-hf_sz, c[1]-hf_sz, c[0]+hf_sz, c[1]+hf_sz) for c in obj_c]\n",645 "print(obj_ver)\n",646 "obj_ver_outer = [(c[0]-hf_sz-out_bound, c[1]-hf_sz-out_bound, c[0]+hf_sz+out_bound, c[1]+hf_sz+out_bound) for c in obj_c]\n",647 "\n",648 "sq1_env = box(-1.0, -1.0, 1.0, 1.0)\n",649 "sq1 = box(-0.8, -0.8, 0.8, 0.8)\n",650 "sq2 = [box(obj_ver[j][0], obj_ver[j][1], obj_ver[j][2], obj_ver[j][3]) for j in range(len(obj_ver))]\n",651 "sq3 = [box(obj_ver_outer[k][0], obj_ver_outer[k][1], obj_ver_outer[k][2], obj_ver_outer[k][3]) for k in range(len(obj_ver_outer))]\n",652 "k1_env = list(sq1_env.exterior.coords)\n",653 "k1 = list(sq1.exterior.coords)\n",654 "k2 = [list(l.exterior.coords) for l in sq2]\n",655 "k3 = [list(ll.exterior.coords) for ll in sq3]\n",656 "\n",657 "env = [[m[0] for m in k1_env ], [m[1] for m in k1_env ]]\n",658 "obj = [[[m[0] for m in obji ], [m[1] for m in obji ]] for obji in k2]\n",659 "obj_boun = [[[m[0] for m in objbi ], [m[1] for m in objbi ]] for objbi in k3]\n",660 "# env = np.asarray(env)\n",661 "# obj = np.asarray(obj)\n",662 "\n",663 "theta = np.asarray(theta)\n",664 "theta_rad = np.radians(theta)\n",665 "print(max(theta))\n",666 "print(len(theta))\n",667 "\n",668 "## objects to do plotting that show shifting\n",669 "obj_c_plot = [(0.0, 0.0), (-0.4, -0.4)]#, (0.4, 0.4)]#, (-0.4, 0.4)]#, (-0.4, -0.4), (0.4, -0.4)]\n",670 "obj_ver_plot = [(c[0]-hf_sz, c[1]-hf_sz, c[0]+hf_sz, c[1]+hf_sz) for c in obj_c_plot]\n",671 "sq2_plot = [box(obj_ver_plot[j][0], obj_ver_plot[j][1], obj_ver_plot[j][2], obj_ver_plot[j][3]) for j in range(len(obj_ver_plot))]\n",672 "k2_plot = [list(l.exterior.coords) for l in sq2_plot]\n",673 "obj_plot = [[[m[0] for m in obji ], [m[1] for m in obji ]] for obji in k2_plot]\n",674 "\n",675 "###--------------------- CREATING GROUND TRUTH(TRAJECTORY) --------------------###\n",676 "\n",677 "# std_dev = 0.2\n",678 "# Hd_rep = np.asarray([np.sin(np.deg2rad(theta)), np.cos(np.deg2rad(theta))]).T\n",679 "# print(pos[:4,:])\n",680 "# Hd_rep = unitvec(pos)\n",681 "# print(np.sqrt((Hd_rep*Hd_rep).sum(axis=1)))\n",682 "# out = 11\n",683 "# xmat = np.matlib.repmat(x.reshape((len(x),1)),1,out)\n",684 "# ymat = np.matlib.repmat(y.reshape((len(y),1)),1,out)\n",685 "\n",686 "# xi = np.asarray(np.matlib.repmat(np.linspace(np.amin(env)-0.4,np.amax(env)+0.4,num=out, endpoint=True), len(x),1))\n",687 "# yi = np.asarray(np.matlib.repmat(np.linspace(np.amin(env)-0.4,np.amax(env)+0.4,num=out, endpoint=True), len(y),1))\n",688 "\n",689 "# x_rep = np.exp(-1*((xi-xmat)/std_dev)**2)\n",690 "# y_rep = np.exp(-1*((yi-ymat)/std_dev)**2)\n",691 "\n",692 "# rep = np.column_stack((x_rep, y_rep, Hd_rep))\n",693 "# rep2 = np.column_stack((x_rep, y_rep))\n",694 "\n",695 "# # CREATING POPULATION CODE FOR HEAD DIRECTION\n",696 "# ui_x = np.cos(np.linspace(0, 2*np.pi ,num=37, endpoint = False))\n",697 "# ui_y = np.sin(np.linspace(0, 2*np.pi ,num=37, endpoint = False))\n",698 "# ui = np.column_stack((ui_x, ui_y))\n",699 "# Hd_out_pop = np.matmul(Hd_rep, ui.T)\n",700 "\n",701 "# Hd_out_pop2 = np.maximum(Hd_out_pop, 0)\n",702 "\n",703 "# CREATE COMPLETE GROUND TRUTH\n",704 "# comp_gt = np.column_stack((rep2, Hd_out_pop))\n",705 "reward = rew_new(x, y, obj_ver_outer, present = obj_pres)\n",706 "print(len(reward))\n",707 "plt.plot(x,y)"708 ]709 },710 {711 "cell_type": "markdown",712 "source": [713 "### Reward"714 ],715 "metadata": {716 "id": "YleTBUDD1QLu"717 }718 },719 {720 "cell_type": "code",721 "execution_count": 154,722 "metadata": {723 "id": "nEyeLsKmLiLV",724 "colab": {725 "base_uri": "https://localhost:8080/",726 "height": 587727 },728 "outputId": "a829d324-95cc-4619-d249-9d40fcdd8383"729 },730 "outputs": [731 {732 "output_type": "display_data",733 "data": {734 "text/plain": [735 "<Figure size 2160x360 with 1 Axes>"736 ],737 "image/png": "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\n"738 },739 "metadata": {740 "needs_background": "light"741 }742 },743 {744 "output_type": "stream",745 "name": "stdout",746 "text": [747 "1851\n",748 "(20000,)\n"749 ]750 },751 {752 "output_type": "display_data",753 "data": {754 "text/plain": [755 "<Figure size 2160x360 with 2 Axes>"756 ],757 "image/png": "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\n"758 },759 "metadata": {760 "needs_background": "light"761 }762 }763 ],764 "source": [765 "#print(gt)\n",766 "plt.plot(reward)\n",767 "plt.show()\n",768 "from scipy.ndimage import gaussian_filter\n",769 "import scipy\n",770 "from scipy import signal, ndimage\n",771 "#ot = predicted_output[1][:,-1,:]\n",772 "#ot = gt\n",773 "# ot = np.ndarray.flatten(encoded['val'])\n",774 "ot = reward\n",775 "print(np.sum(reward))\n",776 "print(ot.shape)\n",777 "thresh = np.min(ot)*0\n",778 "# print(thresh)\n",779 "firr = np.nonzero(ot!=thresh)\n",780 "# print(firr[0])\n",781 "#firr = np.nonzero(abs(resp_neurons[i+num])>thresh)\n",782 "firposgrid = pos[firr[0], :]\n",783 "# print(firposgrid)\n",784 "title = \"pred reward without object\"\n",785 "firing_map = firing_rate_map(firposgrid, ot, firr, title)"786 ]787 },788 {789 "cell_type": "markdown",790 "metadata": {791 "id": "yJpZEVWv9LYh"792 },793 "source": [794 "### Images"795 ]796 },797 {798 "cell_type": "code",799 "execution_count": 155,800 "metadata": {801 "id": "SLXQIPKm10Y7",802 "colab": {803 "base_uri": "https://localhost:8080/"804 },805 "outputId": "2b8a69bb-523e-413b-d5c5-6e4e748a9c83"806 },807 "outputs": [808 {809 "output_type": "stream",810 "name": "stdout",811 "text": [812 "(20000, 32, 32, 3)\n"813 ]814 }815 ],816 "source": [817 "## opening images from file\n",818 "# train_imgs = train_generator[0][0]\n",819 "# with open(data_fol+\"frames_traj(obj)_bw_20k.pk1\", 'wb') as ff:\n",820 "# pickle.dump(train_imgs, ff)\n",821 "# ff.close()\n",822 " # \n",823 "with open(imgs, \"rb\") as f:\n",824 " train_imgs = pickle.load(f)\n",825 " f.close()\n",826 "\n",827 "# train_imgs = train_imgs[:-1]\n",828 "print(train_imgs.shape)\n",829 "\n",830 "# CREATING TEST AND TRAIN DATA-SET\n",831 "# sub_imgs = test_train(train_imgs, test_p)\n",832 "# sub_comp_gt = test_train(comp_gt, test_p)\n",833 "# comp_gt2 = np.column_stack((pos[:-1], Hd_rep))\n",834 "# sub_comp_gt2 = test_train(comp_gt2, 5)\n",835 "# print(sub_imgs[0].shape)\n",836 "# print(sub_imgs[1].shape)"837 ]838 },839 {840 "cell_type": "markdown",841 "metadata": {842 "id": "gn3BRnizJvae"843 },844 "source": [845 "### PI"846 ]847 },848 {849 "cell_type": "code",850 "execution_count": 156,851 "metadata": {852 "id": "857gN0v1JzDO",853 "colab": {854 "base_uri": "https://localhost:8080/"855 },856 "outputId": "94e5796c-f5ea-428e-9eda-5d879040fac7"857 },858 "outputs": [859 {860 "output_type": "stream",861 "name": "stdout",862 "text": [863 "no_osc\n",864 "------using PI WITHOUT oscillators-----\n",865 "20000\n"866 ]867 }868 ],869 "source": [870 "####--------------------- PI (WITHOUT OSCILLATORS)-------------------########\n",871 "print(pi_use)\n",872 "if pi_use == \"no_osc\":\n",873 " #%%Calculating distance from starting point\n",874 " print(\"------using PI WITHOUT oscillators-----\")\n",875 " pos = np.column_stack((x,y))\n",876 " a = pos[0,0] * np.ones(pos[:,0].shape)\n",877 " b = pos[0,1] * np.ones(pos[:,1].shape)\n",878 " origin = np.transpose(np.append([a],[b],axis=0)) #for different x,y\n",879 "\n",880 " #origin = 0 * np.ones(pos.shape) #for same x,y\n",881 " disp = pos - origin\n",882 "\n",883 "\n",884 " # %% Head direciton parameters\n",885 " n = 100\n",886 " dth = np.divide(2*np.pi, n)\n",887 " theta_pref = np.arange(0, 2*np.pi, dth)\n",888 " pref_dir = np.transpose([np.cos(theta_pref), np.sin(theta_pref)])\n",889 " print(len(pos))\n",890 " #curr_dir = []\n",891 " #for i in range(len(theta_rad)):\n",892 " # dir = np.repeat(theta_rad[i],100)\n",893 " # curr_dir[i].append(np.cos(dir - theta_pref))\n",894 " hdi = preprocessing.normalize(np.cos(np.matlib.repmat(theta_pref, len(pos),1) - np.transpose((np.matlib.repmat(theta_rad[0:len(pos)],n, 1)))), norm='l2')\n",895 "\n",896 " #%% HD responses\n",897 " hd_resp = []\n",898 " for i in range(len(disp)):\n",899 " for j in range(len(pref_dir)):\n",900 " z = np.array(disp[i])\n",901 " dj = np.array(pref_dir[j])\n",902 " hd_resp.append(np.dot(z,dj))\n",903 " hd_resp = np.transpose(np.reshape(hd_resp, (len(disp),len(pref_dir))))\n",904 "\n",905 " #%% path integraion\n",906 " #beta = np.transpose(np.random.normal(9,2, size=(1,7)))\n",907 " # beta = np.arange(3,4,1)\n",908 " beta = [5]\n",909 " pi_layer_beta = [] \n",910 " for i in range(len(beta)):\n",911 " #pi_layer_temp = np.concatenate((np.cos(beta[i] * hd_resp),np.sin(beta[i] * hd_resp)))\n",912 " #pi_layer_temp = np.concatenate((beta[i] * hd_resp,beta[i] * hd_resp))\n",913 " pi_layer_temp = np.sin(beta[i] * hd_resp)\n",914 " #pi_layer_temp = (beta[i]* hd_resp)\n",915 " pi_layer_beta.append((pi_layer_temp))\n",916 " pi_layer_beta = np.asarray(pi_layer_beta)\n",917 " pi_beta = pi_layer_beta[0]\n",918 " for i in range(len(beta) - 1):\n",919 " pi_beta = np.concatenate((pi_beta, pi_layer_beta[i+1]))\n",920 " pi_lay = pi_beta.T\n",921 " # sub_pi = test_train(pi, test_p)\n",922 "\n",923 "\n",924 "##### ---------------------------- PI (WITH OSCILLATORS) ----------------------#########\n",925 "if pi_use == \"osc\":\n",926 " print(\"-------- using PI WITH oscillators --------\")\n",927 " trj_hd_resp = HD(speed, theta)\n",928 " #hd = np.asarray(trj_hd_resp)\n",929 " PI1d = PI(trj_hd_resp, speed)\n",930 " PI1d = np.transpose(PI1d)\n",931 " PI1d = preprocessing.normalize(PI1d, norm='l2', axis=1)\n",932 "\n",933 " hd_resp = [iii.T.reshape(100,1) for iii in trj_hd_resp]\n",934 " hd_resp = np.asarray(hd_resp).reshape(len(hd_resp), hd_resp[0].shape[0])\n",935 " hd_resp = preprocessing.normalize(hd_resp, norm='l2', axis=1)\n",936 " num_images = PI1d.shape[0]\n",937 " # d = {\"CAdns1\":CAdns1, \"CAdns2\":CAdns2, \"PIdns1\": PIdns1, \"PIdns2\":PIdns2, \"Lecdns\":Lecdns}\n",938 " # with open(fol+\"PI.pk1\", 'wb') as ff:\n",939 " # pickle.dump(PI1d, ff)\n",940 " # ff.close()\n",941 "\n",942 " # with open(fol + \"PI.pk1\", \"rb\") as f:\n",943 " # PI1d = pickle.load(f)\n",944 " # f.close()\n",945 "\n",946 " pi_lay = PI1d\n",947 " # sub_pi = test_train(pi, test_p)\n",948 "# pi = pi[:-1]\n",949 "from sklearn.model_selection import train_test_split\n",950 "\n",951 "# sub_imgs = train_test_split(train_imgs, test_size=0.2, random_state=random_state)\n",952 "# sub_pi = train_test_split(pi, test_size=0.2, random_state=random_state)\n",953 "# sub_comp_gt = train_test_split(comp_gt, test_size=0.2, random_state=random_state)\n",954 "# sub_r = train_test_split(reward, test_size=0.2, random_state=random_state)\n",955 "# print(sub_imgs[0].shape, sub_pi[0].shape, sub_comp_gt[0].shape, sub_r[0].shape)"956 ]957 },958 {959 "cell_type": "markdown",960 "metadata": {961 "id": "A7uyGjMicT89"962 },963 "source": [964 "---------------------------------\n",965 "---------------------------------\n",966 "---------------------------------\n",967 "### Test train split"968 ]969 },970 {971 "cell_type": "code",972 "execution_count": 157,973 "metadata": {974 "id": "24eHpv76CDik",975 "colab": {976 "base_uri": "https://localhost:8080/"977 },978 "outputId": "0b994658-9d78-49b7-8205-fb1ca2300673"979 },980 "outputs": [981 {982 "output_type": "stream",983 "name": "stdout",984 "text": [985 "(19999, 1, 32, 32, 3)\n",986 "(15999, 1, 100) (4000, 1, 100)\n",987 "(15999, 1, 32, 32, 3) (4000, 1, 32, 32, 3)\n",988 "(15999, 1) (4000, 1)\n"989 ]990 }991 ],992 "source": [993 "# GENERATING DATA FOR LSTM\n",994 "from sklearn.model_selection import train_test_split\n",995 "seq_len = 1\n",996 "\n",997 "pi_seq = seq_data(pi_lay, seq_len)\n",998 "train_imgs_seq = seq_data(train_imgs, seq_len)\n",999 "r_seq = seq_data(reward, seq_len)\n",1000 "print(train_imgs_seq.shape)\n",1001 "\n",1002 "sub_imgs_seq = train_test_split(train_imgs_seq, test_size=0.2, random_state=random_state)\n",1003 "# sub_imgs = train_test_split(train_imgs, test_size=0.2, random_state=random_state)\n",1004 "sub_pi_seq = train_test_split(pi_seq, test_size=0.2, random_state=random_state)\n",1005 "# sub_pi = train_test_split(pi_lay, test_size=0.2, random_state=random_state)\n",1006 "# sub_r = train_test_split(reward, test_size=0.2, random_state=random_state)\n",1007 "sub_r_seq = train_test_split(r_seq, test_size=0.2, random_state=random_state)\n",1008 "\n",1009 "# sub_comp_gt = train_test_split(comp_gt[:-1], test_size=0.2, random_state=random_state)\n",1010 "\n",1011 "sub_pi_t = sub_pi_seq\n",1012 "sub_imgs_t = sub_imgs_seq\n",1013 "sub_r_t = sub_r_seq\n",1014 "\n",1015 "print(sub_pi_t[0].shape, sub_pi_t[1].shape)\n",1016 "print(sub_imgs_t[0].shape, sub_imgs_t[1].shape)\n",1017 "# print(sub_comp_gt[0].shape, sub_comp_gt[1].shape)\n",1018 "print(sub_r_t[0].shape, sub_r_t[1].shape)"1019 ]1020 },1021 {1022 "cell_type": "markdown",1023 "metadata": {1024 "id": "A4i4kggHa8nA"1025 },1026 "source": [1027 "# MODEL"1028 ]1029 },1030 {1031 "cell_type": "markdown",1032 "metadata": {1033 "id": "ZrDV3pvd9pAE"1034 },1035 "source": [1036 "### Setup Architecture"1037 ]1038 },1039 {1040 "cell_type": "code",1041 "source": [1042 "from keras.layers import Dropout, GlobalAveragePooling2D\n",1043 "from keras.regularizers import l2\n",1044 "from tensorflow.keras.losses import categorical_crossentropy\n",1045 "from tensorflow.keras.constraints import max_norm\n",1046 "from tensorflow.keras.layers import Dense, RNN, LSTM, SimpleRNN\n",1047 "from keras.layers import ConvLSTM2D, TimeDistributed, MaxPooling3D, Conv3D\n",1048 "\n",1049 "#activity_regularizer=tf.keras.regularizers.l2(1)\n",1050 "# strides=(2,2) \n",1051 "if (Train) and (not stat_ful):\n",1052 " print(\"#########-----------------TRAINING MODEL---------------#########\")\n",1053 " act = 'relu'\n",1054 "\n",1055 "\n",1056 " input_img = Input((1, 32, 32, 3))\n",1057 " input_pi = Input((1, 100))\n",1058 " #input_pi = Input(shape = (1, 100))\n",1059 " #input_img = Input(shape = (1, 32, 32, 3))\n",1060 " encoder = Conv3D(8, (1, 5, 5), padding='same', activation= act, name=\"CONV_1\")(input_img)\n",1061 " encoder = MaxPooling3D(pool_size=(1,2,2), padding='same', name=\"MAXPOOL_1\")(encoder)\n",1062 " encoder = Conv3D(4, (1, 5, 5), padding='same', activation= act,name=\"CONV_2\")(encoder)\n",1063 " encoder = MaxPooling3D(pool_size=(1,2,2), padding='same', name=\"MAXPOOL_2\")(encoder)\n",1064 " encoder = Conv3D(2, (1, 5, 5), padding='same', activation= act,name=\"CONV_3\")(encoder)\n",1065 " encoder = MaxPooling3D(pool_size=(1,2,2), padding='same', name=\"MAXPOOL_3\")(encoder)\n",1066 " flatencoder=TimeDistributed(Flatten())(encoder) \n",1067 " #print(flatencoder.shape)\n",1068 " dense0 = TimeDistributed(Dense(50, activation = 'sigmoid'), name='LEC')(flatencoder)\n",1069 " #print(dense0.shape)\n",1070 " dense_pi1 = TimeDistributed(Dense(50, activation= 'sigmoid'), name='MEC')(input_pi)\n",1071 " #print(dense_pi1.shape)\n",1072 " dense0 = layers.Reshape((1,1,50))(dense0)\n",1073 " dense_pi1 = layers.Reshape((1,1,50))(dense_pi1)\n",1074 " #print(dense0.shape, dense_pi1.shape)\n",1075 " data_layer = layers.concatenate([dense0, dense_pi1], axis=1)\n",1076 " #print(data_layer.shape)\n",1077 "\n",1078 " edge_layer = tf.constant(np.matlib.repmat(np.asarray([[1/3,1/3], [1/3,1/3]]), 1, 1).reshape((1,1,2,2)))\n",1079 " # print (edge_layer.shape)\n",1080 " conv_layer = GraphConv(units=50, step_num=1,)([data_layer, edge_layer])\n",1081 " #print(\"conv_layer\", conv_layer.shape)\n",1082 " # conv_layer = layers.Reshape((1,2,50))(conv_layer)\n",1083 " print(\"conv_layer_N\", conv_layer.shape)\n",1084 " # rnn_0 = RNN(FF(25), return_sequences=True, name = \"LEC_LSTM\", stateful = True, return_state = False)(conv_layer[0,:,:])\n",1085 " # rnn_01 = RNN(FF(25), return_sequences=True, name = \"LEC_LSTM1\", stateful = True, return_state = False)(rnn_0)\n",1086 " # rnn_1= RNN(FF(25), return_sequences=True, name = \"MEC_LSTM\", stateful = True, return_state = False)(conv_layer[1,:,:])\n",1087 " # rnn_11 = RNN(FF(25), return_sequences=True, name = \"MEC_LSTM1\", stateful = True, return_state = False)(rnn_1)\n",1088 " #print(\"rnn\", rnn_0.shape),state_h11,state_c11\n",1089 " #conv_layer = Dropout(0.5)(rnn_0)\n",1090 " #temp_layer = layers.concatenate([conv_layer[:,0:1,:], rnn_0], axis = 1)\n",1091 " # temp_layer = layers.concatenate([rnn_01, rnn_11], axis = 1)\n",1092 " #print(\"temp_layer\", temp_layer.shape)\n",1093 "\n",1094 " conv_layer0 = Flatten()(conv_layer)\n",1095 " #print(\"conv_layer0\", conv_layer0.shape)\n",1096 " conv_layer0 = layers.Reshape((1,100))(conv_layer0)\n",1097 " rnn = RNN(FF(50), return_sequences=False, name = \"CA3_LSTM\", stateful = False, return_state = False)(conv_layer0)\n",1098 " #rnn = RNN(FF(100), return_sequences=False, name = \"CA3_FF\", stateful = False, return_state = False)(conv_layer0)\n",1099 " # dense1 = Dense(50, activation= 'sigmoid', name='CA1')(rnn)\n",1100 " output1 = Dense(1, activation='linear', name='VALUE1')(rnn)\n",1101 "\n",1102 " regressor_model = Model([input_img, input_pi], output1)\n",1103 "\n",1104 " opt = tf.keras.optimizers.Adam(learning_rate= 0.0001)\n",1105 " regressor_model.compile(optimizer=opt, loss=\"mse\", )\n",1106 " regressor_model.summary() \n",1107 "\n",1108 "# plot_model(regressor_model, to_file=fol+'Max_model1_plot.png', show_shapes=True, show_layer_names=True)"1109 ],1110 "metadata": {1111 "id": "tMK-cM2zILvp"1112 },1113 "execution_count": 158,1114 "outputs": []1115 },1116 {1117 "cell_type": "code",1118 "source": [1119 "from keras.layers import Dropout, GlobalAveragePooling2D\n",1120 "from keras.regularizers import l2\n",1121 "from tensorflow.keras.losses import categorical_crossentropy\n",1122 "from tensorflow.keras.constraints import max_norm\n",1123 "from tensorflow.keras.layers import Dense, RNN, LSTM, SimpleRNN\n",1124 "from keras.layers import ConvLSTM2D, TimeDistributed, MaxPooling3D, Conv3D\n",1125 "\n",1126 "#activity_regularizer=tf.keras.regularizers.l2(1)\n",1127 "# strides=(2,2) \n",1128 "if Train and stat_ful:\n",1129 " print(\"#########-----------------TRAINING MODEL---------------#########\")\n",1130 " act = 'relu'\n",1131 "\n",1132 "\n",1133 " input_img = Input(batch_shape=(10,1, 32, 32, 3))\n",1134 " input_pi = Input(batch_shape=(10,1, 100))\n",1135 " #input_pi = Input(shape = (1, 100))\n",1136 " #input_img = Input(shape = (1, 32, 32, 3))\n",1137 " encoder = Conv3D(8, (1, 5, 5), padding='same', activation= act, name=\"CONV_1\")(input_img)\n",1138 " encoder = MaxPooling3D(pool_size=(1,2,2), padding='same', name=\"MAXPOOL_1\")(encoder)\n",1139 " encoder = Conv3D(4, (1, 5, 5), padding='same', activation= act,name=\"CONV_2\")(encoder)\n",1140 " encoder = MaxPooling3D(pool_size=(1,2,2), padding='same', name=\"MAXPOOL_2\")(encoder)\n",1141 " encoder = Conv3D(2, (1, 5, 5), padding='same', activation= act,name=\"CONV_3\")(encoder)\n",1142 " encoder = MaxPooling3D(pool_size=(1,2,2), padding='same', name=\"MAXPOOL_3\")(encoder)\n",1143 " flatencoder=TimeDistributed(Flatten())(encoder) \n",1144 " #print(flatencoder.shape)\n",1145 " dense0 = TimeDistributed(Dense(50, activation = 'sigmoid'), name='LEC')(flatencoder)\n",1146 " #print(dense0.shape)\n",1147 " dense_pi1 = TimeDistributed(Dense(50, activation= 'sigmoid'), name='MEC')(input_pi)\n",1148 " #print(dense_pi1.shape)\n",1149 " dense0 = layers.Reshape((1,1,50))(dense0)\n",1150 " dense_pi1 = layers.Reshape((1,1,50))(dense_pi1)\n",1151 " #print(dense0.shape, dense_pi1.shape)\n",1152 " data_layer = layers.concatenate([dense0, dense_pi1], axis=1)\n",1153 " #print(data_layer.shape)\n",1154 "\n",1155 " edge_layer = tf.constant(np.matlib.repmat(np.asarray([[1/3,1/3], [1/3,1/3]]), 1, 1).reshape((1,1,2,2)))\n",1156 " # print (edge_layer.shape)\n",1157 " conv_layer = GraphConv(units=50, step_num=1,)([data_layer, edge_layer])\n",1158 " #print(\"conv_layer\", conv_layer.shape)\n",1159 " # conv_layer = layers.Reshape((1,2,50))(conv_layer)\n",1160 " print(\"conv_layer_N\", conv_layer.shape)\n",1161 " # rnn_0 = RNN(FF(25), return_sequences=True, name = \"LEC_LSTM\", stateful = True, return_state = False)(conv_layer[0,:,:])\n",1162 " # rnn_01 = RNN(FF(25), return_sequences=True, name = \"LEC_LSTM1\", stateful = True, return_state = False)(rnn_0)\n",1163 " # rnn_1= RNN(FF(25), return_sequences=True, name = \"MEC_LSTM\", stateful = True, return_state = False)(conv_layer[1,:,:])\n",1164 " # rnn_11 = RNN(FF(25), return_sequences=True, name = \"MEC_LSTM1\", stateful = True, return_state = False)(rnn_1)\n",1165 " #print(\"rnn\", rnn_0.shape),state_h11,state_c11\n",1166 " #conv_layer = Dropout(0.5)(rnn_0)\n",1167 " #temp_layer = layers.concatenate([conv_layer[:,0:1,:], rnn_0], axis = 1)\n",1168 " # temp_layer = layers.concatenate([rnn_01, rnn_11], axis = 1)\n",1169 " #print(\"temp_layer\", temp_layer.shape)\n",1170 "\n",1171 " conv_layer0 = Flatten()(conv_layer)\n",1172 " #print(\"conv_layer0\", conv_layer0.shape)\n",1173 " conv_layer0 = layers.Reshape((1,100))(conv_layer0)\n",1174 " rnn = RNN(FF(50), return_sequences=False, name = \"CA3_LSTM\", stateful = True, return_state = False)(conv_layer0)\n",1175 " #rnn = RNN(FF(100), return_sequences=False, name = \"CA3_FF\", stateful = False, return_state = False)(conv_layer0)\n",1176 " # dense1 = Dense(50, activation= 'sigmoid', name='CA1')(rnn)\n",1177 " output1 = Dense(1, activation='linear', name='VALUE1')(rnn)\n",1178 "\n",1179 " regressor_model = Model([input_img, input_pi], output1)\n",1180 "\n",1181 " opt = tf.keras.optimizers.Adam(learning_rate= 0.0001)\n",1182 " regressor_model.compile(optimizer=opt, loss=\"mse\", )\n",1183 " regressor_model.summary() \n",1184 "\n",1185 "# plot_model(regressor_model, to_file=fol+'Max_model1_plot.png', show_shapes=True, show_layer_names=True)"1186 ],1187 "metadata": {1188 "id": "Eojnd4exJ3v2"1189 },1190 "execution_count": 159,1191 "outputs": []1192 },1193 {1194 "cell_type": "markdown",1195 "metadata": {1196 "id": "9gxb_-QrsrIB"1197 },1198 "source": [1199 "### Train the model"1200 ]