sandstone.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import signal\n",
    "from mpl_toolkits.mplot3d import Axes3D  \n",
    "import scipy.misc\n",
    "import scipy.io\n",
    "from torch.optim import Adam, LBFGS\n",
    "from scipy.stats import bernoulli, norm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.is_available()\n",
    "device = torch.device(\"cuda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_all_triangle(a):\n",
    "    max_len = a / 2\n",
    "    center_x = int(a//2)\n",
    "    center_y = int(a//2)\n",
    "    res = []\n",
    "    dic = []\n",
    "    for l1 in range(0, a):\n",
    "        for l2 in range(0, a):\n",
    "            for l3 in range(0, a):\n",
    "                for l4 in range(0, a):\n",
    "                    if ([l1, l2, l3, l4] not in dic) and ([l3, l4, l1, l2] not in dic):\n",
    "                        dic.append([l1, l2, l3, l4])\n",
    "                        img = np.zeros([a, a])\n",
    "                        img[center_y, center_x] = 1\n",
    "                        img[l1, l2] += 1\n",
    "                        img[l3, l4] += 1\n",
    "                        res.append(img)\n",
    "                    \n",
    "    return np.array(res)\n",
    "\n",
    "def all_all_shuffle_triangle(a):\n",
    "    max_len = a / 2\n",
    "    center_x = int(a//2)\n",
    "    center_y = int(a//2)\n",
    "    res = []\n",
    "    dic = []\n",
    "    for l in range(a-center_x):\n",
    "        for l1 in range(-l, l+1):\n",
    "            for l2 in range(-l, l+1):\n",
    "                for l3 in range(-l, l+1):\n",
    "                    for l4 in range(-l, l+1):\n",
    "                        if ([l1, l2, l3, l4] not in dic) and ([l3, l4, l1, l2] not in dic):\n",
    "                            dic.append([l1, l2, l3, l4])\n",
    "                            img = np.zeros([a, a])\n",
    "                            img[center_x, center_y] = 1\n",
    "                            img[int(center_x+l1), int(center_y+l2)] += 1\n",
    "                            img[int(center_x+l3), int(center_y+l4)] += 1\n",
    "                            res.append(img)\n",
    "    return np.array(res)\n",
    "\n",
    "def all_all_shuffle_triangle_v2(a):\n",
    "    max_len = a / 2\n",
    "    center_x = int(a//2)\n",
    "    center_y = int(a//2)\n",
    "    res = []\n",
    "    dic = []\n",
    "    for l in range(a-center_x):\n",
    "        for l1 in range(-l, l+1):\n",
    "            for l2 in range(-l, l+1):\n",
    "                for l3 in range(-l, l+1):\n",
    "                    for l4 in range(-l, l+1):\n",
    "                        if ([l1, l2, l3, l4] not in dic) and ([l3, l4, l1, l2] not in dic):\n",
    "                            dic.append([l1, l2, l3, l4])\n",
    "    dic = np.array(dic)\n",
    "    for i in range(len(dic)):\n",
    "        l1, l2, l3, l4 = dic[i]\n",
    "        img = np.zeros([a, a])\n",
    "        img[center_x, center_y] = 1\n",
    "        img[int(center_x+l1), int(center_y+l2)] += 1\n",
    "        img[int(center_x+l3), int(center_y+l4)] += 1\n",
    "    return np.array(res)\n",
    "                    \n",
    "                    \n",
    "\n",
    "def stretch_triangle(a, b):\n",
    "    max_len = a.shape[0]\n",
    "    max_len = max_len * b\n",
    "    res = np.zeros([max_len, max_len])\n",
    "    index = np.where(a != 0)\n",
    "    for i in range(len(index[0])):\n",
    "        x1 = index[0][i]\n",
    "        x2 = index[1][i]\n",
    "        v = a[x1, x2]\n",
    "        x1 = x1 * b + b / 2\n",
    "        x2 = x2 * b + b / 2\n",
    "        x1 = int(x1)\n",
    "        x2 = int(x2)\n",
    "        res[x1, x2] = v\n",
    "    return res\n",
    "\n",
    "def stretch_odd_triangle(a, b):\n",
    "    max_len = a.shape[0]\n",
    "    assert(max_len % 2 == 1)\n",
    "    max_len = int((max_len-1) * b  + 1)\n",
    "    res = np.zeros([max_len, max_len])\n",
    "    index = np.where(a != 0)\n",
    "    for i in range(len(index[0])):\n",
    "        x1 = index[0][i]\n",
    "        x2 = index[1][i]\n",
    "        v = a[x1, x2]\n",
    "        x1 = x1 * b\n",
    "        x2 = x2 * b\n",
    "        x1 = int(x1)\n",
    "        x2 = int(x2)\n",
    "        res[x1, x2] = v\n",
    "    return res\n",
    "\n",
    "def resize_triangle(a, b):\n",
    "    current_size = a.shape[0]\n",
    "    center_point = int(current_size / 2)\n",
    "    ind = np.array(np.where(a != 0))\n",
    "#     assert any(center_point in ind)\n",
    "    res = np.zeros([b, b])\n",
    "    center_v = a[center_point, center_point]\n",
    "    new_center = b / 2\n",
    "    res[int(new_center), int(new_center)] = center_v\n",
    "    for i in range(len(ind[0])):\n",
    "        if not (ind[0, i] == center_point and ind[1, i] == center_point):\n",
    "            v = a[int(ind[0, i]), int(ind[1, i])]\n",
    "            x = new_center + int(ind[0, i] - current_size / 2)\n",
    "            y = new_center + int(ind[1, i] - current_size / 2)\n",
    "            res[int(x), int(y)] = v\n",
    "    return res\n",
    "\n",
    "def resize_odd_triangle(a, b):\n",
    "    current_size = a.shape[0]\n",
    "    old_center = (current_size-1)/2\n",
    "    assert(current_size % 2 == 1)\n",
    "    assert(b%2==1)\n",
    "    ind = np.array(np.where(a != 0))\n",
    "#     assert any(center_point in ind)\n",
    "    res = np.zeros([b, b])\n",
    "    center_v = a[int(old_center), int(old_center)]\n",
    "    new_center = (b-1)/2\n",
    "    res[int(new_center), int(new_center)] = center_v\n",
    "    for i in range(len(ind[0])):\n",
    "        if not (ind[0, i] == old_center and ind[1, i] == old_center):\n",
    "            v = a[int(ind[0, i]), int(ind[1, i])]\n",
    "            x = new_center + int(ind[0, i] - old_center)\n",
    "            y = new_center + int(ind[1, i] - old_center)\n",
    "            res[int(x), int(y)] = v\n",
    "    return res\n",
    "    \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gkern(kernlen=21, std=3):\n",
    "    \"\"\"Returns a 2D Gaussian kernel array.\"\"\"\n",
    "    gkern1d = signal.gaussian(kernlen, std=std).reshape(kernlen, 1)\n",
    "    gkern2d = np.outer(gkern1d, gkern1d)\n",
    "    gkern2d /= (2*np.pi*(std**2))\n",
    "    return gkern2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def resize_odd_triangle_index(a, b, index):\n",
    "    current_size = a\n",
    "    old_center = (current_size-1)/2\n",
    "    res = np.zeros([b, b])\n",
    "    new_center = (b-1)/2\n",
    "    l1, l2, l3, l4 = index\n",
    "    res[int(new_center), int(new_center)] = 1\n",
    "    x1 = new_center - (l1 - old_center)\n",
    "    y1 = new_center - (l2 - old_center)\n",
    "    x2 = new_center - (l3 - old_center)\n",
    "    y2 = new_center - (l4 - old_center)\n",
    "    res[int(x1), int(y1)] += 1\n",
    "    res[int(x2), int(y2)] += 1\n",
    "    return res\n",
    "\n",
    "def stretch_odd_triangle_index(a, b, index):\n",
    "    current_size = a\n",
    "    old_center = (current_size-1)/2\n",
    "    assert(current_size % 2 == 1)\n",
    "    new_size = int((current_size-1) * b  + 1)\n",
    "    new_center = old_center*b\n",
    "    res = np.zeros([new_size, new_size])\n",
    "    res[int(new_center), int(new_center)] = 1\n",
    "    res[int(index[0]*b+new_center), int(index[1]*b+new_center)] += 1\n",
    "    res[int(index[2]*b+new_center), int(index[3]*b+new_center)] += 1\n",
    "    return res\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index_40 = np.load('20_index.npy')\n",
    "index_40[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7381"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bound_len = np.max(np.abs(index_40), 1)\n",
    "bound = 5\n",
    "bound_index = np.where(bound_len <= bound)[0]\n",
    "len(bound_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "w_all_test = [stretch_odd_triangle_index(21, 2, i) for i in index_40[bound_index]]\n",
    "w_all_test = np.array(w_all_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(7381, 41, 41)\n"
     ]
    }
   ],
   "source": [
    "print(w_all_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(45, 41, 41)\n"
     ]
    }
   ],
   "source": [
    "w_all_test1 = all_all_shuffle_triangle(3)\n",
    "w_all_test1 = [stretch_odd_triangle(w_, 2) for w_ in w_all_test1]\n",
    "w_all_test1 = [resize_odd_triangle(w_, 41) for w_ in w_all_test1]\n",
    "# w_all_test = all_all_triangle(20)\n",
    "w_all_test1 = np.array(w_all_test1)\n",
    "print(w_all_test1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(41, 41)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAC7klEQVR4nO3aQW7DMAwAwbLI/7/MPKBOkEvgrTBzlHXQZUGA8OzuD9Dze/cDgGvihChxQpQ4IUqcEPV493FmrHLhy3Z3rs5NTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCHqcfcDeG13/5zNzEf3Xt3l/zA5IUqcECVOiBInRFkIhX260LH4OZPJCVHihChxQpQ4IcpC6AD+EDqTyQlR4oQocUKUOCFKnBBlW3sAW9kzmZwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBA1u3v3G4ALJidEiROixAlR4oQocUKUOCHqCTL0FNoQ5ieFAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "w1 = w_all_test[2,:,:]\n",
    "plt.imshow(w1, cmap='gray')\n",
    "plt.axis(\"off\")\n",
    "print(w1.shape)\n",
    "# plt.imshow(w_all[100], cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(128, 128)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(-0.5, 127.5, 127.5, -0.5)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "a1 = scipy.io.loadmat('sandstone_data.mat')\n",
    "a1 = a1['Data']\n",
    "a1 = a1[0,:].reshape([128, 128])\n",
    "size = a1.shape\n",
    "print(size)\n",
    "plt.imshow(a1, cmap='gray')\n",
    "plt.axis('off')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "index = np.random.permutation(np.arange(len(w_all_test)))[:738]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.05854983, 0.09653235, 0.05854983],\n",
       "       [0.09653235, 0.15915494, 0.09653235],\n",
       "       [0.05854983, 0.09653235, 0.05854983]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weight_filter = gkern(3, 1)\n",
    "weight_filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "d1 = w_all_test[index]\n",
    "d2 = d1[:,np.newaxis,:,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "with torch.no_grad():\n",
    "    aa = np.rot90(np.rot90(a1)).copy()\n",
    "    inputs = torch.from_numpy(aa.reshape([1, 1, size[0], size[1]]))\n",
    "    # inputs = torch.from_numpy(a.reshape([1, 1, size[0], size[1]]))\n",
    "    inputs = inputs.type(torch.FloatTensor)\n",
    "    inputs = Variable(inputs)\n",
    "    inputs_inv = torch.ones(inputs.size()) - inputs\n",
    "    inputs = inputs.to(device)\n",
    "    inputs_inv = inputs_inv.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 1, 128, 128])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputs.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([738, 1, 168, 168])\n",
      "tensor([0.0050, 0.0105, 0.0067, 0.0162, 0.0021, 0.0067, 0.0162, 0.0016, 0.0127,\n",
      "        0.0251, 0.0054, 0.0229, 0.0202, 0.0077, 0.0177, 0.0344, 0.0080, 0.0070,\n",
      "        0.0237, 0.0105], device='cuda:0')\n",
      "torch.Size([738])\n"
     ]
    }
   ],
   "source": [
    "# %% convert to pytorch code\n",
    "with torch.no_grad():\n",
    "    weights = torch.from_numpy(d2.reshape([d2.shape[0],1,d2.shape[2], d2.shape[3]]))\n",
    "    weights = weights.type(torch.FloatTensor)\n",
    "    weights = Variable(weights)\n",
    "    weights = weights.to(device)\n",
    "    bias = Variable(torch.Tensor([-2.0]))\n",
    "    bias = bias.to(device)\n",
    "    outputs = F.conv_transpose2d(weights, inputs, bias, padding=0)\n",
    "    outputs = F.relu(outputs)\n",
    "    print(outputs.size())\n",
    "    outputs = torch.mean(outputs, dim=(1,2,3))\n",
    "    # outputs = F.conv2d(inputs, weights, b+ias, padding=5)\n",
    "    print(outputs[:20])\n",
    "    outputs_inv = F.conv_transpose2d(weights, inputs_inv, bias, padding=0)\n",
    "    outputs_inv = F.relu(outputs_inv)\n",
    "    outputs_inv = torch.mean(outputs_inv, dim=(1,2,3))\n",
    "    print(outputs_inv.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([45, 1, 168, 168])\n",
      "tensor([0.1149, 0.0793, 0.0723, 0.0584, 0.0731, 0.0793, 0.0605, 0.0617, 0.0620,\n",
      "        0.0528, 0.0899, 0.0736, 0.0716, 0.0899, 0.0731, 0.0630, 0.0697, 0.0626,\n",
      "        0.0792, 0.0589, 0.0792, 0.0716, 0.0530, 0.0624, 0.0591, 0.0876, 0.0876,\n",
      "        0.0646, 0.0736, 0.0723, 0.0599, 0.0876, 0.0792, 0.0899, 0.0793, 0.0876,\n",
      "        0.0590, 0.0736, 0.0723, 0.0792, 0.0716, 0.0570, 0.0899, 0.0731, 0.0793],\n",
      "       device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "# %% convert to pytorch code\n",
    "# index = [0,1,2]\n",
    "with torch.no_grad():\n",
    "    d3 = w_all_test1[:, np.newaxis, :,:]\n",
    "    weights_test = torch.from_numpy(d3.reshape([d3.shape[0],1,d3.shape[2], d3.shape[3]]))\n",
    "    weights_test = weights_test.type(torch.FloatTensor)\n",
    "    weights_test = Variable(weights_test)\n",
    "    weights_test = weights_test.to(device)\n",
    "    bias = Variable(torch.Tensor([-2.0]))\n",
    "    bias = bias.to(device)\n",
    "    outputs_test = F.conv_transpose2d(weights_test, inputs, bias, padding=0)\n",
    "    outputs_test = F.relu(outputs_test)\n",
    "    print(outputs_test.size())\n",
    "    outputs_test = torch.mean(outputs_test, dim=(1,2,3))\n",
    "    print(outputs_test[:50])\n",
    "    # outputs = F.conv2d(inputs, weights, b+ias, padding=5)\n",
    "    # print(outputs.size())\n",
    "    outputs_inv_test = F.conv_transpose2d(weights_test, inputs_inv, bias, padding=0)\n",
    "    outputs_inv_test = F.relu(outputs_inv_test)\n",
    "    outputs_inv_test = torch.mean(outputs_inv_test, dim=(1,2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.11486677825450897\n",
      "(128, 128)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "p = outputs_test[0].item()\n",
    "# p = outputs[312].item()\n",
    "print(p)\n",
    "I1 = bernoulli.rvs(p, size=[size[0], size[1]])\n",
    "plt.axis(\"off\")\n",
    "print(I1.shape)\n",
    "plt.imshow(I1, cmap='gray')\n",
    "I1 = I1.astype(np.float32)\n",
    "I1 = I1.reshape([1, 1, size[0], size[1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 0, loss: 3.98737e-04\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 100, loss: 1.93451e-05\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 200, loss: 1.52002e-05\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 300, loss: 1.23323e-05\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 400, loss: 8.02133e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 500, loss: 5.63105e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 600, loss: 4.80516e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 700, loss: 3.95323e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 800, loss: 3.70851e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 900, loss: 3.57223e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 1000, loss: 3.27929e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 2000, loss: 2.32140e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 3000, loss: 2.11632e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 7, iteration: 4000, loss: 1.84993e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 9, iteration: 0, loss: 1.76020e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 9, iteration: 1000, loss: 1.74612e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 9, iteration: 2000, loss: 1.74085e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta: 9, iteration: 3000, loss: 1.72622e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "weights.requires_grad = False\n",
    "bias.requires_grad = False\n",
    "outputs.requires_grad = False\n",
    "outputs_inv.requires_grad = False\n",
    "outputs = outputs.to(device)\n",
    "outputs_inv = outputs_inv.to(device)\n",
    "I = torch.tensor(I1, device=device)\n",
    "I = Variable(I, requires_grad=True)\n",
    "ones = Variable(torch.ones([1, 1, size[0], size[1]]), requires_grad=False)\n",
    "ones = ones.to(device)\n",
    "zeros = Variable(torch.zeros([1, 1, size[0], size[1]]), requires_grad=False)\n",
    "init_I = I.detach().data\n",
    "weight_filters = Variable(torch.from_numpy(weight_filter.reshape([1,1,3,3])).float(), requires_grad=False)\n",
    "\n",
    "# I = I.to(device)\n",
    "I.requires_grad = True\n",
    "weight_filters = weight_filters.to(device)\n",
    "for beta in [7, 9, 11, 17]:\n",
    "    if beta < 11:\n",
    "        iters = 5000\n",
    "    elif beta < 15:\n",
    "        iters = 4000\n",
    "    else:\n",
    "        iters = 2000\n",
    "    for i in range(iters):\n",
    "        \n",
    "        \n",
    "        cons_i = F.tanh(torch.tensor(beta/2))\n",
    "        I_ = (cons_i + F.tanh(beta*I - beta/2)) / (2 * cons_i)\n",
    "        out = F.conv_transpose2d(weights, I_, bias, padding=0, stride=1)\n",
    "        out = F.relu(out)\n",
    "        out = torch.mean(out, dim=(1,2,3))\n",
    "        loss = ((out-outputs)**2).mean()\n",
    "\n",
    "        \n",
    "        with torch.no_grad():\n",
    "            if beta == 7 and i % 100 == 0 and i <= 1000:\n",
    "                print(\"Beta: {}, iteration: {}, loss: {:.5e}\".format(beta, i, loss.item()))\n",
    "                plt.imshow(I_.data.cpu().numpy()[0,0,:,:], cmap='gray')\n",
    "                plt.axis(\"off\")\n",
    "                plt.show()\n",
    "            elif i % 1000 == 0:\n",
    "                print(\"Beta: {}, iteration: {}, loss: {:.5e}\".format(beta, i, loss.item()))\n",
    "                plt.imshow(I_.data.cpu().numpy()[0,0,:,:], cmap='gray')\n",
    "                plt.axis(\"off\")\n",
    "                plt.show()\n",
    "     \n",
    "        grads = torch.autograd.grad(loss, I)\n",
    "        with torch.no_grad():\n",
    "            if I.grad is None:\n",
    "                I.grad = grads[0].detach()\n",
    "            else:\n",
    "                I.grad.fill_(grads[0].detach())\n",
    "\n",
    "            I.grad = F.conv2d(I.grad, weight_filters, padding=1, stride=1)\n",
    "\n",
    "\n",
    "        if beta < 9:\n",
    "            if i < 5:\n",
    "                I = I - 20000000 * I.grad\n",
    "            elif i < 500:\n",
    "                I = I - 20000000 * I.grad\n",
    "            elif i < 2000:\n",
    "                I = I - 20000000 * I.grad\n",
    "            elif i < 10000:\n",
    "                I = I - 10000000 * I.grad\n",
    "            elif i < 20000:\n",
    "                I = I - 5000000 * I.grad\n",
    "            else:\n",
    "                I = I - 1000000 * I.grad\n",
    "        else:\n",
    "            if i < 2000:\n",
    "                I = I - 10000000 * I.grad\n",
    "            else:\n",
    "                I = I - 5000000 * I.grad                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch-gpu",
   "language": "python",
   "name": "pytorch-gpu"
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}