static/tensorflow_tests.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensorflow Tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from torch import from_numpy as t\n",
    "import network_moments.torch.gaussian as tnm\n",
    "from  network_moments.tensorflow.utils import *\n",
    "import network_moments.tensorflow.gaussian as fnm\n",
    "\n",
    "eager = False\n",
    "\n",
    "if eager:\n",
    "    tf.enable_eager_execution()\n",
    "else:\n",
    "    tf.InteractiveSession()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = 5\n",
    "n = 3\n",
    "p = 2\n",
    "batch = 7\n",
    "\n",
    "# numpy tensors\n",
    "nA = np.random.rand(m, n)\n",
    "nc1 = np.random.rand(m)\n",
    "nB = np.random.rand(p, m)\n",
    "nc2 = np.random.rand(p)\n",
    "nmu = np.random.rand(batch, n)\n",
    "nvar = np.random.rand(batch, n)\n",
    "ncov = np.random.rand(batch, n, n)\n",
    "\n",
    "# tensorflow tensors\n",
    "fA = tf.constant(nA, tf.float32)\n",
    "fc1 = tf.constant(nc1, tf.float32)\n",
    "fB = tf.constant(nB, tf.float32)\n",
    "fc2 = tf.constant(nc2, tf.float32)\n",
    "fmu = tf.constant(nmu, tf.float32)\n",
    "fvar = tf.constant(nvar, tf.float32)\n",
    "fcov = tf.constant(ncov, tf.float32)\n",
    "\n",
    "# torch tensors\n",
    "tA = t(nA)\n",
    "tc1 = t(nc1)\n",
    "tB = t(nB)\n",
    "tc2 = t(nc2)\n",
    "tmu = t(nmu)\n",
    "tvar = t(nvar)\n",
    "tcov = t(ncov)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# gaussian.affine:\n",
      "mean(): 2.3841858e-07\n",
      "covariance(): 2.3841858e-07\n",
      "variance(): 2.3841858e-07\n",
      "# gaussian.relu:\n",
      "mean(): 5.9604645e-08\n",
      "covariance(): 5.9604645e-08\n",
      "# gaussian.affine_relu_affine:\n",
      "mean(): 4.7683716e-07\n",
      "covariance(): 9.536743e-07\n",
      "variance(): 7.1525574e-07\n",
      "# Linearization\n",
      "A: 2.8007386299044867e-08\n",
      "c1: 1.4069705944752542e-07\n"
     ]
    }
   ],
   "source": [
    "def comp(a, b):\n",
    "    res = tf.reduce_max(tf.abs(a - b))\n",
    "    if tf.executing_eagerly():\n",
    "        return res.numpy()\n",
    "    else:\n",
    "        return res.eval()\n",
    "\n",
    "print('# gaussian.affine:')\n",
    "print(\"mean():\", comp(tnm.affine.mean(tmu, tA, tc1).numpy(),\n",
    "                      fnm.affine.mean(fmu, fA, fc1)))\n",
    "print(\"covariance():\", comp(tnm.affine.covariance(tcov, tA).numpy(),\n",
    "                            fnm.affine.covariance(fcov, fA)))\n",
    "print(\"variance():\", comp(tnm.affine.variance(tcov, tA).numpy(),\n",
    "                          fnm.affine.variance(fcov, fA)))\n",
    "\n",
    "print('# gaussian.relu:')\n",
    "print(\"mean():\", comp(tnm.relu.mean(tmu, tvar).numpy(),\n",
    "                      fnm.relu.mean(fmu, fvar)))\n",
    "print(\"covariance():\", comp(tnm.relu.zero_mean_covariance(tcov).numpy(),\n",
    "                          fnm.relu.zero_mean_covariance(fcov)))\n",
    "\n",
    "print('# gaussian.affine_relu_affine:')\n",
    "print(\"mean():\", comp(tnm.affine_relu_affine.mean(tmu, tcov, tA, tc1, tB, tc2).numpy(),\n",
    "                      fnm.affine_relu_affine.mean(fmu, fcov, fA, fc1, fB, fc2)))\n",
    "print(\"covariance():\", comp(tnm.affine_relu_affine.special_covariance(tcov, tA, tB).numpy(),\n",
    "                            fnm.affine_relu_affine.special_covariance(fcov, fA, fB)))\n",
    "print(\"variance():\", comp(tnm.affine_relu_affine.special_variance(tcov, tA, tB).numpy(),\n",
    "                          fnm.affine_relu_affine.special_variance(fcov, fA, fB)))\n",
    "\n",
    "if not eager:\n",
    "    print('# Linearization')\n",
    "    ins = tf.placeholder(tf.float32, shape=(None, n))\n",
    "    out = tf.maximum(matmul(ins, fA, transpose_b=True)+fc1, 0)\n",
    "    A, c1 = linearize(out, ins, nmu)\n",
    "    print('A:', comp(nA, A))\n",
    "    print('c1:', comp(nc1, c1))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}