contracture_curve.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "contracture_curve.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/starkdg/pyConvnetPhash/blob/master/contracture_curve.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "metadata": {
        "id": "OjQVaoUfSMDZ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/gdrive')\n",
        "\n",
        "import sys\n",
        "import os\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "import tensorflow as tf\n",
        "import tensorflow_hub as hub\n",
        "\n",
        "model_dir = \"/gdrive/My Drive/models\"\n",
        "module_inception_url = \"https://tfhub.dev/google/imagenet/inception_v3/feature_vector/1\"\n",
        "module_mobilenetv2_url = \"https://tfhub.dev/google/imagenet/mobilenet_v2_140_224/feature_vector/2\"\n",
        "\n",
        "module = hub.Module(module_mobilenetv2_url)\n",
        "target_height, target_width = hub.get_expected_image_size(module)\n",
        "\n",
        "normalization_constant = 5.0\n",
        "\n",
        "n_inputs = 1792\n",
        "n_hidden = 256\n",
        "model_tag = \"sigmoid1\"\n",
        "# model_file = \"/gdrive/My Drive/models/pca_autoencoder/mobilenetv2_pca_autoenc_{0}to{1}_frozen_model-{2}.pb\".format(n_inputs, n_hidden, model_tag)\n",
        "model_file = \"/gdrive/My Drive/models/cae_autoencoder/mobilenetv2_cae_autoenc_{0}to{1}_frozen_model-{2}.pb\".format(n_inputs, n_hidden, model_tag)\n",
        "# model_file = \"/gdrive/My Drive/models/svd/mobilenetv2_pca_from_svd_1792to256_frozen_model.pb\"\n",
        "\n",
        "input_tensor_name = \"autoenc/input:0\"\n",
        "output_tensor_name = \"autoenc/output:0\"\n",
        "\n",
        "files_dir = \"/gdrive/My Drive/imageset/test\"\n",
        "batch_size = 40\n",
        "n_intervals = 100\n",
        "min_distance = 0.\n",
        "max_distance = 10.\n",
        "\n",
        "plot_title_str = \"Contractive Curve for CAE {0} to {1} Feature Space\".format(n_inputs, n_hidden)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "dJh_r22nUErn",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "\n",
        "with tf.gfile.GFile(model_file, 'rb') as f:\n",
        "  aec_graph_def = tf.GraphDef()  \n",
        "  aec_graph_def.ParseFromString(f.read())\n",
        "\n",
        "  \n",
        "  \n",
        "graph = tf.get_default_graph()\n",
        "\n",
        "tf.import_graph_def(aec_graph_def, name='autoenc')\n",
        "\n",
        "input_tensor = graph.get_tensor_by_name(input_tensor_name)\n",
        "output_tensor = graph.get_tensor_by_name(output_tensor_name)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "j9iYJKBWSkzf",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def get_tfrecord_files(path):\n",
        "  files = []\n",
        "  for entry in os.scandir(path):\n",
        "    if entry.is_file() and entry.name.endswith('.tfrecord'):\n",
        "             files.append(entry.path)\n",
        "  return files\n",
        "  \n",
        "  \n",
        "def _parse_example(example):\n",
        "  features = {'height': tf.FixedLenFeature([], tf.int64),\n",
        "              'width': tf.FixedLenFeature([], tf.int64),\n",
        "              'image_raw': tf.FixedLenFeature([], tf.string)}\n",
        "  parsed_features = tf.parse_single_example(example, features)\n",
        "  img = tf.io.decode_raw(parsed_features['image_raw'], tf.uint8)\n",
        "  height = tf.cast(parsed_features['height'], tf.int32)\n",
        "  width = tf.cast(parsed_features['width'], tf.int32)\n",
        "\n",
        "  img_reshaped = tf.manip.reshape(img, [height, width, 3])\n",
        "  imgfl = tf.image.convert_image_dtype(img_reshaped, dtype=tf.float32)\n",
        "  img_norm = tf.expand_dims(imgfl, 0)\n",
        "  img_resized = tf.image.resize_bicubic(img_norm, [target_height, target_width])\n",
        "  img_resized = tf.squeeze(img_resized, 0)\n",
        "  return img_resized\n",
        "\n",
        "\n",
        "def input_function(path, batch_size=1, num_epochs=None, shuffle=False):\n",
        "  tfrecords = get_tfrecord_files(path)\n",
        "  dataset = tf.data.TFRecordDataset(tfrecords)\n",
        "  dataset = dataset.map(_parse_example)\n",
        "  if (shuffle):\n",
        "    dataset = dataset.shuffle(10000)\n",
        "  dataset = dataset.batch(batch_size).repeat(num_epochs)\n",
        "  iterator = dataset.make_initializable_iterator()\n",
        "  return iterator\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "vueEdJ1RkPV2",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def generate_points_from_features(features, radius):\n",
        "  n_points, n_features = features.shape\n",
        "  features2 = np.random.normal(0., normalization_constant, size=(n_points, n_features))\n",
        "  features2 = radius * features2 / np.linalg.norm(features2, axis=1, keepdims=True)\n",
        "  features2 = features2 + features\n",
        "  features2 = np.clip(features2, 0., normalization_constant)\n",
        "  return features2\n",
        "  \n",
        "def avg_difference_between_points(features1, features2):\n",
        "  avg_distance = np.mean(np.linalg.norm(features1 - features2, axis=1))\n",
        "  return avg_distance\n",
        "  \n",
        "def normalize(x):\n",
        "  normalize_x = x / normalization_constant\n",
        "  return normalize_x"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "VIyamYJPSsTC",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def calc_contracture_curve(files_dir, batch, n_intervals=100, min_distance=0, max_distance=100):\n",
        "  images_iter = input_function(files_dir, batch)\n",
        "  test_images = images_iter.get_next()\n",
        "  test_features = module(test_images)\n",
        "    \n",
        "  delta_distance = (max_distance - min_distance)/n_intervals\n",
        "  distances = [x*delta_distance + delta_distance + min_distance for x in range(0, n_intervals)]\n",
        "\n",
        "  init = tf.global_variables_initializer()\n",
        "  sess = tf.Session()\n",
        "  sess.run(init)\n",
        "  \n",
        "  orig_distances = []\n",
        "  cond_distances = []\n",
        "  ratios = []\n",
        "  print(\"Contraction of Autoencoder\")\n",
        "  for d in distances:\n",
        "    sess.run([images_iter.initializer])\n",
        "    \n",
        "    # get next features\n",
        "    features = sess.run(test_features)\n",
        "    features2 = generate_points_from_features(features, d)\n",
        "    \n",
        "    condensed_features = sess.run(output_tensor, feed_dict={input_tensor : features})\n",
        "    condensed_features2 = sess.run(output_tensor, feed_dict={input_tensor : features2})\n",
        "        \n",
        "    avg_distance1 = avg_difference_between_points(features, features2)\n",
        "    avg_distance2 = avg_difference_between_points(condensed_features, condensed_features2)\n",
        "    \n",
        "    orig_distances.append(avg_distance1)\n",
        "    cond_distances.append(avg_distance2)\n",
        "    \n",
        "    ratio = avg_distance2 / avg_distance1\n",
        "    ratios.append(ratio)\n",
        "    print(\"d = {0:.2f} orig = {1:.4f} cond = {2:.8f} cond/orig = {3:.6f}\".format(d, avg_distance1, avg_distance2, ratio))\n",
        "    \n",
        "  return distances, orig_distances, cond_distances, ratios\n",
        "   \n",
        "    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "FXRItjjdkamk",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "\n",
        "d, orig, cond, ratios = calc_contracture_curve(files_dir, batch_size, n_intervals, min_distance, max_distance)\n",
        "\n",
        "plt.figure(1)\n",
        "plt.plot(orig, cond, orig, ratios)\n",
        "plt.legend(['condensed', 'ratio'], loc='upper left')\n",
        "plt.title(plot_title_str)\n",
        "plt.xlabel(\"Original Feature Distance\")\n",
        "plt.ylabel(\"Condensed Feature Distance\")\n",
        "plt.show()\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}