SOM_tensorflow2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "from ipywidgets import interact, interactive, fixed, interact_manual\n",
    "import ipywidgets as widjets\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sys import stdout\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from time import time\n",
    "np.random.seed(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SOMNetwork():\n",
    "    def __init__(self, x,y, dim=10, sigma=None, learning_rate=0.1, tau1=1000, tau2=1000, dtype=tf.float32,accuracy = 0.001,init_map=None):\n",
    "        np.random.seed(0)\n",
    "        self.dtype = dtype\n",
    "        self._X = x\n",
    "        self._Y = y\n",
    "        if init_map==None:\n",
    "            self._data = np.random.rand(x,y,dim)\n",
    "        else: \n",
    "            self._data = DATA.reshape(30,30,3)\n",
    "        self._map_weights = tf.Variable(self._data,dtype=self.dtype, name='weights')\n",
    "        self.dim = tf.constant(dim, dtype=tf.int64)\n",
    "        self._learning_rate = tf.constant(learning_rate, dtype=self.dtype, name='learning_rate')\n",
    "        self._sigma = tf.constant(sigma, dtype=self.dtype, name='sigma')\n",
    "        self._tau1 = tf.constant(tau1, dtype=self.dtype, name='tau_learn_rate')\n",
    "        self._tau2 = tf.constant(tau2, dtype=self.dtype, name='tau_sigma')\n",
    "        self._accuracy = accuracy\n",
    "        self._input = tf.placeholder(shape=[dim], dtype=self.dtype, name='input')\n",
    "        self._num_iter = tf.placeholder(dtype=self.dtype, name='iteration')\n",
    "        self.positions = tf.where(tf.fill([dim, dim], True)) #полезно\n",
    "        self._distance_map = tf.constant(self.Get_Distances(self._X, self._Y),dtype='float32') #[0,1,2,3,2,1]\n",
    "        self.SOM_MAP = 1   #сохраняем карту сюда после сессии\n",
    "        \n",
    "    def change_params(self,sigma=6, learning_rate=0.1, tau1=1000, tau2=1000, init_map=None):\n",
    "        self._sigma = tf.constant(sigma, dtype=self.dtype, name='sigma')\n",
    "        self._learning_rate = tf.constant(learning_rate, dtype=self.dtype, name='learning_rate')\n",
    "        self._tau1 = tf.constant(tau1, dtype=self.dtype, name='tau_learn_rate')\n",
    "        self._tau2 = tf.constant(tau2, dtype=self.dtype, name='tau_sigma')\n",
    "        self._data = init_map\n",
    "        self._map_weights = tf.Variable(self._data,dtype=self.dtype, name='weights')\n",
    "        \n",
    "    def _train(self):\n",
    "        with tf.name_scope('cooperation') as scope:\n",
    "            #Calculating BMU\n",
    "            bmu_location = self._won_neuron()\n",
    "            \n",
    "            _current_learning_rate = tf.maximum(self._learning_rate*tf.exp(-self._num_iter/self._tau1), 0.1)\n",
    "            _current_sigma = tf.maximum(self._sigma*tf.exp(-self._num_iter/self._tau2), 0.1)\n",
    "            \n",
    "            bmu_distance = tf.roll(self._distance_map,shift=bmu_location, axis=[0,1])\n",
    "            neighbourhood_func = tf.exp(-bmu_distance/(2*_current_sigma**2))\n",
    "            learning_rate_matrix = _current_learning_rate* neighbourhood_func\n",
    "            delta = tf.transpose(tf.transpose(self._input-self._map_weights)*tf.transpose(learning_rate_matrix))\n",
    "            new_weights = tf.add(self._map_weights, delta)\n",
    "            training_op = tf.assign(self._map_weights, new_weights)\n",
    "            \n",
    "        return training_op\n",
    "    \n",
    "    def _won_neuron(self):\n",
    "        #M = self._input - self._map_weights\n",
    "        #distance = tf.norm(self._input - self._map_weights,axis=-1)\n",
    "        distance = tf.sqrt(tf.reduce_sum(tf.square(self._input - self._map_weights), axis=-1))\n",
    "        bmu=tf.argmin(tf.reshape(distance, [-1]))\n",
    "        #bmu_location = self.positions[bmu]\n",
    "        bmu_location = tf.unravel_index(bmu, [self._X,self._Y])\n",
    "        return bmu_location\n",
    "    \n",
    "    def training(self, data, n_iters,Verbose=False):\n",
    "        #summary_writer = tf.summary.FileWriter('./logs/', tf.get_default_graph())\n",
    "        #summary_op = tf.summary.scalar('Functional_Z', self.FUNCTIONAL_Z())\n",
    "        init = tf.global_variables_initializer()\n",
    "        _data = tf.constant(data,dtype=self.dtype, name='data')\n",
    "        _training = self._train()\n",
    "        _functional = self.FUNCTIONAL_Z()\n",
    "        data_len = len(data)\n",
    "        temp_funq = 0\n",
    "        \n",
    "        with tf.Session() as sess:\n",
    "            init.run()\n",
    "            for i in range(n_iters):\n",
    "                n_item = np.random.randint(data_len)\n",
    "                sess.run(_training, feed_dict={self._input: data[n_item], self._num_iter:i})\n",
    "                if i % 50 == 0:\n",
    "                    #summary_writer.add_summary(sess.run(summary_op), i)\n",
    "                    new_funq=sess.run(_functional)\n",
    "                    if abs(temp_funq-new_funq)<self._accuracy: break\n",
    "                    temp_funq = np.copy(new_funq)\n",
    "                if Verbose:\n",
    "                    _to_print = f'\\r Iters = {i}, funq = {new_funq}'\n",
    "                    stdout.write(_to_print)\n",
    "            self.SOM_MAP = SOM._map_weights.eval()\n",
    "        sess.close()\n",
    "        return i, new_funq\n",
    "            \n",
    "    \n",
    "    def check_for_nodes(self,data):\n",
    "        def WIN_NEURON(vect):\n",
    "            distances=np.linalg.norm(self.SOM_MAP-vect,axis=-1)\n",
    "            index=np.argmin(distances)\n",
    "            return index\n",
    "        #for i in range(len(data)):\n",
    "        for vect in data:\n",
    "            a=WIN_NEURON(vect)\n",
    "            print(a)\n",
    "    \n",
    "    def Get_Distances(self,y,x):\n",
    "        def ring_closure(A):\n",
    "            if A==1: return [0]\n",
    "            a=np.arange(A)\n",
    "            max_val = int(len(a)/2)\n",
    "            max_ind=np.argwhere(a==max_val)[0,0]\n",
    "            if len(a)%2==0:\n",
    "                b=np.arange(1,a[max_ind])[::-1]\n",
    "            else:\n",
    "                b=np.arange(1,a[max_ind+1])[::-1]\n",
    "            a[max_ind+1:]=b\n",
    "            return a\n",
    "        yv=ring_closure(y)\n",
    "        xv=ring_closure(x)\n",
    "        XV, YV = np.meshgrid(xv, yv)\n",
    "        #res = np.stack((YV,XV), axis=-1)\n",
    "        res = np.sqrt(XV**2+YV**2)\n",
    "        return res\n",
    "    \n",
    "    def ring_closure(self,A):\n",
    "        if A==1: return [0]\n",
    "        a=np.arange(A)\n",
    "        max_val = int(len(a)/2)\n",
    "        max_ind=np.argwhere(a==max_val)[0,0]\n",
    "        if len(a)%2==0:\n",
    "            b=np.arange(1,a[max_ind])[::-1]\n",
    "        else:\n",
    "            b=np.arange(1,a[max_ind+1])[::-1]\n",
    "        a[max_ind+1:]=b\n",
    "        return a\n",
    "    \n",
    "    def FUNCTIONAL_Z(self):\n",
    "        #ATTENTION! Working only for 2D maps\n",
    "        #Functional_Z = 0\n",
    "        B=tf.roll(self._map_weights, shift=1, axis=0)\n",
    "        F1 = tf.reduce_sum(tf.norm(tf.subtract(self._map_weights,B),axis=-1))\n",
    "        B=tf.roll(self._map_weights, shift=1, axis=1)\n",
    "        F2 = tf.reduce_sum(tf.norm(tf.subtract(self._map_weights,B),axis=-1))\n",
    "        return F1+F2\n",
    "    \n",
    "    \n",
    "    def func_for_Q(self):\n",
    "        bmu = self._won_neuron()\n",
    "        dist = tf.norm(self._input-self._map_weights[bmu], axis=0)\n",
    "        return dist\n",
    "    \n",
    "    def FUNCTIONAL_Q(self):\n",
    "        FUNC = tf.Variable(0)\n",
    "        init = tf.global_variables_initializer()\n",
    "        with tf.Session() as sess:\n",
    "            init.run()\n",
    "            for i in range(len(DATA)):\n",
    "                FUNC+=sess.run(func_for_Q, feed_dict = {self._input:DATA[i]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "#DATA = np.load('cube100x100_60.npy')\n",
    "#DATA = np.load('cube100x100_30.npy')\n",
    "#DATA = np.load('cube100x100_30x30_2D.npy')\n",
    "DATA = np.load('data_circle_30x30_2D.npy')\n",
    "#print(DATA[111])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "307.493861325969"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def Functional_Z(a):\n",
    "    F1 = np.linalg.norm(a-np.roll(a,1,axis=0), axis=-1).sum()\n",
    "    F2 = np.linalg.norm(a-np.roll(a,1,axis=1), axis=-1).sum()\n",
    "    return F1+F2\n",
    "Functional_Z(DATA.reshape(30,30,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Iters = 12999, funq = 289.47052001953125time taken:  12.802255868911743\n",
      "took13000 iters, funq 289.47027587890625\n"
     ]
    }
   ],
   "source": [
    "#SOM = SOMNetwork(x=30,y=30,dim=len(DATA[0]),sigma=2,learning_rate=1,tau1=1000,tau2=1000,dtype=tf.float32)  ну кое как\n",
    "SOM = SOMNetwork(x=30,y=30,dim=len(DATA[0]),sigma=2,learning_rate=1,tau1=3000,tau2=3000,dtype=tf.float32)\n",
    "#SOM.test()\n",
    "time_start=time()\n",
    "iters, funq = SOM.training(DATA, 40000, Verbose=True)\n",
    "print('time taken: ',time()-time_start)\n",
    "print(f'took{iters} iters, funq {funq}')\n",
    "\n",
    "#SOM.look_for_nodes(DATA)\n",
    "SOM_MAP = SOM.SOM_MAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Iters = 2399, funq = 280.78979492187595\n",
      "time taken:  2.5320796966552734\n",
      "took2400 iters, funq 280.7889099121094\n"
     ]
    }
   ],
   "source": [
    "SOM.change_params(sigma=1,learning_rate=1,tau1=2000,tau2=1000, init_map=DATA.reshape(30,30,3))\n",
    "time_start=time()\n",
    "iters, funq = SOM.training(DATA, 40000, Verbose=True)\n",
    "print()\n",
    "print('time taken: ',time()-time_start)\n",
    "print(f'took{iters} iters, funq {funq}')\n",
    "SOM_MAP = SOM.SOM_MAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#DATA1 = DATA.reshape(30,30,3)\n",
    "DATA1 = SOM_MAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b47dd02acdde42a1906cf167a64f0f65",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='i', max=29), Output()), _dom_classes=('widget-interact',…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "DATA1 = SOM_MAP\n",
    "@interact(i=(0,29,1))\n",
    "def print_circle(i=0):\n",
    "    fig = plt.figure(figsize=(10,5))\n",
    "    ax = fig.add_subplot(121, projection='3d')\n",
    "    plt.xlim(-1, 1)\n",
    "    plt.ylim(-1, 1)\n",
    "    xs = SOM_MAP[:,i, 0]\n",
    "    ys = SOM_MAP[:,i, 1]\n",
    "    zs = SOM_MAP[:,i, 2]\n",
    "    ax.plot(xs, ys, zs, marker='^')\n",
    "    \n",
    "    xs = SOM_MAP[i,:, 0]\n",
    "    ys = SOM_MAP[i,:, 1]\n",
    "    zs = SOM_MAP[i,:, 2]\n",
    "\n",
    "    ax.plot(xs, ys, zs, marker='^')\n",
    "\n",
    "    ax.set_xlabel('X')\n",
    "    ax.set_ylabel('Y')\n",
    "    ax.set_zlabel('Z')\n",
    "\n",
    "    ax1 = fig.add_subplot(122, projection='3d')\n",
    "    plt.xlim(-1, 1)\n",
    "    plt.ylim(-1, 1)\n",
    "    #plt.zlim(-1, 1)\n",
    "    DD=SOM_MAP.reshape(-1,3)\n",
    "    xs = DD[:, 0]\n",
    "    ys = DD[:, 1]\n",
    "    zs = DD[:, 2]\n",
    "    ax1.scatter(xs, ys, zs, c='b', marker='^')\n",
    "    #ax.plot(xs, ys, zs, marker='^')\n",
    "    ax1.set_xlabel('X')\n",
    "    ax1.set_ylabel('Y')\n",
    "    ax1.set_zlabel('Z')\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "from mayavi.mlab import *\n",
    "\n",
    "def test_points3d():\n",
    "    dd=DATA1.reshape(-1,3)\n",
    "    x = dd[:,0]\n",
    "    y = dd[:,1]\n",
    "    z = dd[:,2]\n",
    "\n",
    "    return points3d(x, y, z, colormap=\"copper\", scale_factor=.1)\n",
    "\n",
    "test_points3d()\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bad3aaed3a1a457cafab1c34d5c9c15c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='i', max=29), Output()), _dom_classes=('widget-interact',…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@interact(i=(0,29,1))\n",
    "def print_circle(i=0):\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "    plt.xlim(-1, 1)\n",
    "    plt.ylim(-1, 1)\n",
    "    #plt.zlim(-1, 1)\n",
    "    xs = DATA1[i,:, 0]\n",
    "    ys = DATA1[i,:, 1]\n",
    "    zs = DATA1[i,:, 2]\n",
    "    #ax.scatter(xs, ys, zs, c='b', marker='^')\n",
    "    ax.plot(xs, ys, zs, marker='^')\n",
    "\n",
    "    ax.set_xlabel('X')\n",
    "    ax.set_ylabel('Y')\n",
    "    ax.set_zlabel('Z')\n",
    "\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "793daceda7e140cf91373c15575a0ffd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='i', max=29), Output()), _dom_classes=('widget-interact',…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def _iterator():\n",
    "    for learn_rate in [1]:\n",
    "        for sigma in np.linspace(1, 30, 6):\n",
    "            for tau1 in np.linspace(100, 5000, 10):\n",
    "                for tau2 in np.linspace(100, 1500, 3):\n",
    "                    yield (np.array([learn_rate, sigma, tau1, tau2]))\n",
    "        \n",
    "def worker(x):\n",
    "    \n",
    "    learn_rate, sigma, tau1, tau2 = x\n",
    "    SOM.change_params(sigma,learn_rate,tau1, tau2)\n",
    "    iters, funq = SOM.training(DATA, 5000)\n",
    "    \n",
    "    res = [learn_rate, sigma, tau1, tau2, iters, funq]\n",
    "    #print(f'{res}, time {Time_exec}')\n",
    "    return res\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "SOM = SOMNetwork(x=len(DATA),dim=len(DATA[0]),sigma=2,learning_rate=1,tau1=2000,tau2=100,dtype=tf.float32)\n",
    "testing_params = []\n",
    "for num_iter,x in enumerate(_iterator()):\n",
    "    time_start = time()\n",
    "    res = worker(x)\n",
    "    Time_exec = time()-time_start\n",
    "    print(f'iter {num_iter}, res {res},time {Time_exec}')\n",
    "    testing_params.append(res)\n",
    "    if num_iter % 10==0:\n",
    "        np.save('testing_params3.npy',np.array(testing_params))\n",
    "np.save('testing_params3.npy',np.array(testing_params))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c80e0a2f4a9e46f486272dfc2e51c46d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='i', max=29), Output()), _dom_classes=('widget-interact',…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@interact(i=(0,29,1))\n",
    "def print_circle(i=0):\n",
    "    plt.figure(figsize=(4,4))\n",
    "    x = SOM_MAP[:,i,0]\n",
    "    y = SOM_MAP[:,i,1]\n",
    "    plt.xlim(-1, 1)\n",
    "    plt.ylim(-1, 1)\n",
    "    plt.plot(x,y,'o-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "361461f654fc4176bdaf8ccefee2a886",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='x', max=29), IntSlider(value=0, description='y', max=29)…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@interact(x=(0,29,1), y=(0,29,1))\n",
    "def test(x=0,y=0):\n",
    "    plt.imshow(SOM_MAP[x,y].reshape(100,100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "702b690b05004835b1f2d7ffa466b502",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=449, description='i', max=899), Output()), _dom_classes=('widget-interac…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@interact(i=(0,len(DATA)-1,1))\n",
    "def test(i):\n",
    "    plt.imshow(DATA[i].reshape(100,100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter 0, res [1.0, 1.0, 100.0, 100.0, 11800, 273.28723],time 9.641743898391724\n",
      "iter 1, res [1.0, 1.0, 100.0, 644.4444444444445, 16200, 282.67715],time 13.621647834777832\n",
      "iter 2, res [1.0, 1.0, 100.0, 1188.888888888889, 19000, 283.2836],time 16.02179217338562\n",
      "iter 3, res [1.0, 1.0, 100.0, 1733.3333333333335, 21350, 279.82565],time 17.896175861358643\n",
      "iter 4, res [1.0, 1.0, 100.0, 2277.777777777778, 12950, 268.96747],time 11.13916802406311\n",
      "iter 5, res [1.0, 1.0, 100.0, 2822.222222222222, 10150, 257.77475],time 8.602128028869629\n",
      "iter 6, res [1.0, 1.0, 100.0, 3366.666666666667, 6700, 263.4489],time 5.83296012878418\n",
      "iter 7, res [1.0, 1.0, 100.0, 3911.1111111111113, 14650, 269.5352],time 12.176800012588501\n",
      "iter 8, res [1.0, 1.0, 100.0, 4455.555555555556, 10300, 269.4231],time 8.742496013641357\n",
      "iter 9, res [1.0, 1.0, 100.0, 5000.0, 13350, 259.90826],time 11.357407808303833\n",
      "iter 10, res [1.0, 1.0, 644.4444444444445, 100.0, 2650, 273.5124],time 2.500831365585327\n",
      "iter 11, res [1.0, 1.0, 644.4444444444445, 644.4444444444445, 12250, 272.23767],time 10.210654973983765\n",
      "iter 12, res [1.0, 1.0, 644.4444444444445, 1188.888888888889, 7600, 269.00247],time 6.624576568603516\n",
      "iter 13, res [1.0, 1.0, 644.4444444444445, 1733.3333333333335, 6750, 265.06134],time 5.891488075256348\n",
      "iter 14, res [1.0, 1.0, 644.4444444444445, 2277.777777777778, 9600, 269.7953],time 8.235088109970093\n",
      "iter 15, res [1.0, 1.0, 644.4444444444445, 2822.222222222222, 9050, 261.7158],time 7.70139217376709\n",
      "iter 16, res [1.0, 1.0, 644.4444444444445, 3366.666666666667, 16200, 276.72174],time 13.711920261383057\n",
      "iter 17, res [1.0, 1.0, 644.4444444444445, 3911.1111111111113, 9200, 262.6457],time 7.898799657821655\n",
      "iter 18, res [1.0, 1.0, 644.4444444444445, 4455.555555555556, 16650, 269.7519],time 14.317039966583252\n",
      "iter 19, res [1.0, 1.0, 644.4444444444445, 5000.0, 19100, 268.95236],time 16.117023944854736\n",
      "iter 20, res [1.0, 1.0, 1188.888888888889, 100.0, 3050, 275.40265],time 3.1138880252838135\n",
      "iter 21, res [1.0, 1.0, 1188.888888888889, 644.4444444444445, 3650, 280.60144],time 3.3395678997039795\n",
      "iter 22, res [1.0, 1.0, 1188.888888888889, 1188.888888888889, 7400, 276.67355],time 6.376079797744751\n",
      "iter 23, res [1.0, 1.0, 1188.888888888889, 1733.3333333333335, 11750, 274.8025],time 10.067808151245117\n",
      "iter 24, res [1.0, 1.0, 1188.888888888889, 2277.777777777778, 16750, 275.8969],time 14.688047885894775\n",
      "iter 25, res [1.0, 1.0, 1188.888888888889, 2822.222222222222, 11050, 272.03302],time 10.052431583404541\n",
      "iter 26, res [1.0, 1.0, 1188.888888888889, 3366.666666666667, 11150, 265.41174],time 10.064831972122192\n",
      "iter 27, res [1.0, 1.0, 1188.888888888889, 3911.1111111111113, 12450, 268.94287],time 10.81825590133667\n",
      "iter 28, res [1.0, 1.0, 1188.888888888889, 4455.555555555556, 15950, 272.792],time 13.868160009384155\n",
      "iter 29, res [1.0, 1.0, 1188.888888888889, 5000.0, 14750, 267.24634],time 12.727856159210205\n",
      "iter 30, res [1.0, 1.0, 1733.3333333333335, 100.0, 5100, 282.39276],time 4.513104677200317\n",
      "iter 31, res [1.0, 1.0, 1733.3333333333335, 644.4444444444445, 7200, 285.03433],time 6.203471899032593\n",
      "iter 32, res [1.0, 1.0, 1733.3333333333335, 1188.888888888889, 6750, 279.06354],time 5.897936105728149\n",
      "iter 33, res [1.0, 1.0, 1733.3333333333335, 1733.3333333333335, 4900, 266.1949],time 4.280479907989502\n",
      "iter 34, res [1.0, 1.0, 1733.3333333333335, 2277.777777777778, 6150, 269.2079],time 5.481295824050903\n",
      "iter 35, res [1.0, 1.0, 1733.3333333333335, 2822.222222222222, 6200, 268.16492],time 5.472368001937866\n",
      "iter 36, res [1.0, 1.0, 1733.3333333333335, 3366.666666666667, 14400, 277.74808],time 12.222928285598755\n",
      "iter 37, res [1.0, 1.0, 1733.3333333333335, 3911.1111111111113, 16850, 274.34222],time 14.315055847167969\n",
      "iter 38, res [1.0, 1.0, 1733.3333333333335, 4455.555555555556, 15000, 268.47348],time 12.567152261734009\n",
      "iter 39, res [1.0, 1.0, 1733.3333333333335, 5000.0, 13600, 273.9793],time 11.420399904251099\n",
      "iter 40, res [1.0, 1.0, 2277.777777777778, 100.0, 1250, 285.81326],time 1.4607198238372803\n",
      "iter 41, res [1.0, 1.0, 2277.777777777778, 644.4444444444445, 3950, 288.96484],time 3.6803200244903564\n",
      "iter 42, res [1.0, 1.0, 2277.777777777778, 1188.888888888889, 3800, 281.3468],time 3.566240072250366\n",
      "iter 43, res [1.0, 1.0, 2277.777777777778, 1733.3333333333335, 5200, 276.96954],time 4.688191890716553\n",
      "iter 44, res [1.0, 1.0, 2277.777777777778, 2277.777777777778, 8000, 278.46033],time 6.806112051010132\n",
      "iter 45, res [1.0, 1.0, 2277.777777777778, 2822.222222222222, 12450, 278.08917],time 10.667471885681152\n",
      "iter 46, res [1.0, 1.0, 2277.777777777778, 3366.666666666667, 4900, 265.45084],time 4.544847726821899\n",
      "iter 47, res [1.0, 1.0, 2277.777777777778, 3911.1111111111113, 9300, 271.5138],time 7.9454240798950195\n",
      "iter 48, res [1.0, 1.0, 2277.777777777778, 4455.555555555556, 18300, 278.42212],time 16.104126930236816\n",
      "iter 49, res [1.0, 1.0, 2277.777777777778, 5000.0, 17400, 271.72998],time 14.828416109085083\n",
      "iter 50, res [1.0, 1.0, 2822.222222222222, 100.0, 3900, 292.28748],time 3.672384023666382\n",
      "iter 51, res [1.0, 1.0, 2822.222222222222, 644.4444444444445, 5400, 291.13263],time 4.886095762252808\n",
      "iter 52, res [1.0, 1.0, 2822.222222222222, 1188.888888888889, 4000, 282.50903],time 3.7581918239593506\n",
      "iter 53, res [1.0, 1.0, 2822.222222222222, 1733.3333333333335, 4500, 280.62054],time 4.1619367599487305\n",
      "iter 54, res [1.0, 1.0, 2822.222222222222, 2277.777777777778, 7650, 280.38086],time 6.7966883182525635\n",
      "iter 55, res [1.0, 1.0, 2822.222222222222, 2822.222222222222, 8600, 273.28534],time 7.267888069152832\n",
      "iter 56, res [1.0, 1.0, 2822.222222222222, 3366.666666666667, 13050, 275.74252],time 11.142143964767456\n",
      "iter 57, res [1.0, 1.0, 2822.222222222222, 3911.1111111111113, 6350, 271.69324],time 5.860735893249512\n",
      "iter 58, res [1.0, 1.0, 2822.222222222222, 4455.555555555556, 14750, 273.36218],time 12.672799587249756\n",
      "iter 59, res [1.0, 1.0, 2822.222222222222, 5000.0, 13150, 278.81787],time 11.391631841659546\n",
      "iter 60, res [1.0, 1.0, 3366.666666666667, 100.0, 2650, 288.82037],time 2.696255922317505\n",
      "iter 61, res [1.0, 1.0, 3366.666666666667, 644.4444444444445, 8150, 294.1988],time 7.336336135864258\n",
      "iter 62, res [1.0, 1.0, 3366.666666666667, 1188.888888888889, 5850, 289.5829],time 5.342912197113037\n",
      "iter 63, res [1.0, 1.0, 3366.666666666667, 1733.3333333333335, 6900, 284.43768],time 6.1995038986206055\n",
      "iter 64, res [1.0, 1.0, 3366.666666666667, 2277.777777777778, 4100, 275.14697],time 3.8955838680267334\n",
      "iter 65, res [1.0, 1.0, 3366.666666666667, 2822.222222222222, 7700, 279.21545],time 6.871088266372681\n",
      "iter 66, res [1.0, 1.0, 3366.666666666667, 3366.666666666667, 8450, 274.60776],time 7.34377646446228\n",
      "iter 67, res [1.0, 1.0, 3366.666666666667, 3911.1111111111113, 7850, 276.92715],time 7.01095986366272\n",
      "iter 68, res [1.0, 1.0, 3366.666666666667, 4455.555555555556, 14400, 281.50073],time 12.381648302078247\n",
      "iter 69, res [1.0, 1.0, 3366.666666666667, 5000.0, 9650, 274.9046],time 8.532191753387451\n",
      "iter 70, res [1.0, 1.0, 3911.1111111111113, 100.0, 7150, 296.16278],time 6.659791946411133\n",
      "iter 71, res [1.0, 1.0, 3911.1111111111113, 644.4444444444445, 5700, 287.25092],time 5.895951986312866\n",
      "iter 72, res [1.0, 1.0, 3911.1111111111113, 1188.888888888889, 5500, 281.6623],time 6.44601583480835\n",
      "iter 73, res [1.0, 1.0, 3911.1111111111113, 1733.3333333333335, 5100, 284.15997],time 5.906863451004028\n",
      "iter 74, res [1.0, 1.0, 3911.1111111111113, 2277.777777777778, 5900, 279.04456],time 6.615648031234741\n",
      "iter 75, res [1.0, 1.0, 3911.1111111111113, 2822.222222222222, 8500, 278.46088],time 9.208239793777466\n",
      "iter 76, res [1.0, 1.0, 3911.1111111111113, 3366.666666666667, 8850, 276.3739],time 9.507823944091797\n",
      "iter 77, res [1.0, 1.0, 3911.1111111111113, 3911.1111111111113, 10800, 285.5728],time 11.330623865127563\n",
      "iter 78, res [1.0, 1.0, 3911.1111111111113, 4455.555555555556, 8350, 275.33954],time 9.253870964050293\n",
      "iter 79, res [1.0, 1.0, 3911.1111111111113, 5000.0, 13700, 273.17444],time 14.534784078598022\n",
      "iter 80, res [1.0, 1.0, 4455.555555555556, 100.0, 5100, 294.6414],time 5.655392169952393\n",
      "iter 81, res [1.0, 1.0, 4455.555555555556, 644.4444444444445, 4600, 297.26013],time 5.213455677032471\n",
      "iter 82, res [1.0, 1.0, 4455.555555555556, 1188.888888888889, 7300, 280.81113],time 7.935504198074341\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter 83, res [1.0, 1.0, 4455.555555555556, 1733.3333333333335, 5200, 282.88654],time 5.645967960357666\n",
      "iter 84, res [1.0, 1.0, 4455.555555555556, 2277.777777777778, 5550, 283.10645],time 6.27340841293335\n",
      "iter 85, res [1.0, 1.0, 4455.555555555556, 2822.222222222222, 4650, 279.20667],time 5.82750391960144\n",
      "iter 86, res [1.0, 1.0, 4455.555555555556, 3366.666666666667, 300, 230.92793],time 1.0167999267578125\n",
      "iter 87, res [1.0, 1.0, 4455.555555555556, 3911.1111111111113, 10200, 281.1918],time 10.782048225402832\n",
      "iter 88, res [1.0, 1.0, 4455.555555555556, 4455.555555555556, 9950, 275.3177],time 12.530944108963013\n",
      "iter 89, res [1.0, 1.0, 4455.555555555556, 5000.0, 1950, 249.82382],time 3.048912286758423\n",
      "iter 90, res [1.0, 1.0, 5000.0, 100.0, 7400, 295.59326],time 9.958192110061646\n",
      "iter 91, res [1.0, 1.0, 5000.0, 644.4444444444445, 6500, 290.39746],time 8.497472286224365\n",
      "iter 92, res [1.0, 1.0, 5000.0, 1188.888888888889, 9100, 282.0078],time 9.875856161117554\n",
      "iter 93, res [1.0, 1.0, 5000.0, 1733.3333333333335, 7500, 283.7226],time 6.982687950134277\n",
      "iter 94, res [1.0, 1.0, 5000.0, 2277.777777777778, 5500, 280.19147],time 5.102352142333984\n",
      "iter 95, res [1.0, 1.0, 5000.0, 2822.222222222222, 7550, 281.78284],time 6.828431844711304\n",
      "iter 96, res [1.0, 1.0, 5000.0, 3366.666666666667, 8850, 281.67627],time 8.302543878555298\n",
      "iter 97, res [1.0, 1.0, 5000.0, 3911.1111111111113, 5900, 272.66516],time 6.720799922943115\n",
      "iter 98, res [1.0, 1.0, 5000.0, 4455.555555555556, 8150, 286.63672],time 7.680063724517822\n",
      "iter 99, res [1.0, 1.0, 5000.0, 5000.0, 9600, 276.83417],time 8.3962881565094\n",
      "iter 100, res [1.0, 6.8, 100.0, 100.0, 13000, 218.71674],time 11.326159715652466\n",
      "iter 101, res [1.0, 6.8, 100.0, 644.4444444444445, 25500, 287.409],time 21.97478413581848\n",
      "iter 102, res [1.0, 6.8, 100.0, 1188.888888888889, 15350, 282.55896],time 13.683647871017456\n",
      "iter 103, res [1.0, 6.8, 100.0, 1733.3333333333335, 15050, 280.18658],time 13.965375661849976\n",
      "iter 104, res [1.0, 6.8, 100.0, 2277.777777777778, 27250, 289.9394],time 25.018736124038696\n",
      "iter 105, res [1.0, 6.8, 100.0, 2822.222222222222, 30800, 284.4142],time 26.60643219947815\n",
      "iter 106, res [1.0, 6.8, 100.0, 3366.666666666667, 25950, 281.11322],time 22.84328031539917\n",
      "iter 107, res [1.0, 6.8, 100.0, 3911.1111111111113, 24350, 282.153],time 21.47779083251953\n",
      "iter 108, res [1.0, 6.8, 100.0, 4455.555555555556, 37200, 282.86572],time 31.475663900375366\n",
      "iter 109, res [1.0, 6.8, 100.0, 5000.0, 28150, 278.0346],time 24.139328002929688\n",
      "iter 110, res [1.0, 6.8, 644.4444444444445, 100.0, 21250, 311.07828],time 18.224031448364258\n",
      "iter 111, res [1.0, 6.8, 644.4444444444445, 644.4444444444445, 19050, 293.72992],time 16.59665584564209\n",
      "iter 112, res [1.0, 6.8, 644.4444444444445, 1188.888888888889, 18300, 295.47833],time 15.892336130142212\n",
      "iter 113, res [1.0, 6.8, 644.4444444444445, 1733.3333333333335, 15250, 284.69278],time 13.67571210861206\n",
      "iter 114, res [1.0, 6.8, 644.4444444444445, 2277.777777777778, 23500, 285.4159],time 20.351871967315674\n",
      "iter 115, res [1.0, 6.8, 644.4444444444445, 2822.222222222222, 22750, 281.73938],time 19.62721586227417\n",
      "iter 116, res [1.0, 6.8, 644.4444444444445, 3366.666666666667, 15000, 270.38434],time 13.103327751159668\n",
      "iter 117, res [1.0, 6.8, 644.4444444444445, 3911.1111111111113, 18350, 270.2013],time 15.838272094726562\n",
      "iter 118, res [1.0, 6.8, 644.4444444444445, 4455.555555555556, 4550, 55.729446],time 4.589984178543091\n",
      "iter 119, res [1.0, 6.8, 644.4444444444445, 5000.0, 27100, 277.16284],time 23.365071773529053\n",
      "iter 120, res [1.0, 6.8, 1188.888888888889, 100.0, 7750, 302.23102],time 7.870527982711792\n",
      "iter 121, res [1.0, 6.8, 1188.888888888889, 644.4444444444445, 17350, 301.51944],time 16.69932794570923\n",
      "iter 122, res [1.0, 6.8, 1188.888888888889, 1188.888888888889, 15300, 289.20984],time 13.899904251098633\n"
     ]
    }
   ],
   "source": [
    "def _iterator():\n",
    "    for learn_rate in [1]:\n",
    "        for sigma in np.linspace(1, 30, 6):\n",
    "            for tau1 in np.linspace(100, 5000, 10):\n",
    "                for tau2 in np.linspace(100, 5000, 10):\n",
    "                    yield (np.array([learn_rate, sigma, tau1, tau2]))\n",
    "        \n",
    "def worker(x):\n",
    "    \n",
    "    learn_rate, sigma, tau1, tau2 = x\n",
    "    SOM.change_params(sigma=sigma,learning_rate=learn_rate,tau1=tau1,tau2=tau2, init_map=DATA.reshape(30,30,3))\n",
    "    iters, funq = SOM.training(DATA, 40000)\n",
    "    \n",
    "    res = [learn_rate, sigma, tau1, tau2, iters, funq]\n",
    "    #print(f'{res}, time {Time_exec}')\n",
    "    return res\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "SOM = SOMNetwork(x=30,y=30,dim=len(DATA[0]),sigma=2,learning_rate=1,tau1=2000,tau2=100,dtype=tf.float32)\n",
    "testing_params = []\n",
    "for num_iter,x in enumerate(_iterator()):\n",
    "    time_start = time()\n",
    "    res = worker(x)\n",
    "    Time_exec = time()-time_start\n",
    "    print(f'iter {num_iter}, res {res},time {Time_exec}')\n",
    "    testing_params.append(res)\n",
    "    if num_iter %10==0:\n",
    "        np.save('testing_params2.npy',np.array(testing_params))\n",
    "np.save('testing_params2.npy',np.array(testing_params))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([  2,  11,  34,  61,  73,  78,  85, 100, 108, 122, 137, 142, 149,\n",
      "       156, 163, 178, 185, 192, 198, 204], dtype=int64),)\n",
      "[[1.00000000e+00 6.00000000e+00 4.22222222e+02 1.00000000e+02\n",
      "  8.50000000e+02 1.45321922e+05]\n",
      " [1.00000000e+00 6.00000000e+00 7.44444444e+02 1.00000000e+02\n",
      "  8.50000000e+02 1.44185438e+05]\n",
      " [1.00000000e+00 6.00000000e+00 1.71111111e+03 1.00000000e+02\n",
      "  7.00000000e+02 1.44024766e+05]\n",
      " [1.00000000e+00 6.00000000e+00 3.00000000e+03 1.00000000e+02\n",
      "  5.50000000e+02 1.41588531e+05]\n",
      " [1.00000000e+00 7.55555556e+00 4.22222222e+02 1.00000000e+02\n",
      "  8.00000000e+02 1.44922344e+05]\n",
      " [1.00000000e+00 7.55555556e+00 7.44444444e+02 1.00000000e+02\n",
      "  6.00000000e+02 1.42638297e+05]\n",
      " [1.00000000e+00 7.55555556e+00 1.06666667e+03 1.00000000e+02\n",
      "  7.00000000e+02 1.44515531e+05]\n",
      " [1.00000000e+00 7.55555556e+00 1.71111111e+03 1.00000000e+02\n",
      "  6.00000000e+02 1.47580906e+05]\n",
      " [1.00000000e+00 7.55555556e+00 2.03333333e+03 1.00000000e+02\n",
      "  5.00000000e+02 1.43369109e+05]\n",
      " [1.00000000e+00 7.55555556e+00 2.67777778e+03 1.00000000e+02\n",
      "  6.00000000e+02 1.44564844e+05]\n",
      " [1.00000000e+00 9.11111111e+00 4.22222222e+02 1.00000000e+02\n",
      "  9.50000000e+02 1.42522391e+05]\n",
      " [1.00000000e+00 9.11111111e+00 7.44444444e+02 1.00000000e+02\n",
      "  8.50000000e+02 1.43452469e+05]\n",
      " [1.00000000e+00 9.11111111e+00 1.06666667e+03 1.00000000e+02\n",
      "  9.50000000e+02 1.41628094e+05]\n",
      " [1.00000000e+00 9.11111111e+00 1.38888889e+03 1.00000000e+02\n",
      "  6.00000000e+02 1.43407562e+05]\n",
      " [1.00000000e+00 9.11111111e+00 1.71111111e+03 1.00000000e+02\n",
      "  8.00000000e+02 1.44752469e+05]\n",
      " [1.00000000e+00 9.11111111e+00 2.67777778e+03 1.00000000e+02\n",
      "  5.50000000e+02 1.48712625e+05]\n",
      " [1.00000000e+00 9.11111111e+00 3.00000000e+03 1.00000000e+02\n",
      "  5.50000000e+02 1.41352875e+05]\n",
      " [1.00000000e+00 1.06666667e+01 4.22222222e+02 1.00000000e+02\n",
      "  8.50000000e+02 1.41988969e+05]\n",
      " [1.00000000e+00 1.06666667e+01 7.44444444e+02 1.00000000e+02\n",
      "  6.50000000e+02 1.41618656e+05]\n",
      " [1.00000000e+00 1.06666667e+01 1.06666667e+03 1.00000000e+02\n",
      "  9.00000000e+02 1.46978547e+05]]\n"
     ]
    }
   ],
   "source": [
    "a=np.load('testing_params1.npy')\n",
    "ind = np.where(a[:,5]>135000)\n",
    "a=a[ind]\n",
    "ind = np.where(a[:,5]<150000)\n",
    "a=a[ind]\n",
    "ind = np.where(a[:,4]<1000)\n",
    "print(ind)\n",
    "print(a[ind])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Summary name Learning rate is illegal; using Learning_rate instead.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 0\n",
      "iter: 1000\n",
      "iter: 2000\n",
      "iter: 3000\n",
      "iter: 4000\n",
      "iter: 5000\n",
      "iter: 6000\n",
      "iter: 7000\n",
      "iter: 8000\n",
      "iter: 9000\n",
      "iter: 10000\n",
      "iter: 11000\n",
      "iter: 12000\n",
      "iter: 13000\n",
      "iter: 14000\n",
      "iter: 15000\n",
      "iter: 16000\n",
      "iter: 17000\n",
      "iter: 18000\n",
      "iter: 19000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22.28634023666382\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt     \n",
    "\n",
    "class SOMNetwork():\n",
    "\tdef __init__(self, input_dim, dim=10, sigma=None, learning_rate=0.1, tay2=1000, dtype=tf.float32):\n",
    "\t\tif not sigma:\n",
    "\t\t\tsigma = dim / 2\n",
    "\t\tself.dtype = dtype\n",
    "\t\t#constants\n",
    "\t\tself.dim = tf.constant(dim, dtype=tf.int64)\n",
    "\t\tself.learning_rate = tf.constant(learning_rate, dtype=dtype, name='learning_rate')\n",
    "\t\tself.sigma = tf.constant(sigma, dtype=dtype, name='sigma')\n",
    "\t\tself.tay1 = tf.constant(1000/np.log(sigma), dtype=dtype, name='tay1')\n",
    "\t\tself.minsigma = tf.constant(sigma * np.exp(-1000/(1000/np.log(sigma))), dtype=dtype, name='min_sigma')\n",
    "\t\tself.tay2 = tf.constant(tay2, dtype=dtype, name='tay2')\n",
    "\t\t#input vector\n",
    "\t\tself.x = tf.placeholder(shape=[input_dim], dtype=dtype, name='input')\n",
    "\t\t#iteration number\n",
    "\t\tself.n = tf.placeholder(dtype=dtype, name='iteration')\n",
    "\t\t#variables\n",
    "\t\tself.w = tf.Variable(tf.random_uniform([dim*dim, input_dim], minval=-1, maxval=1, dtype=dtype),\n",
    "\t\t\tdtype=dtype, name='weights')\n",
    "\t\t#helper\n",
    "\t\tself.positions = tf.where(tf.fill([dim, dim], True))\n",
    "\n",
    "\n",
    "\n",
    "\tdef training_op(self):\n",
    "\t\twin_index = self.__competition('train_')\n",
    "\t\twith tf.name_scope('cooperation') as scope:\n",
    "\t\t\tcoop_dist = tf.sqrt(tf.reduce_sum(tf.square(tf.cast(self.positions -\n",
    "\t\t\t\t[win_index//self.dim, win_index-win_index//self.dim*self.dim], \n",
    "\t\t\t\tdtype=self.dtype)), axis=1))\n",
    "\t\t\tsigma = tf.cond(self.n > 1000, lambda: self.minsigma, lambda: self.sigma * tf.exp(-self.n/self.tay1))\n",
    "\t\t\tsigma_summary = tf.summary.scalar('Sigma', sigma)\n",
    "\t\t\ttnh = tf.exp(-tf.square(coop_dist) / (2 * tf.square(sigma))) # topological neighbourhood\n",
    "\t\twith tf.name_scope('adaptation') as scope:\n",
    "\t\t\tlr = self.learning_rate * tf.exp(-self.n/self.tay2)\n",
    "\t\t\tminlr = tf.constant(0.01, dtype=self.dtype, name='min_learning_rate')\n",
    "\t\t\tlr = tf.cond(lr <= minlr, lambda: minlr, lambda: lr)\n",
    "\t\t\tlr_summary = tf.summary.scalar('Learning rate', lr)\n",
    "\t\t\tdelta = tf.transpose(lr * tnh * tf.transpose(self.x - self.w))\n",
    "\t\t\ttraining_op = tf.assign(self.w, self.w + delta)\n",
    "\t\treturn training_op, lr_summary, sigma_summary\n",
    "\n",
    "\tdef __competition(self, info=''):\n",
    "\t\twith tf.name_scope(info+'competition') as scope:\n",
    "\t\t\tdistance = tf.sqrt(tf.reduce_sum(tf.square(self.x - self.w), axis=1))\n",
    "\t\treturn tf.argmin(distance, axis=0)\n",
    "\n",
    "#== Test SOM Network ==\n",
    "\n",
    "def test_som_with_color_data():\n",
    "\tsom_dim = 100\n",
    "\tsom = SOMNetwork(input_dim=3, dim=som_dim, dtype=tf.float64, sigma=3)\n",
    "\ttest_data = np.random.uniform(0, 1, (20000, 3))\n",
    "\ttraining_op, lr_summary, sigma_summary = som.training_op()\n",
    "\tinit = tf.global_variables_initializer()\n",
    "\twriter = tf.summary.FileWriter('./logs/', tf.get_default_graph())\n",
    "\twith tf.Session() as sess:\n",
    "\t\tinit.run()\n",
    "\t\timg1 = tf.reshape(som.w, [som_dim,som_dim,-1]).eval()\n",
    "\t\tplt.figure(1)\n",
    "\t\tplt.subplot(121)\n",
    "\t\tplt.imshow(img1)\n",
    "\t\tstart = time.time()\n",
    "\t\tfor i, color_data in enumerate(test_data):\n",
    "\t\t\tif i % 1000 == 0:\n",
    "\t\t\t\tprint('iter:', i)\n",
    "\t\t\tsess.run(training_op, feed_dict={som.x: color_data, som.n:i})\n",
    "\t\tend = time.time()\n",
    "\t\tprint(end - start)\n",
    "\t\timg2 = tf.reshape(som.w, [som_dim,som_dim,-1]).eval()\n",
    "\t\tplt.subplot(122)\n",
    "\t\tplt.imshow(img2)\n",
    "\twriter.close()\n",
    "\tplt.show()\t\t\n",
    "\n",
    "test_som_with_color_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Get_Distances(y,x):\n",
    "    def ring_closure(A):\n",
    "        if A==1: return [0]\n",
    "        a=np.arange(A)\n",
    "        max_val = int(len(a)/2)\n",
    "        max_ind=np.argwhere(a==max_val)[0,0]\n",
    "        if len(a)%2==0:\n",
    "            b=np.arange(1,a[max_ind])[::-1]\n",
    "        else:\n",
    "            b=np.arange(1,a[max_ind+1])[::-1]\n",
    "        a[max_ind+1:]=b\n",
    "        return a\n",
    "    yv=ring_closure(y)\n",
    "    xv=ring_closure(x)\n",
    "    XV, YV = np.meshgrid(xv, yv)\n",
    "    #res = np.stack((YV,XV), axis=-1)\n",
    "    res = np.sqrt(XV**2+YV**2)\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.ones((x*y,5))*np.array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 2]\n",
      "[0.666743  0.77672   0.9048374 0.77672   0.666743 ]\n",
      "[[ 1.333486  1.333486  1.333486  1.333486  1.333486]\n",
      " [ 0.77672   0.77672   0.77672   0.77672   0.77672 ]\n",
      " [ 0.        0.        0.        0.        0.      ]\n",
      " [-0.77672  -0.77672  -0.77672  -0.77672  -0.77672 ]\n",
      " [-1.333486 -1.333486 -1.333486 -1.333486 -1.333486]]\n"
     ]
    }
   ],
   "source": [
    "x=5\n",
    "y=1\n",
    "def _generate_index_matrix(x, y):\n",
    "        return tf.constant(np.array(list(_iterator(x, y))))\n",
    "    \n",
    "def _iterator(x, y):\n",
    "    for i in range(x):\n",
    "        for j in range(y):\n",
    "            yield np.array([i, j])\n",
    "\n",
    "\n",
    "            \n",
    "_distance_map = tf.constant(Get_Distances(y,x),dtype='float32')\n",
    "_locations = _generate_index_matrix(y, x)\n",
    "\n",
    "# Build a dataflow graph.\n",
    "_weights  = tf.Variable(a.T,dtype='float32')\n",
    "_input = 3*tf.constant([1, 1, 1, 1, 1],dtype='float32')\n",
    "input_matix = tf.stack([_input for i in range(x*y)])\n",
    "distances = tf.sqrt(tf.reduce_sum((_weights-_input)**2, -1))\n",
    "bmu = tf.argmin(distances, 0)\n",
    "bmu_location = _locations[bmu]\n",
    "_current_learning_rate = tf.maximum(1*tf.exp(-100/1000), 0.1)\n",
    "_current_radius = 2*tf.exp(-100/1000)\n",
    "\n",
    "bmu_distance = tf.reshape(tf.roll(_distance_map,shift=bmu_location, axis=[0, 1]),[-1])\n",
    "neighbourhood_func = tf.exp(-bmu_distance/(2*_current_radius**2))\n",
    "learning_rate_matrix = tf.multiply(_current_learning_rate, neighbourhood_func)\n",
    " \n",
    "#Update all the weights\n",
    "multiplytiplier = tf.stack([tf.tile(tf.slice(learning_rate_matrix, np.array([i]), np.array([1])), [5])\n",
    "                                               for i in range(x*y)])\n",
    "\n",
    "delta = tf.transpose(tf.transpose(_input-_weights)*learning_rate_matrix)\n",
    "\n",
    "# Construct a `Session` to execute the graph.\n",
    "#sess = tf.Session()\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    #print(sess.run(distances))\n",
    "    #print(sess.run(_locations))\n",
    "    #print(sess.run(bmu))\n",
    "    print(sess.run(bmu_location))\n",
    "    #print(sess.run(_distance_map))\n",
    "    ##print(sess.run(bmu_distance))\n",
    "    #print(sess.run(neighbourhood_func))\n",
    "    print(sess.run(learning_rate_matrix))\n",
    "    #print(sess.run(multiplytiplier))\n",
    "    print(sess.run(delta))\n",
    "\n",
    "\n",
    "# Execute the graph and store the value that `e` represents in `result`.\n",
    "#result = sess.run(bmu_location)\n",
    "#print(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.147895574569702\n"
     ]
    }
   ],
   "source": [
    "time_start = time()\n",
    "\n",
    "x = tf.constant(1.0, name='input')\n",
    "w = tf.Variable(0.8, name='weight')\n",
    "y = tf.multiply(w, x, name='output')\n",
    "y_ = tf.constant(0.0, name='correct_value')\n",
    "loss = tf.pow(y - y_, 2, name='loss')\n",
    "z = tf.add(y,2, name='JEJE')\n",
    "train_step = tf.train.GradientDescentOptimizer(0.025).minimize(loss)\n",
    "\n",
    "for value in [z,x, w, y, y_, loss]:\n",
    "    tf.summary.scalar(value.op.name, value)\n",
    "\n",
    "summaries = tf.summary.merge_all()\n",
    "\n",
    "sess = tf.Session()\n",
    "summary_writer = tf.summary.FileWriter('log_simple_stats', sess.graph)\n",
    "\n",
    "sess.run(tf.global_variables_initializer())\n",
    "for i in range(100):\n",
    "    summary_writer.add_summary(sess.run(summaries), i)\n",
    "    #print('before step {}, y is {}'.format(i, sess.run(y)))\n",
    "    #sess.run(y)\n",
    "    sess.run(train_step)\n",
    "\n",
    "print(time()-time_start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "from mayavi.mlab import *\n",
    "\n",
    "def test_points3d():\n",
    "    x = DATA[:,0]\n",
    "    y = DATA[:,1]\n",
    "    z = DATA[:,2]\n",
    "\n",
    "    return points3d(x, y, z, colormap=\"copper\", scale_factor=.25)\n",
    "\n",
    "test_points3d()\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}