jarvez/Object_representation_model-api

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

Showing the first 1,200 of 1805 lines. Download the file for the rest.