Tarea2_1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.misc\n",
    "import scipy.signal\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "from PIL import ImageFilter\n",
    "from PIL import ImageChops\n",
    "from PIL import ImageStat\n",
    "from scipy.ndimage.filters import gaussian_filter\n",
    "\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Gaussian_Window(sigma,x_pos = 32, y_pos = 32):\n",
    "    D = np.zeros([64,64])\n",
    "    for i in range(0,64):\n",
    "        for j in range(0,64):\n",
    "            x = i - x_pos\n",
    "            y = j - y_pos\n",
    "            r = (1/(2*np.pi*(sigma ** 2)))*np.exp(-(x ** 2 + y ** 2)/(2*(sigma ** 2)))\n",
    "            D[i][j] = r\n",
    "    return D/(1/(2*np.pi*(sigma ** 2)))\n",
    "\n",
    "def Gaussian_mask(sigma,img):\n",
    "    Gmasked = gaussian_filter(img, sigma=sigma)\n",
    "    return Gmasked\n",
    "\n",
    "def r_generate(sigma_m,sigma_w,size=64):\n",
    "    gW = Gaussian_Window(sigma_w)\n",
    "    gW = (255.0 / gW.max() * (gW - gW.min())).astype(np.uint8)\n",
    "    #Image.fromarray(gW,mode='L').save('GW.jpg')\n",
    "    gNoisse = np.random.normal(loc=0.0, scale=1.0, size=(size,size))\n",
    "    #gN = (255.0 / gNoisse.max() * (gNoisse - gNoisse.min())).astype(np.uint8)\n",
    "    gM = Gaussian_mask(2,gNoisse) + 1\n",
    "    gMimg = (255.0 / gM.max() * (gM - gM.min())).astype(np.uint8)\n",
    "    Image.fromarray(gMimg,mode='L').save('GM.jpg')\n",
    "    G = np.multiply(gW,gM)\n",
    "    G = (255.0 / G.max() * (G - G.min())).astype(np.uint8)\n",
    "    return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "gW = Gaussian_Window(8,x_pos = 32, y_pos = 32)\n",
    "gWImg = (255.0 / gW.max() * (gW - gW.min())).astype(np.uint8)\n",
    "RsImg = Image.fromarray(gWImg,mode='L')\n",
    "RsImg.save('GaussianWindow.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = r_generate(2,8)\n",
    "rImg = Image.fromarray(r,mode='L')\n",
    "rImg.save('rrr.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "R = np.zeros((2000,4096))\n",
    "for i in range(0,2000):\n",
    "    r = np.ravel(r_generate(2,8))\n",
    "    R[i] = r\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "W = np.random.uniform(low=-0.1, high=0.1, size=(16,4096))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16, 16)"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y = np.dot(W,R[0])\n",
    "Y.reshape((16,1))\n",
    "np.tril(Y*np.transpose(Y)).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [],
   "source": [
    "beta = 10000\n",
    "dW = np.ones((4096,16))\n",
    "X = R[0].reshape((4096,1))\n",
    "W /= np.linalg.norm(W, axis=1).reshape((16,1))\n",
    "for i in range(0,2000):\n",
    "    Y = Y.reshape((16,1))\n",
    "    X = R[i].reshape((4096,1))\n",
    "    dW = beta*(np.dot(Y,np.transpose(X))- np.dot(np.tril(Y*np.transpose(Y)),W))\n",
    "    dW /= np.linalg.norm(dW, axis=1).reshape((16,1))\n",
    "    W /= np.linalg.norm(W, axis=1).reshape((16,1))\n",
    "    W = W + dW\n",
    "    \n",
    "    Y = np.dot(W,X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(64, 64)"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y_W = np.empty((16,64,64))\n",
    "yw = 0\n",
    "for w in W:\n",
    "    Y_W[yw] = w.reshape((64,64))\n",
    "    yw += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [],
   "source": [
    "iW0 = (255.0 / (Y_W[0]+1).max() * ((Y_W[0]+1) - (Y_W[0]+1).min())).astype(np.uint8)\n",
    "iw0 = Image.fromarray(iW0,mode='L')\n",
    "iw0.save('./weights/W00p.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,16):\n",
    "    z = str(i).zfill(4)\n",
    "    mmm = np.abs(Y_W[i].min()) \n",
    "    iW = (255.0 / (Y_W[i]+mmm).max() * ((Y_W[i]+mmm) - (Y_W[i]+mmm).min())).astype(np.uint8)\n",
    "    Image.fromarray(iW,mode='L').save('./weights/W'+z+'.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}