01_ek_tensorflow.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of 01_ek_tensorflow.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyOiJ7dUfPA7N5c6tdJLiMF6",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/kgene521/Calc/blob/master/01_ek_tensorflow.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Code is at:\n",
        "https://github.com/mrdburke/tensorflow-deep-learning/\n"
      ],
      "metadata": {
        "id": "SZ5-vDE0Mj8N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tensofflow documentation\n",
        "https://www.tensorflow.org/api_docs/python\n",
        "\n",
        "Rule 4: \"Use lobal and operation level random seed\""
      ],
      "metadata": {
        "id": "P7iHeGzhN2Ye"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HJwoR6G7xD2l"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "from psutil import virtual_memory\n",
        "import numpy as np\n",
        "\n",
        "ram_gb = virtual_memory().total / 1e9\n",
        "print('Your runtime has {:.1f} gigabytes of available RAM\\n'.format(ram_gb))\n",
        "\n",
        "def print_env():\n",
        "  if ram_gb < 20:\n",
        "    print('Not using a high-RAM runtime')\n",
        "  else:\n",
        "    print('You are using a high-RAM runtime!')\n",
        "\n",
        "  gpu_info = !nvidia-smi\n",
        "  gpu_info = '\\n'.join(gpu_info)\n",
        "  if gpu_info.find('failed') >= 0:\n",
        "    print('Not connected to a GPU')\n",
        "  else:\n",
        "    print(gpu_info)\n",
        "\n",
        "def p(msg):\n",
        "  print(msg)\n",
        "\n",
        "def print_tensor_info(tensor, msg=\"\", conf=0):\n",
        "  nump_array = tensor.numpy()\n",
        "  print(\"=\"*50)\n",
        "  p(msg)\n",
        "  print(f\"{tensor}\")\n",
        "  if conf == 1:\n",
        "    print(f\"Number of dims (rank): {tensor.ndim}\")\n",
        "    print(f\"Shape of tensor: {tensor.shape}\")\n",
        "    print(f\"Datatype of every element: {tensor.dtype}\")\n",
        "    print(f\"Elements along the 0 axis: {tensor.shape[0]}\")\n",
        "    print(f\"Elements along the last axis: {tensor.shape[-1]}\")\n",
        "    print(f\"Total number of elements in tensor: {tf.size(tensor)}\", )\n",
        "    print(f\"Total number of elements in numpy array: {tf.size(tensor.numpy())}\", )\n",
        "\n",
        "  # print(\"=\"*50)\n",
        "\n",
        "pti = print_tensor_info\n",
        "\n",
        "\n",
        "\n",
        "not_shuffled = tf.constant([[10, 7], [3, 4], [2, 5]])\n",
        "not_shuffled\n",
        "tf.random.set_seed(42) # global level random seed (always the same)\n",
        "tf.random.shuffle(not_shuffled, seed=42) # operation level random seed (superseded by global)\n",
        "not_shuffled\n",
        "tf.random.shuffle(not_shuffled, seed=42)\n",
        "\n",
        "# Create a tensor of all ones\n",
        "tf.ones([3, 2])\n",
        "tf.ones(shape=(3, 3))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Turn NumPy arrays into tensors\n",
        "### The main difference between NumPy arrays and Tensorflow tensors is that tensors can be run on GPU"
      ],
      "metadata": {
        "id": "aXZdSdHRQHJF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "numpy_A = np.arange(1, 25, dtype=np.int32) # create a NumPy array between 1 and 25 (not including 25)\n",
        "numpy_A\n",
        "A = tf.constant(numpy_A, shape=(2, 3, 4))  # re-shape the array from 1 dim to 3 dim \n",
        "B = tf.constant(numpy_A)\n",
        "A, B, A.ndim, B.ndim\n"
      ],
      "metadata": {
        "id": "cP5YmPYMPcFM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Getting information from/about tensors\n",
        "* Shape\n",
        "* Rank\n",
        "* Axis or dimension\n",
        "* Size"
      ],
      "metadata": {
        "id": "jbfWE8zlT83R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "rank_4_tensor = tf.zeros(shape=(2, 2, 2, 2, 2))\n",
        "rank_4_tensor\n",
        "# Create a rank 2 tensor (2 dimensions)\n",
        "rank_2_tensor = tf.constant([[10, 7], [3, 4]])\n",
        "rank_2_tensor.shape, rank_2_tensor.ndim\n",
        "rank_2_tensor\n",
        "some_list = [1, 2, 3, 4]\n",
        "some_list, some_list[-1]\n",
        "# Get the last item of each row of rank_2_tensor\n",
        "rank_2_tensor[:, -1], rank_2_tensor[:0,:]\n",
        "# Add in a new dimension to our rank_2_tensor\n",
        "rank_3_tensor = rank_2_tensor[..., tf.newaxis]\n",
        "rank_3_tensor\n",
        "foo = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
        "print(foo[tf.newaxis, :, :])\n",
        "print(foo[:, tf.newaxis, :])\n",
        "print(foo[:, :, tf.newaxis])\n",
        "\n",
        "foo = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
        "tf.expand_dims(foo, axis=0)\n",
        "print_tensor_info(foo)\n"
      ],
      "metadata": {
        "id": "rivXanrNRDo1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Manipulating Tensors (tensor operations)\n",
        "### Basic Operations\n",
        "`+, -, *, /`\n"
      ],
      "metadata": {
        "id": "BR67ILSsdMr_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Addition operator\n",
        "tensor = tf.constant([[10, 7], [3, 4]])\n",
        "tensor + 10\n",
        "print_tensor_info(tensor / 10)\n",
        "print_tensor_info(tensor)\n",
        "print_tensor_info(tf.multiply(tensor, 11))\n"
      ],
      "metadata": {
        "id": "qqQP4JOjWvbJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Matrix Multiplication\n",
        "\n",
        "*Element-Wise Multiply Matrix by another Matrix*\n"
      ],
      "metadata": {
        "id": "jK7YJt6HzCQr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_vector = [10, 20]\n",
        "print_tensor_info(tensor)\n",
        "print_tensor_info(tf.multiply(tensor, [1, 2]))\n"
      ],
      "metadata": {
        "id": "r6m01LmFzq5q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Dot product*\n"
      ],
      "metadata": {
        "id": "RuEvq_b5EEQQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor)\n",
        "print_tensor_info(tf.matmul(tensor, tensor))\n",
        "me = tf.constant([[10, 7], [3, 4]])\n",
        "print_tensor_info(me)\n",
        "print_tensor_info(tf.matmul(me, me))\n",
        "\n"
      ],
      "metadata": {
        "id": "Zeoq5961Jxt3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "mat1 = tf.constant([[[1, 2, 5], [7, 2, 1], [3, 3, 3]]])\n",
        "mat2 = tf.constant([[3, 5], [6, 7], [1, 8]])\n",
        "print_tensor_info(mat1)\n",
        "print_tensor_info(mat2)\n",
        "print_tensor_info(tf.matmul(mat1, mat2))\n",
        "\n"
      ],
      "metadata": {
        "id": "pUo5x4gqJ7o-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Python Matrix Multiplication using operator @*\n"
      ],
      "metadata": {
        "id": "6FynfdBKPlzp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pti(tensor @ tensor)\n",
        "pti(tf.matmul(tensor, tensor))"
      ],
      "metadata": {
        "id": "Ioif4O2FNqho"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "📚 **Resource:** Info and example matrix multiplication: \n",
        "\n",
        "https://www.mathisfun.com/algebra/matrix-multiplying.html\n"
      ],
      "metadata": {
        "id": "S7sYLd_cRBzT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Y = tf.constant([[7, 8], [9, 10], [11, 12]])\n",
        "X = tf.reshape(Y, shape=(2, 3))\n",
        "pti(Y)\n",
        "pti(X)\n",
        "pti(tf.matmul(Y, X))\n",
        "pti(tf.matmul(X, Y))\n"
      ],
      "metadata": {
        "id": "klh1k1lkQG55"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X = tf.constant([[1, 2], [3, 4], [5, 6]])\n",
        "pti(X)\n",
        "pti(Y)\n",
        "pti(tf.transpose(X))\n",
        "# pti(tf.reshape(X, shape=(2, 3)))\n",
        "pti(tf.matmul(tf.transpose(X), Y))\n"
      ],
      "metadata": {
        "id": "Mz_a63NJtCAP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**The dot product**\n",
        "Matrix multiplication can be performed using:\n",
        "\n",
        "* `tf.matmul(X, Y)`\n",
        "* `tf.tensordot(X, Y, axes=n)`\n"
      ],
      "metadata": {
        "id": "T9B1kEwCwbUh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Perform the dot product on X and Y (requires X or Y to be transposed)\n",
        "pti(X)\n",
        "pti(Y)\n",
        "Xp = tf.transpose(X)\n",
        "pti(Xp)\n",
        "pti(tf.tensordot(Xp, Y, axes=1))\n"
      ],
      "metadata": {
        "id": "t-x6r917wP4_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Perform matrix multiplication between X and Y (transposed)\n",
        "pti(X)\n",
        "pti(Y)\n",
        "pti(tf.transpose(Y))\n",
        "tf.matmul(X, tf.transpose(Y))\n",
        "# Perform matrix multiplication between X and Y (reshaped)\n",
        "tf.matmul(X, tf.reshape(Y, shape=(2, 3)))"
      ],
      "metadata": {
        "id": "dmiWm8W4zHTs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Check the values of Y, reshaped Y and transposed Y\n",
        "p(\"Normal Y:\")\n",
        "pti(Y)\n",
        "p(\"Y reshaped to (2, 3):\")\n",
        "pti(tf.reshape(Y, shape=(2,3)))\n",
        "p(\"Y transposed:\")\n",
        "pti(tf.transpose(Y))"
      ],
      "metadata": {
        "id": "bUcczLWu1ZCK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Changing the datatype of a tensor\n"
      ],
      "metadata": {
        "id": "nhMxMHH9MOrQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Change precision of float\n"
      ],
      "metadata": {
        "id": "9X2KLRAVNtOI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a new tensor with default datatype (float32), check the version of tf: tf.__version__\n",
        "B = tf.constant([1.7, 7.4])\n",
        "C = tf.constant([7, 10])\n",
        "B.dtype, C.dtype, tf.cast(B, dtype=tf.float16), tf.cast(C, dtype=tf.int16)"
      ],
      "metadata": {
        "id": "gToRy66kMU_K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Aggregating Tensors\n",
        "### Aggregating tensors = condensing tensors from many values to fewer values\n",
        "\n",
        "* Get the absolute value"
      ],
      "metadata": {
        "id": "paOaJD44R3kA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "D = tf.constant([-7, -10])\n",
        "D, tf.abs(D)"
      ],
      "metadata": {
        "id": "bS8e7nvVR2Xc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Get the minimum\n",
        "* Get the maximum\n",
        "* Get the mean\n",
        "* Get the sum"
      ],
      "metadata": {
        "id": "bDL3zzLlWz9y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "E = tf.constant([3., 6., -1., 0., 34., 99., 200., 129., 100., 90., 35., 261., 693.])\n",
        "tf.reduce_max(E), tf.reduce_min(E), tf.reduce_mean(E), tf.reduce_sum(E)"
      ],
      "metadata": {
        "id": "LIkTEg8cWoqF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Get the Variance and Standard Deviation of a tensor"
      ],
      "metadata": {
        "id": "gA5WCZqXcZ5e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow_probability as tfp\n",
        "\n",
        "pti(E, \"E tensor: \")\n",
        "Ep = tf.cast(E, dtype=tf.float32)\n",
        "# Ep = E\n",
        "pti(tf.math.reduce_variance(Ep), \"tf.math.reduce_variance: \")\n",
        "pti(tf.math.reduce_std(Ep), \"tf.math.reduce_std: \")\n"
      ],
      "metadata": {
        "id": "yZIylWPDcjDG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Find the index of the maximum/minimum "
      ],
      "metadata": {
        "id": "aJMuziuwqrIj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.random.set_seed(42)\n",
        "F = tf.random.uniform(shape=[50])\n",
        "pti(F, \"Tensor F: \")\n",
        "pti(tf.argmax(F), \"tf.argmax(F)\")\n",
        "max1 = tf.argmax(F)\n",
        "max2 = tf.reduce_max(F)\n",
        "p(f\"F[tf.argmax(F)]: {F[max1]}  tf.reduce_max(F): {max2}\")\n",
        "res = (F[max1] == max2)\n",
        "p(f\"F[tf.argmax(F)] == tf.reduce_max(F): {res}\")\n"
      ],
      "metadata": {
        "id": "5W3ypG9_q7ui"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Squeezing a tensor (removing all single dimensions)\n"
      ],
      "metadata": {
        "id": "_T473PnezUUK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.random.set_seed(42)\n",
        "G = tf.constant(tf.random.uniform(shape=[50]), shape=(1, 1, 1, 1, 50))\n",
        "G_squeezed = tf.squeeze(G)\n",
        "pti(G), \n",
        "p(G.shape)\n",
        "pti(G_squeezed) \n",
        "p(G_squeezed.shape)"
      ],
      "metadata": {
        "id": "SKWQn4cBzZ92"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#One-hot encoding tensors"
      ],
      "metadata": {
        "id": "3kpWJp138Agu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a list of indices\n",
        "some_list = [0, 1, 2, 4]\n",
        "# One hot encode our list of indices\n",
        "tf.one_hot(indices=some_list, depth=4)\n",
        "\n",
        "# Specify custom values for one hot encoding\n",
        "tf.one_hot(indices=some_list, depth=6, on_value=1, off_value=None)\n"
      ],
      "metadata": {
        "id": "58CroHXg8FmZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Square, log, square root"
      ],
      "metadata": {
        "id": "HiOKCDgv-4z-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "H = tf.range(1, 10)\n",
        "p(H)\n",
        "p(tf.square(H))\n",
        "p(tf.sqrt(tf.cast(H, tf.float32)))\n",
        "p(tf.math.log(tf.cast(H, tf.float32)))"
      ],
      "metadata": {
        "id": "HkjnGisl-_0L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Tensors and NumPy\n",
        "TensorFlow integrates with NumPy\n",
        "\n",
        "stopped 03/21/2022 10:16pm"
      ],
      "metadata": {
        "id": "-K_XVIX_BGD5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "J = tf.constant(np.array([3., 7., 10.]))\n",
        "p(J)\n",
        "np.array(J)\n",
        "J.numpy(), type(J.numpy())\n"
      ],
      "metadata": {
        "id": "eJobzCxVBLPT"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}