{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-05T12:20:08.818657Z",
     "start_time": "2018-10-05T12:20:08.561719Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n",
      "Dataset has been loaded\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "from sklearn.model_selection import train_test_split\n",
    "#import jtplot submodule from jupyterthemes\n",
    "from jupyterthemes import jtplot\n",
    "#currently installed theme will be used to\n",
    "#set plot style if no arguments provided\n",
    "jtplot.style()\n",
    "\n",
    "#now load this dataset \n",
    "h5f = h5py.File('./datasets/s8_sio2tio2_v2.h5','r')\n",
    "X = h5f['sizes'][:]\n",
    "Y = h5f['spectrum'][:]\n",
    "\n",
    "#create a train - test split of the dataset\n",
    "x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.4, random_state=42)\n",
    "# normalize inputs \n",
    "#x_test = (x_test - 50)/20 \n",
    "\n",
    "print(\"Dataset has been loaded\")\n",
    "\n",
    "import numpy as np\n",
    "import mxnet as mx\n",
    "\n",
    "# Step1: Load the model in MXNet\n",
    "\n",
    "# Use the same prefix and epoch parameters we used in save_mxnet_model API.\n",
    "sym, arg_params, aux_params = mx.model.load_checkpoint(prefix='my_mod_bet', epoch=0)\n",
    "\n",
    "# We use the data_names and data_shapes returned by save_mxnet_model API.\n",
    "mod = mx.mod.Module(symbol=sym, \n",
    "                    data_names=['/input_21'], \n",
    "                    context=mx.gpu(), \n",
    "                    label_names=None)\n",
    "mod.bind(for_training=False, \n",
    "         data_shapes=[('/input_21', (1,8))], \n",
    "         label_shapes=mod._label_shapes)\n",
    "mod.set_params(arg_params, aux_params, allow_missing=True)    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-05T13:31:25.375799Z",
     "start_time": "2018-10-05T13:31:25.342858Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def de(fobj, bounds, mut=0.8, crossp=0.7, popsize=20, its=1000):\n",
    "    dimensions = len(bounds)\n",
    "    pop = np.random.rand(popsize, dimensions)\n",
    "    min_b, max_b = np.asarray(bounds).T\n",
    "    diff = np.fabs(min_b - max_b)\n",
    "    pop_denorm = min_b + pop * diff\n",
    "    fitness = np.asarray([fobj(ind) for ind in pop_denorm])\n",
    "    best_idx = np.argmin(fitness)\n",
    "    best = pop_denorm[best_idx]\n",
    "    for i in range(its):\n",
    "        #trialarr = np.zeros(popsize)\n",
    "        for j in range(popsize):\n",
    "            idxs = [idx for idx in range(popsize) if idx != j]\n",
    "            a, b, c = pop[np.random.choice(idxs, 3, replace = False)]\n",
    "            #mutant = np.clip(a + mut * (b - c), 0, 1)\n",
    "            mutant = np.clip(pop[best_idx] + mut * (b - c), 0, 1)\n",
    "            cross_points = np.random.rand(dimensions) < crossp\n",
    "            if not np.any(cross_points):\n",
    "                cross_points[np.random.randint(0, dimensions)] = True\n",
    "            trial = np.where(cross_points, mutant, pop[j])\n",
    "            #trialarr[j] = np.where(cross_points, mutant, pop[j])\n",
    "            trial_denorm = min_b + trial * diff\n",
    "            f = fobj(trial_denorm)\n",
    "            if f < fitness[j]:\n",
    "                fitness[j] = f\n",
    "                pop[j] = trial\n",
    "                if f < fitness[best_idx]:\n",
    "                    best_idx = j\n",
    "                    best = trial_denorm\n",
    "        if i%25 == 0:\n",
    "            print(i, fitness[best_idx])\n",
    "    return best, fitness[best_idx]\n",
    "\n",
    "\n",
    "def de2(fobj, bounds, mut=0.8, crossp=0.7, popsize=20, its=1000):\n",
    "    dimensions = len(bounds)\n",
    "    pop = np.random.rand(popsize, dimensions)\n",
    "    min_b, max_b = np.asarray(bounds).T\n",
    "    diff = np.fabs(min_b - max_b)\n",
    "    pop_denorm = min_b + pop * diff\n",
    "    fitness = np.asarray(fobj(pop_denorm))\n",
    "    best_idx = np.argmin(fitness)\n",
    "    best = pop_denorm[best_idx]\n",
    "    for i in range(its):\n",
    "        trialarr = np.zeros((popsize, dimensions))\n",
    "        for j in range(popsize):\n",
    "            idxs = [idx for idx in range(popsize) if idx != j]\n",
    "            a, b, c = pop[np.random.choice(idxs, 3, replace = False)]\n",
    "            #mutant = np.clip(a + mut * (b - c), 0, 1)\n",
    "            mutant = np.clip(pop[best_idx] + mut * (b - c), 0, 1)\n",
    "            cross_points = np.random.rand(dimensions) < crossp\n",
    "            if not np.any(cross_points):\n",
    "                cross_points[np.random.randint(0, dimensions)] = True\n",
    "            trialarr[j] = np.where(cross_points, mutant, pop[j])\n",
    "            \n",
    "        \n",
    "        trial_denorm = min_b + trialarr * diff\n",
    "        #print(trial_denorm)\n",
    "        f = fobj(trial_denorm)\n",
    "        for j in range(popsize):\n",
    "            if f[j] < fitness[j]:\n",
    "                fitness[j] = f[j]\n",
    "                pop[j] = trialarr[j]\n",
    "                if f[j] < fitness[best_idx]:\n",
    "                    best_idx = j\n",
    "                    best = trial_denorm[j]\n",
    "        if i%25 == 0:\n",
    "            print(i, fitness[best_idx])\n",
    "    return best, fitness[best_idx]\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2018-10-05T13:30:27.166Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1.9676681607961655\n",
      "25 0.7767577655613422\n",
      "50 0.7767577655613422\n",
      "75 0.7767577655613422\n",
      "100 0.7324242033064365\n"
     ]
    }
   ],
   "source": [
    "\n",
    "import numpy as np\n",
    "from scipy.optimize import rosen, differential_evolution\n",
    "import scnets as scn\n",
    "import mxnet as mx\n",
    "from mxnet import nd\n",
    "import snlay as snlay\n",
    "\n",
    "mats = np.array([3, 4, 3, 4, 3, 4, 3, 4])\n",
    "lams = np.linspace(300, 1200, 256)\n",
    "targ_spec = y_test[29]\n",
    "targ_spec2 = np.tile(targ_spec, (80,1))\n",
    "\n",
    "# def loss_jumper(x, it_cnt=0):\n",
    "\n",
    "def mxmod_arr_loss(x):\n",
    "    x_np = np.array(x)\n",
    "    x_np = (x_np - 50.0)/20.0\n",
    "    res2 = mod.predict(x_np)\n",
    "    y_t = nd.array(targ_spec2, ctx=mx.gpu())\n",
    "    err = nd.abs(y_t - res2)/y_t\n",
    "    err2 = 100*nd.mean(err, axis=1).asnumpy()\n",
    "    return err2\n",
    "\n",
    "def mxmod_loss(x):\n",
    "    x_np = np.array(x)\n",
    "    x_np = (x_np - 50.0)/20.0\n",
    "    x_np = np.expand_dims(x_np, axis=0)\n",
    "    res2 = mod.predict(x_np)\n",
    "    y_t = nd.array(targ_spec, ctx=mx.gpu())\n",
    "    err = nd.abs(y_t - res2)/y_t\n",
    "    err2 = 100*nd.mean(err).asscalar()\n",
    "    return err2\n",
    "\n",
    "#     res2 = mod.predict(x)\n",
    "\n",
    "#     \n",
    "#     #ez2 = err2.copyto(mx.cpu())\n",
    "#     return err2\n",
    "\n",
    "def loss_func(x):\n",
    "    #x_np = np.array(x)\n",
    "    #count+=1\n",
    "    spec_ac = snlay.calc_spectrum(x, mats, lams)\n",
    "    diff = np.abs(targ_spec - spec_ac)/targ_spec\n",
    "    return 100*np.mean(diff)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# x_t = np.array([40, 45, 40, 45, 40, 45, 40, 50])\n",
    "# sd = mxmod_loss(x_t)\n",
    "# sd2 = loss_func(x_t)\n",
    "# print(sd, sd2)\n",
    "bnds = [(30, 70)]*8\n",
    "#b, c = de(fobj=loss_func, bounds=bnds, popsize=80, its=2500)\n",
    "b, c = de(fobj=mxmod_loss, bounds=bnds, popsize=80, its=2500)\n",
    "#b, c = de2(fobj=mxmod_arr_loss, bounds=bnds, popsize=80, its=2500)                 \n",
    "#it = list(de(lambda x: x**2, bounds=[(-100, 100)]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-05T13:09:02.641621Z",
     "start_time": "2018-10-05T13:09:02.616461Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(80, 256)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "targ_spec.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-05T12:35:59.739963Z",
     "start_time": "2018-10-05T12:35:59.714914Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30., 64., 52., 36., 36., 64., 35., 62.])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_test[29]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-05T13:04:11.358640Z",
     "start_time": "2018-10-05T13:04:11.334873Z"
    }
   },
   "outputs": [],
   "source": [
    "a = np.array([0, 1, 2])\n",
    "b = np.tile(a, (3,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-05T13:04:13.495202Z",
     "start_time": "2018-10-05T13:04:13.469641Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.shape"
   ]
  },
  {
   "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}