Tensorflow - Basics.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/sahug/ds-tensorflow-colab/blob/master/Tensorflow%20-%20Basics.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wWxFCBouWTe-"
      },
      "source": [
        "**Tensorflow - Basics**\n",
        "\n",
        "TensorFlow is an end-to-end platform for machine learning. It supports the following:\n",
        "\n",
        "- Multidimensional-array based numeric computation (similar to **NumPy**.)\n",
        "- GPU and distributed processing\n",
        "- Automatic differentiation\n",
        "- Model construction, training, and export\n",
        "- And more"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZL_2jtgPWeQt"
      },
      "source": [
        "**Tensors**\n",
        "\n",
        "TensorFlow operates on multidimensional arrays or tensors represented as **tf.Tensor** objects. Here is a two-dimensional tensor:\n",
        "\n",
        "The most important attributes of a **tf.Tensor** are its **shape** and **dtype**:\n",
        "\n",
        "Tensor.**shape**: tells you the size of the tensor along each of its axes.\n",
        "\n",
        "Tensor.**dtype**: tells you the type of all the elements in the tensor.\n",
        "\n",
        "Everything in TensorFlow is based on Tensor operations. Tensors are (kind of) like np.arrays. All tensors are immutable: you can never update the contents of a tensor, only create a new one."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [],
      "source": [
        "import tensorflow as tf"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Create**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Scalar, Rank-0 Tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor(4, shape=(), dtype=int32)\n"
          ]
        }
      ],
      "source": [
        "\n",
        "x = tf.constant(4)\n",
        "print(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Vector, Rank-1 Tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor([1 2 3], shape=(3,), dtype=int32)\n"
          ]
        }
      ],
      "source": [
        "x = tf.constant([1,2,3])\n",
        "print(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Matrix, Rank-2 Tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pEQq1QqeWN1I",
        "outputId": "002c8f0c-ebbb-4a79-96e3-2b4a97e6c2a4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor(\n",
            "[[1. 2. 3.]\n",
            " [4. 5. 6.]], shape=(2, 3), dtype=float32)\n",
            "(2, 3)\n",
            "<dtype: 'float32'>\n"
          ]
        }
      ],
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "x = tf.constant([\n",
        "                 [1.,2.,3.,],\n",
        "                 [4.,5.,6.,]])\n",
        "\n",
        "print(x)\n",
        "print(x.shape)\n",
        "print(x.dtype)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "One-Hot Tensors"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor(\n",
            "[[1. 1. 1.]\n",
            " [1. 1. 1.]\n",
            " [1. 1. 1.]], shape=(3, 3), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "x = tf.ones((3,3))\n",
        "print(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Zero Tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor(\n",
            "[[0. 0. 0.]\n",
            " [0. 0. 0.]\n",
            " [0. 0. 0.]], shape=(3, 3), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "x = tf.zeros((3,3))\n",
        "print(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Identity Tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor(\n",
            "[[1. 0. 0.]\n",
            " [0. 1. 0.]\n",
            " [0. 0. 1.]], shape=(3, 3), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "x = tf.eye(3)\n",
        "print(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Random Normal Tensor\n",
        "\n",
        "Outputs random values from a normal distribution."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor(\n",
            "[[ 0.7003764   2.3886075  -0.14009777]\n",
            " [ 1.5319357  -0.13742709  2.0903883 ]\n",
            " [ 0.26101756 -0.12700923 -0.04365437]], shape=(3, 3), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "x = tf.random.normal((3,3), mean=0, stddev=1)\n",
        "print(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Random Uniform Tensor\n",
        "\n",
        "Outputs random values from a uniform distribution."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor(\n",
            "[[0.09686077 0.03202593 0.45156038]\n",
            " [0.20881367 0.39181316 0.41869915]\n",
            " [0.345379   0.27274346 0.62917507]], shape=(3, 3), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "x = tf.random.uniform((3,3), minval=0, maxval=1)\n",
        "print(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Cast**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "int: tf.Tensor([0 1 2 3 4 5 6 7 8 9], shape=(10,), dtype=int32)\n",
            "float: tf.Tensor([0. 1. 2. 3. 4. 5. 6. 7. 8. 9.], shape=(10,), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "x = tf.range(10)\n",
        "print(\"int:\", x)\n",
        "x = tf.cast(x, dtype=tf.float32)\n",
        "print(\"float:\", x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Operations**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Addition"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor([5 7 9], shape=(3,), dtype=int32)\n",
            "tf.Tensor([5 7 9], shape=(3,), dtype=int32)\n"
          ]
        }
      ],
      "source": [
        "x = tf.constant([1,2,3])\n",
        "y = tf.constant([4,5,6])\n",
        "\n",
        "z = tf.add(x,y)\n",
        "print(z)\n",
        "\n",
        "z = x + y\n",
        "print(z)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Subtraction"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor([-3 -3 -3], shape=(3,), dtype=int32)\n",
            "tf.Tensor([-3 -3 -3], shape=(3,), dtype=int32)\n"
          ]
        }
      ],
      "source": [
        "x = tf.constant([1,2,3])\n",
        "y = tf.constant([4,5,6])\n",
        "\n",
        "z = tf.subtract(x,y)\n",
        "print(z)\n",
        "\n",
        "z = x - y\n",
        "print(z)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Division"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor([0.25 0.4  0.5 ], shape=(3,), dtype=float64)\n",
            "tf.Tensor([0.25 0.4  0.5 ], shape=(3,), dtype=float64)\n"
          ]
        }
      ],
      "source": [
        "x = tf.constant([1,2,3])\n",
        "y = tf.constant([4,5,6])\n",
        "\n",
        "z = tf.divide(x,y)\n",
        "print(z, \"\\n\")\n",
        "\n",
        "z = x / y\n",
        "print(z, \"\\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Multiply"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor([ 4 10 18], shape=(3,), dtype=int32)\n",
            "tf.Tensor([ 4 10 18], shape=(3,), dtype=int32)\n"
          ]
        }
      ],
      "source": [
        "x = tf.constant([1,2,3])\n",
        "y = tf.constant([4,5,6])\n",
        "\n",
        "z = tf.multiply(x,y)\n",
        "print(z, \"\\n\")\n",
        "\n",
        "z = x * y\n",
        "print(z, \"\\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Dot Product"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor(32, shape=(), dtype=int32)\n"
          ]
        }
      ],
      "source": [
        "x = tf.constant([1,2,3])\n",
        "y = tf.constant([4,5,6])\n",
        "\n",
        "z = tf.tensordot(x,y, axes=1)\n",
        "print(z)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Exponents"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor([  8. 512.], shape=(2,), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "x = tf.constant([2.0, 8.0])\n",
        "z = x ** 3\n",
        "print(z)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Matrix Multiplication"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor(\n",
            "[[ 1.0311725  -0.2663836   0.21051812  1.2172937 ]\n",
            " [ 0.20502889 -1.2961298  -0.35803106 -2.4185078 ]], shape=(2, 4), dtype=float32)\n",
            "tf.Tensor(\n",
            "[[ 1.0311725  -0.2663836   0.21051812  1.2172937 ]\n",
            " [ 0.20502889 -1.2961298  -0.35803106 -2.4185078 ]], shape=(2, 4), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "x = tf.random.normal((2,3)) # 2,3\n",
        "y = tf.random.normal((3,4)) # 3,4\n",
        "\n",
        "z = tf.matmul(x,y)\n",
        "print(z, \"\\n\")\n",
        "\n",
        "z = x @ y\n",
        "print(z, \"\\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Indexing and Slicing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor([1 2 3 4], shape=(4,), dtype=int32) \n",
            "\n",
            "tf.Tensor([1 5], shape=(2,), dtype=int32) \n",
            "\n",
            "tf.Tensor([5 6 7 8], shape=(4,), dtype=int32) \n",
            "\n",
            "tf.Tensor(6, shape=(), dtype=int32) \n",
            "\n"
          ]
        }
      ],
      "source": [
        "x = tf.constant([[1,2,3,4],[5,6,7,8]])\n",
        "\n",
        "print(x[0], \"\\n\")\n",
        "print(x[:, 0], \"\\n\") # all rows, column 0\n",
        "print(x[1, :], \"\\n\") # row 1, all columns\n",
        "print(x[1,1], \"\\n\") # element at 1, 1\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Reshape**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor(\n",
            "[[ 0.8320782  -0.25611863  1.1959288 ]\n",
            " [-1.6438805   1.2278249  -0.41673538]], shape=(2, 3), dtype=float32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[ 0.8320782  -0.25611863]\n",
            " [ 1.1959288  -1.6438805 ]\n",
            " [ 1.2278249  -0.41673538]], shape=(3, 2), dtype=float32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[ 0.8320782  -0.25611863]\n",
            " [ 1.1959288  -1.6438805 ]\n",
            " [ 1.2278249  -0.41673538]], shape=(3, 2), dtype=float32) \n",
            "\n",
            "tf.Tensor([ 0.8320782  -0.25611863  1.1959288  -1.6438805   1.2278249  -0.41673538], shape=(6,), dtype=float32) \n",
            "\n"
          ]
        }
      ],
      "source": [
        "x = tf.random.normal((2,3))\n",
        "print(x, \"\\n\")\n",
        "\n",
        "x = tf.reshape(x, (3,2))\n",
        "print(x, \"\\n\")\n",
        "\n",
        "x = tf.reshape(x, (-1,2))\n",
        "print(x, \"\\n\")\n",
        "\n",
        "x = tf.reshape(x, (6))\n",
        "print(x, \"\\n\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Numpy**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<class 'numpy.ndarray'> \n",
            "\n",
            "<class 'tensorflow.python.framework.ops.EagerTensor'> \n",
            "\n"
          ]
        }
      ],
      "source": [
        "x = x.numpy()\n",
        "print(type(x), \"\\n\")\n",
        "\n",
        "x = tf.convert_to_tensor(x)\n",
        "print(type(x), \"\\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**String Tensors**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor(b'Patrick', shape=(), dtype=string) \n",
            "\n",
            "tf.Tensor([b'Patrick' b'Max' b'Mary'], shape=(3,), dtype=string) \n",
            "\n"
          ]
        }
      ],
      "source": [
        "# string tensor\n",
        "x = tf.constant(\"Patrick\")\n",
        "print(x, \"\\n\")\n",
        "\n",
        "x = tf.constant([\"Patrick\", \"Max\", \"Mary\"])\n",
        "print(x, \"\\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qT8QtK_TXb-q"
      },
      "source": [
        "**Transpose**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E0bkSRddXfNR",
        "outputId": "2135f991-2a9a-41ef-cef2-c563494b00f8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n",
              "array([[14., 32.],\n",
              "       [32., 77.]], dtype=float32)>"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x @ tf.transpose(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AsVvtsS9Xmm-"
      },
      "source": [
        "**Concat**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vodn-MTjXnx_",
        "outputId": "500c4e51-faf7-42ee-b65f-2d0804ce4470"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(6, 3), dtype=float32, numpy=\n",
              "array([[1., 2., 3.],\n",
              "       [4., 5., 6.],\n",
              "       [1., 2., 3.],\n",
              "       [4., 5., 6.],\n",
              "       [1., 2., 3.],\n",
              "       [4., 5., 6.]], dtype=float32)>"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tf.concat([x, x, x], axis = 0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7KAr9_vqXsqW"
      },
      "source": [
        "**Normalization**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LZTcnMS4Xv7A",
        "outputId": "15f5ce4f-44bc-4c0b-aae0-696314e0212d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3), dtype=float32, numpy=\n",
              "array([[0.09003057, 0.24472848, 0.66524094],\n",
              "       [0.09003057, 0.24472848, 0.66524094]], dtype=float32)>"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tf.nn.softmax(x, axis = -1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WcEnpttAX5nz"
      },
      "source": [
        "**Reduce**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TblvKMQrX34B",
        "outputId": "38f7d9d4-6045-4206-8ca5-a37552c1c3e6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor(21.0, shape=(), dtype=float32)\n",
            "tf.Tensor(720.0, shape=(), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "print(tf.reduce_sum(x))\n",
        "print(tf.reduce_prod(x))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rELbfyvuYQkv"
      },
      "source": [
        "**Config**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rHuDEvWiYSE3",
        "outputId": "a56be96d-7088-4f7f-c9d2-277bbef34cdb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "TensorFlow **IS NOT** using the GPU\n"
          ]
        }
      ],
      "source": [
        "if tf.config.list_physical_devices(\"GPU\"):\n",
        "    print(\"TensorFlow **IS** using the GPU\")\n",
        "else:\n",
        "  print(\"TensorFlow **IS NOT** using the GPU\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XHdquXM8Yauw"
      },
      "source": [
        "**Variables**\n",
        "\n",
        "Normal **tf.Tensor** objects are **immutable**. To store model weights (or other mutable state) in TensorFlow use a **tf.Variable**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j0sifPqoYNwX",
        "outputId": "6dd86726-1fd0-4542-8d35-a3f43e29e6ae"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<tf.Variable 'Variable:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "var = tf.Variable([0.0, 0.0, 0.0])\n",
        "var"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AW5xXQIGYraJ",
        "outputId": "6e80d553-41fd-43f9-f218-da3f82eea005"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<tf.Variable 'UnreadVariable' shape=(3,) dtype=float32, numpy=array([1., 2., 3.], dtype=float32)>"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "var.assign([1, 2, 3])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wOBJU8IbYwKM",
        "outputId": "7e431221-5769-4716-b5a9-4208a54f2ba3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<tf.Variable 'UnreadVariable' shape=(3,) dtype=float32, numpy=array([2., 3., 4.], dtype=float32)>"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "var.assign_add([1, 1, 1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YETSZDeFY2lo"
      },
      "source": [
        "**Automatic differentiation**\n",
        "\n",
        "Gradient descent and related algorithms are a cornerstone of modern machine learning.\n",
        "\n",
        "To enable this, TensorFlow implements automatic differentiation (autodiff), which uses calculus to compute gradients. Typically you'll use this to calculate the gradient of a model's error or loss with respect to its weights."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QonswdQQY0IS",
        "outputId": "73013a65-aec6-4a59-f670-a711bbd405e7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=-2.0>"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = tf.Variable(1.0)\n",
        "\n",
        "def f(x):\n",
        "  y = x**2 + 2*x - 5\n",
        "  return y\n",
        "\n",
        "f(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "stznNPHOZNuB"
      },
      "source": [
        "At `x = 1.0, y = f(x) = (1**2 + 2*1 - 5) = -2.`\n",
        "\n",
        "The derivative of y is `y' = f'(x) = (2*x + 2) = 4`. TensorFlow can calculate this automatically:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FtgS6shHZIuj",
        "outputId": "2b77dcc6-ebd2-4814-81ea-4ddecb23d2e1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=4.0>"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "with tf.GradientTape() as tape:\n",
        "  y = f(x)\n",
        "\n",
        "g_x = tape.gradient(y, x)  # g(x) = dy/dx\n",
        "\n",
        "g_x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4o3JWTNyZWDu"
      },
      "source": [
        "**Graphs and tf.function**\n",
        "\n",
        "While you can use TensorFlow interactively like any Python library, TensorFlow also provides tools for:\n",
        "\n",
        "- **Performance optimization:**to speed up training and inference.\n",
        "- **Export**: so you can save your model when it's done training.\n",
        "\n",
        "These require that you use **tf.function** to separate your **pure-TensorFlow code from Python.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "daZIvR0XZeX4"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def my_func(x):\n",
        "  print('Tracing.\\n')\n",
        "  return tf.reduce_sum(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XGdOJy-WZnpb"
      },
      "source": [
        "The first time you run the **tf.function**, although it executes in Python, i**t captures a complete, optimized graph representing the TensorFlow computations done within the function.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ehdyI5X3ZpxY",
        "outputId": "75a10538-1f64-4b05-fd63-526311a41826"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Tracing.\n",
            "\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int32, numpy=6>"
            ]
          },
          "execution_count": 22,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = tf.constant([1, 2, 3])\n",
        "my_func(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yNOEyofcZsZr"
      },
      "source": [
        "On subsequent calls TensorFlow **only executes the optimized graph, skipping any non-TensorFlow steps.** Below, note that my_func doesn't print tracing since print is a Python function, not a TensorFlow function. A**s we see no tracing is shown as it is using the priviously optimized graph.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G2xk6O7AZtA-",
        "outputId": "15a2974b-6148-4d18-ceb0-80facc4c2e2e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int32, numpy=27>"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = tf.constant([10, 9, 8])\n",
        "my_func(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IW05EbPIZ_Os"
      },
      "source": [
        "A graph may not be reusable for inputs with a different signature (**shape and dtype**), so a new graph is generated instead. **And we will call the function to trace this new graph.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2S6LuyiiaBg_",
        "outputId": "33507ba5-fded-4468-f220-515af0089edb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Tracing.\n",
            "\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=27.3>"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = tf.constant([10.0, 9.1, 8.2], dtype=tf.float32)\n",
        "my_func(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JAktgIFfaKw7"
      },
      "source": [
        "These captured graphs provide two benefits:\n",
        "\n",
        "- In many cases they provide a significant speedup in execution (though not this trivial example).\n",
        "- You can export these graphs, using tf.saved_model, to run on other systems like a server or a mobile device, no Python installation required."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uBn1-1Kmah-B"
      },
      "source": [
        "**Modules, layers, and models**\n",
        "\n",
        "**tf.Module** is a class for managing your **tf.Variable** objects, and the **tf.function** objects that operate on them. The **tf.Module** class is necessary to support two significant features:\n",
        "\n",
        "- You can save and restore the values of your variables using **tf.train.**Checkpoint. This is useful during training as it is quick to save and restore a model's state.\n",
        "- You can import and export the **tf.Variable** values and the **tf.function**graphs using **tf.saved_model**. This allows you to run your model independently of the Python program that created it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "UGEgBDUeajD5"
      },
      "outputs": [],
      "source": [
        "class MyModule(tf.Module):\n",
        "  def __init__(self, value):\n",
        "    self.weight = tf.Variable(value)\n",
        "\n",
        "  @tf.function\n",
        "  def multiply(self, x):\n",
        "    return x * self.weight"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cIFOVGuEa7ug",
        "outputId": "b0998ef2-da6f-4d71-e67e-33a27718e150"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=int32, numpy=array([3, 6, 9], dtype=int32)>"
            ]
          },
          "execution_count": 26,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "mod = MyModule(3)\n",
        "mod.multiply(tf.constant([1, 2, 3]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4pCIAFcBbATC"
      },
      "source": [
        "Save the Module:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RvAt4JWDbBGl",
        "outputId": "f34d7ee1-01d3-47a7-89b6-0745f5c75c6b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Assets written to: ./saved/assets\n"
          ]
        }
      ],
      "source": [
        "save_path = './saved'\n",
        "tf.saved_model.save(mod, save_path)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bVCFOSHybIWB"
      },
      "source": [
        "The resulting **SavedModel** is independent of the code that created it. You can load a **SavedModel** from **Python**, **other language bindings**, or **TensorFlow Serving**. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yKlI94eIbPtG",
        "outputId": "f80817c2-191a-4509-82f3-2a20d90ac5b0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=int32, numpy=array([3, 6, 9], dtype=int32)>"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "reloaded = tf.saved_model.load(save_path)\n",
        "reloaded.multiply(tf.constant([1, 2, 3]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pEWfAcc8bR-S"
      },
      "source": [
        "**Training loops**\n",
        "\n",
        "Now put this all together to build a basic model and train it from scratch.\n",
        "\n",
        "First, create some example data. This generates a cloud of points that loosely follows a quadratic curve:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 374
        },
        "id": "y7b0aMEKbWjo",
        "outputId": "ce98ddc2-8fe9-469e-e036-b0cd078a4c92"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 648x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "matplotlib.rcParams['figure.figsize'] = [9, 6]\n",
        "\n",
        "x = tf.linspace(-2, 2, 201)\n",
        "x = tf.cast(x, tf.float32)\n",
        "\n",
        "def f(x):\n",
        "  y = x**2 + 2*x - 5\n",
        "  return y\n",
        "\n",
        "y = f(x) + tf.random.normal(shape=[201])\n",
        "\n",
        "plt.plot(x.numpy(), y.numpy(), '.', label='Data')\n",
        "plt.plot(x, f(x),  label='Ground truth')\n",
        "plt.legend();"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gLU31_REbciJ"
      },
      "source": [
        "Create a model:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "LLeSXpiXbcAN"
      },
      "outputs": [],
      "source": [
        "class Model(tf.keras.Model):\n",
        "  def __init__(self, units):\n",
        "    super().__init__()\n",
        "    self.dense1 = tf.keras.layers.Dense(units=units,\n",
        "                                        activation=tf.nn.relu,\n",
        "                                        kernel_initializer=tf.random.normal,\n",
        "                                        bias_initializer=tf.random.normal)\n",
        "    self.dense2 = tf.keras.layers.Dense(1)\n",
        "\n",
        "  def call(self, x, training=True):\n",
        "    # For Keras layers/models, implement `call` instead of `__call__`.\n",
        "    x = x[:, tf.newaxis]\n",
        "    x = self.dense1(x)\n",
        "    x = self.dense2(x)\n",
        "    return tf.squeeze(x, axis=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "id": "9eBwAT5rbjfp"
      },
      "outputs": [],
      "source": [
        "model = Model(64)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 390
        },
        "id": "Hdrd31RsbkuZ",
        "outputId": "10bf4d7f-4cad-4f69-f9ea-171eda90b26e"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhoAAAF1CAYAAACu80M0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3yV5f3/8deVRRJWAglbgbBXEpKgiEgVBw5EFAcOHNTROlu/1tbqz9Xa1vG12urX1okDxbpw1oGCiopAIIBsCATCDCGBAIHk5Fy/P+7kmITsnJm8nw/O44Rz7nHlzjn3/bk/1zLWWkRERER8ISzQBRAREZGWS4GGiIiI+IwCDREREfEZBRoiIiLiMwo0RERExGcUaIiIiIjPKNAQaUWMMb82xuwyxhwwxnQOdHnqY4z5ozHmeW8vKyL+YzSOhkjoMMZsBroCZUAp8D3wK2vt1gasGwnsB0Zba5f5spzl+5sHvGat1cVfpBVTRkMk9JxrrW0HdAd2Af9s4HpdgWhgZWN3aBxePV8YYyK8uT0RCU4KNERClLX2MPA2MLTiNWNMG2PMY8aYLeVVJP8yxsQYYwYCa8sXKzTGfFW+/BhjzCJjzL7y5zGVtjXPGPOQMeY74BCQZIwZbIz5whiz1xiz1hhzcU1lM8Y8BJwEPFVeTfNU+evWGHOTMWY9sL78tSeNMVuNMfuNMZnGmJMqbed+Y8xr5T/3KV//qvLfb48x5u4mLhtjjHnZGFNgjFltjLnTGJPbjD+HiNRCgYZIiDLGxAKXAAsqvfw3YCCQCvQHegL3WmvXAcPKl4mz1o43xnQCPgb+AXQGHgc+rtZ2YxpwPdAeyAO+AF4HugBTgf8zxgylGmvt3cC3wM3W2nbW2psrvT0ZOJ6fA6RF5eXtVL7tt4wx0XX86mOBQcCpwL3GmCFNWPY+oA+QBJwOXFHHNkSkGRRoiISe2caYQmAfzkXyUXCqN3CCgt9aa/daa4uAv+AEBDU5B1hvrX3VWuuy1r4BrAHOrbTMDGvtSmutCzgT2Gytfal8+aXAO8BFjSz/X8vLVwxgrX3NWptfvs3/BdrgBAe1ecBaW1zezmQZkNKEZS8G/mKtLbDW5uIEWyLiA6ojFQk9k621c4wx4cB5wNflWQU3EAtkOjEHAAYIr2U7PYCcaq/l4GRBKlRuZNobOL48yKkQAbzayPJXabhqjLkD+GV5eSzQAUioY/2dlX4+BLRrwrI9qpWj3sa0ItI0ymiIhChrbZm19l2cHihjgT1AMTDMWhtX/uhY3nC0JttxgofKjgW2Vd5NpZ+3Al9X2nZcebXIr2srYn2vl7fHuBMnwxBvrY3DydSYWtb1lh1Ar0r/P8bH+xNptRRoiISo8p4g5wHxwGprrRt4Dvi7MaZL+TI9jTETatnEJ8BAY8xlxpgIY8wlOO0mPqpl+Y/Kl59mjIksf4yqo43ELpw2EHVpD7hw2n9EGGPuxclo+Np/gLuMMfHGmJ7AzfWtICJNo0BDJPR8aIw5gDMmxkPAVdbaii6rvwc2AAuMMfuBOdTS3sFamw9MBP4HyMfJLEy01u6pZfki4AycNh/bcaolHsZpU1GTJ4ELy3t21NYG4jPgU2AdTrXNYfxTjfEgkAtswjlGbwNH/LBfkVZHA3aJSKtnjPk1MNVa+4tAl0WkpVFGQ0RaHWNMd2PMicaYMGPMIJysznuBLpdIS6ReJyLSGkUB/wb6AoXALOD/AloikRZKVSciIiLiM6o6EREREZ9RoCEiIiI+E5A2GgkJCbZPnz6B2LWIiIh4WWZm5h5rbWJN7wUk0OjTpw+LFy8OxK5FRETEy4wx1acz8FDViYiIiPiMAg0RERHxGQUaIiIi4jNBM2BXaWkpubm5HD58ONBFkRATHR1Nr169iIyMDHRRRESkmqAJNHJzc2nfvj19+vTBGF/PEC0thbWW/Px8cnNz6du3b6CLIyIi1QRN1cnhw4fp3LmzggxpFGMMnTt3ViZMRCRIBU2gASjIkCbR50ZEJHgFVaARTO6//34ee+yxWt+fPXs2q1at8mOJREREQo8CjSZSoCEiIlK/kA40MnMKeHruBjJzCryyvYceeoiBAwcyduxY1q5dC8Bzzz3HqFGjSElJYcqUKRw6dIjvv/+eDz74gN/97nekpqaycePGGpcTERFp7UI20MjMKeDy5xfwv5+v5fLnFzQ72MjMzGTWrFlkZWXxySefsGjRIgAuuOACFi1axLJlyxgyZAgvvPACY8aMYdKkSTz66KNkZWXRr1+/GpcTEREJJG/fkDdF0HRvbawF2fmUuNy4LZS63CzIzie9d3yTt/ftt99y/vnnExsbC8CkSZMA+Omnn7jnnnsoLCzkwIEDTJgwocb1G7qciIiIP1TckJe43ERFhDHz2tHNuk42ldcyGsaYcGPMUmPMR97aZl1GJ3UmKiKMcAOREWGMTursk/1cffXVPPXUU6xYsYL77ruv1m6UDV1ORETEH2q6IQ8Eb1ad3Aas9uL26pTeO56Z147m9jMGeSVKGzduHLNnz6a4uJiioiI+/PBDAIqKiujevTulpaXMnDnTs3z79u0pKiry/L+25URERALBXzfk9fFK1YkxphdwDvAQcLs3ttkQ6b3jvZYGSktL45JLLiElJYUuXbowatQoAP70pz9x/PHHk5iYyPHHH+8JLqZOncp1113HP/7xD95+++1alxMREQmEihvyBdn5jE7qHJBqEwBjrW3+Rox5G/gr0B64w1o7sa7lMzIy7OLFi6u8tnr1aoYMGdLsskjrpM+PiEjgGGMyrbUZNb3X7KoTY8xEYLe1NrOe5a43xiw2xizOy8tr7m5FREQkBHijjcaJwCRjzGZgFjDeGPNa9YWstc9aazOstRmJiYle2K2IiIgEu2YHGtbau6y1vay1fYCpwFfW2iuaXTIREREJeSE7YJeIiIgEP68O2GWtnQfM8+Y2RUREJHQpoyEiIiI+o0Cjkl27dnHZZZeRlJREeno6J5xwAu+9955fy7B582aGDx9e4+uvv/56k7b5xBNPVJnkrV27dk0un4iISGMo0ChnrWXy5MmMGzeO7OxszyRrubm5Ry3rcrn8Xr66Ao36ylM90BAREfGXkJ1Uzdu++uoroqKi+NWvfuV5rXfv3txyyy0AzJgxg3fffZcDBw5QVlbGe++9x/Tp08nOziY2NpZnn32W5ORk7r//ftq1a8cdd9wBwPDhw/noI2f6l7POOouxY8fy/fff07NnT95//31iYmLIzMxk+vTpAJxxxhk1lu8Pf/gDq1evJjU1lauuuor4+Pgq5XnggQd47LHHPPu6+eabycjIYP/+/Wzfvp1TTjmFhIQE5s6dC8Ddd9/NRx99RExMDO+//z5du3b1zYEVEZFWLTgDjf/+AXau8O42u42As/5W69srV64kLS2tzk0sWbKE5cuX06lTJ2655RZGjhzJ7Nmz+eqrr7jyyivJysqqc/3169fzxhtv8Nxzz3HxxRfzzjvvcMUVV3DNNdfw1FNPMW7cOH73u9/VuO7f/va3KoHEjBkzqpRn3rx5Na5366238vjjjzN37lwSEhIAOHjwIKNHj+ahhx7izjvv5LnnnuOee+6ps+wiIiJNoaqTWtx0002kpKR45jwBOP300+nUqRMA8+fPZ9q0aQCMHz+e/Px89u/fX+c2+/btS2pqKgDp6els3ryZwsJCCgsLGTduHIBnmw1RuTyNERUVxcSJE6uUQ0RExBeCM6NRR+bBV4YNG8Y777zj+f/TTz/Nnj17yMj4eej2tm3b1rudiIgI3G635/+Vp4tv06aN5+fw8HCKi4ubVebK5alrv9VFRkZijPGUIxBtTkREpHVQRqPc+PHjOXz4MM8884zntboaUJ500kme6eDnzZtHQkICHTp0oE+fPixZsgRwqlo2bdpU537j4uKIi4tj/vz5ALVOMV99WvrqevfuzapVqzhy5AiFhYV8+eWXDV5XRETEV4IzoxEAxhhmz57Nb3/7Wx555BESExNp27YtDz/8cI3L33///UyfPp3k5GRiY2N5+eWXAZgyZQqvvPIKw4YN4/jjj2fgwIH17vull15i+vTpGGNqbQyanJxMeHg4KSkpXH311cTHV53u95hjjuHiiy9m+PDh9O3bl5EjR3reu/766znzzDPp0aOHpzGoiIiIP3hlmvjG0jTx4m36/IiIBI5Pp4kXERERqY0CDREREfEZBRoiIiLiMwo0RERExGcUaIiIiARQZk4BT8/dQGZOQaCL4hPq3ioiIhIgmTkFXP78AkpcbqIiwph57WjSe8fXv2IIUUajXE3Ts99///089thjda6XlZXFJ5980uj9bd++nQsvvLDR69Vk3rx5niHFfany8bj33nuZM2dOrctWPy4ffPABf/ub/0d8FREJZguy8ylxuXFbKHW5WZCdH+gieZ0CjWaqK9Coa2jvHj168Pbbb/uqWA1mra0ydHlDPfjgg5x22mm1vl/9uEyaNIk//OEPTSqjiEhLNTqpM1ERYYQbiIwIY3RS50AXyesUaDTQySefzO9//3uOO+44Bg4cyLfffktJSQn33nsvb775Jqmpqbz55pvcf//9TJs2jRNPPJFp06axefNmTjrpJNLS0khLS+P7778HqmZQZsyYwQUXXMCZZ57JgAEDuPPOOz37/fzzzznhhBNIS0vjoosu4sCBAwB8+umnDB48mLS0NN59990ayzxjxgzOO+88Tj75ZAYMGMADDzzg2fegQYO48sorGT58OFu3buXRRx9l1KhRJCcnc99993m28dBDDzFw4EDGjh3L2rVrPa9fffXVnkBp0aJFjBkzhpSUFI477jj27dt31HGZMWMGN998s2f/48ePJzk5mVNPPZUtW7Z4tnnrrbcyZswYkpKSPNvfsWMH48aNIzU1leHDh/Ptt982/w8qIhIE0nvHM/Pa0dx+xiDfVpsczIeFz0EABukMyjYaDy98mDV713h1m4M7Deb3x/2+WdtwuVwsXLiQTz75hAceeIA5c+bw4IMPsnjxYp566inAqV5YtWoV8+fPJyYmhkOHDvHFF18QHR3N+vXrufTSS6k+Kio4GYClS5fSpk0bBg0axC233EJMTAx//vOfmTNnjmc49Mcff5w777yT6667jq+++or+/ftzySWX1FrmhQsX8tNPPxEbG8uoUaM455xzSEhIYP369bz88suMHj2azz//nPXr17Nw4UKstUyaNIlvvvmGtm3bMmvWLLKysnC5XKSlpZGenl5l+yUlJVxyySW8+eabjBo1iv379xMbG3vUcZkxY4ZnnVtuuYWrrrqKq666ihdffJFbb72V2bNnA05QMX/+fNasWcOkSZO48MILef3115kwYQJ33303ZWVldc5BIyISatJ7x3s9wMjMKWBBdj6jkzqTfkwHeGc65PwA/cZD535e3Vd9gjLQCISK2Uzrev2CCy4A6p9afdKkScTExABQWlrKzTffTFZWFuHh4axbt67GdU499VQ6duwIwNChQ8nJyaGwsJBVq1Zx4oknAs5F/YQTTmDNmjX07duXAQMGAHDFFVfw7LPP1rjd008/nc6dO3vKP3/+fCZPnkzv3r0ZPXo04GRNPv/8c8/8KAcOHGD9+vUUFRVx/vnnExsb6/m9qlu7di3du3dn1KhRAHTo0KHW41Lhhx9+8GRhpk2bViWDM3nyZMLCwhg6dCi7du0CYNSoUUyfPp3S0lImT55MampqvfsQEWmtqjcwnTvyW7pnz4NJ//R7kAFBGmg0N/PQFJ07d6agoGrXor1799K3b1/P/yumea9vavXK07f//e9/p2vXrixbtgy32010dHSN61SfQt7lcmGt5fTTT+eNN96osmxWVlaDf6/qAVTF/yuX0VrLXXfdxQ033FBl2SeeeKLB+/GWysehYh6ecePG8c033/Dxxx9z9dVXc/vtt3PllVf6vWwiIqGgcgPTX7gX0n3505B2pfMIALXRKNeuXTu6d+/OV199BThBxqeffsrYsWPrXK++Kdj37dtH9+7dCQsL49VXX6WsrKzBZRo9ejTfffcdGzZsAODgwYOsW7eOwYMHs3nzZjZu3AhwVCBS2RdffMHevXspLi5m9uzZnuxIZRMmTODFF1/0tP/Ytm0bu3fvZty4ccyePZvi4mKKior48MMPj1p30KBB7Nixg0WLFgFQVFSEy+Wq87iMGTOGWbNmATBz5kxOOumkOo9DTk4OXbt25brrruPaa69lyZIldS4vItKaVTQw7Re2g8cinuFgQjKc9WjAyqNAo5JXXnmFP/3pT6SmpjJ+/Hjuu+8++vWrO810yimnsGrVKk+jx+puvPFGXn75ZVJSUlizZk2VTEJ9EhMTmTFjBpdeeinJycmeapPo6GieffZZzjnnHNLS0ujSpUut2zjuuOOYMmUKycnJTJkyhYyMoyfXO+OMM7jssss44YQTGDFiBBdeeCFFRUWkpaVxySWXkJKSwllnneWpHqksKiqKN998k1tuuYWUlBROP/10Dh8+XOdx+ec//8lLL71EcnIyr776Kk8++WSdx2HevHmkpKQwcuRI3nzzTW677bYGHkERkdYnvXc8b1yVzH/i/o+Y6GjaXjGTzO3FARsUTNPEt2AzZsyo0iCzJdPnR0RCTZUGm95sDGotvHMtrHwXrniHzIiRPh8UrK5p4oOyjYaIiEhL5tMRQX/8F/z0Npx6L/Qbz4K5G44aFMyfo4+q6qQFu/rqq1tFNkNEJNT4bETQnO/h83tg0Dlw4m+BwA8KpoyGiIiIn1Vc/Etdbu9d/It2wltXQ9yxcP4zEObkEioGBfNJNU0DBFWgYa2tdTwLkdoEop2RiEhzeP3iX1bqBBlHimDabIjueNT+AjVZW9AEGtHR0eTn59O5c2cFG9Jg1lry8/NrHZ9ERCRYefXi//n/gy0/wJQXoOtQ72zTS4Im0OjVqxe5ubnk5eUFuigSYqKjo+nVq1egiyEi4lcVvVbOYj5JPz4Dx/8aRnhnVnBvCppAIzIyssoonCIiIlKzil4r/cuymR55P0XdRtH+jD8Fulg1Uq8TERGRELMgO592rkL+Ffk4hbTjraSHIDwy0MWqkQINERGRIJOZU1DnSJ6j+3Tgqah/ksg+bnH/DymDB/q5hA0XNFUnIiIi0rDBvNLXPA5mJXMGPcBdYy4PWI+ShlCgISIiEkRqGsyrSiCR9QaUN/487azfBK6gDaSqExERkSBS50ie25bg/vBWcuMyyBx8e+AK2QjKaIiIiASRWgfzOrCbkpmXkefqwORd13LgxUxmXjsaIGCjfjaEAg0REZEgc9RgXq4S+M+VmMN7uaH0PvbYDoS73LyzJJd3l+T6dGbW5lLViYiISLD77C7Y8gNbT3qEDeFJnmoVA76ZnM2LlNEQEREJZpkvw6LnYcytJJ1yNTOTCjxVJQDvLMn17uRsXtbsQMMYcwzwCtAVsMCz1tonm7tdERGRVm/rIvjkDug3Hk67Hzi6WiWQM7M2hDcyGi7gf6y1S4wx7YFMY8wX1tpVXti2iIhI67RvG8y6DDr0IOv4x/nu6001BhOBnJm1IZodaFhrdwA7yn8uMsasBnoCCjRERCSkVUxc5vdsQckhmHUplBaz8vTXmPrqmqBu8FkXr7bRMMb0AUYCP9bw3vXA9QDHHnusN3crIiLidQ0ZodMnrIXZv4Ydy+GyN5m3rTMlrj21D+AV5LzW68QY0w54B/iNtXZ/9fettc9aazOstRmJiYne2q2IiIhP1DRCp198/Qismg2nPwADJ9Q9gFcI8EpGwxgTiRNkzLTWvuuNbYqIiARSxQXerz06Vr0P8/4CKZfCmFuBOgbwChHGWtu8DRhjgJeBvdbaBg26npGRYRcvXtys/YqIiDRUU9taeKuNRoO2s2MZvHgmdB0OV30IkdFN3p+/GWMyrbUZNb3njYzGicA0YIUxJqv8tT9aaz/xwrZFRESapTltLbzRo6NB+y/aBW9cBjGd4JLXQirIqI83ep3MB4wXyiIiIuJ19c6G6uf9v7Mkt2p2o/QwvHk5FO+F6Z9C+65+K5s/aGRQERFp0QLS1qKW/YeHGd7OzMVVVp7d+OXxpC/9I+Qugotehu4pfi2bPyjQEBGRFi3QjSkr7397YTFvLNziyW4c/uYJyH4DTv4jDJvs13L5iwINERFp8QI9embF/jNzCjxzk5wWkcWY7H/AsPPhF3cGrGy+pkBDRETETyqyG+uXL+CiZU9jEpPhvP8D03KbOirQEBER8aP0TiWkr78DYjrApbMgKjbQRfIpBRoiIiL+UnII3pj6cw+TDj0CXSKfU6AhIiLiD243vHcDbF8KU19vkT1MaqJAQ0RExB++ehBWfwAT/gKDzw50afxGgYaIiIiPVAw9fo7rS/p893fImA6jb6xz2VCcz6QuCjRERER8oGLo8bSyFVwf+Tf29TyJjmc9UmMPk4BNSe8HXpsmXkRERH62IDufnmW5PBP5dzbZbvyn758gPLLWZQMyJb0fKNAQERHxgRN7GF6MfJRSIvi1/T1pA/vUumzFMOXhhiYPk56ZU8DTczeQmVPQjFJ7n6pORERE6tHo9hOuI6R+dxPuiALeTX6WR1JPrnO95g6THsxVLwo0RERE6tDoi7i18MEtsOUHwi58kQuHn9+g/TRnmPRAz1BbF1WdiIiI1KHR7SfmPgTL34RT7oHhU/xSRm9UvfiKMhoiIiJ1aNQ085kz4JtHIe1KGHeH38oY6Blq62KstX7faUZGhl28eLHf9ysiItIUDWqjsf4LeP0S6HeKM4dJLT1MWiJjTKa1NqOm95TREBERqUe97Se2Z8F/roKuw+CiGa0qyKiP2miIiIg0R0EOvH4xxHaCy9+CNu0DXaKgooyGiIhIUxUXwMyLwHUYrvwA2ncLdImCjgINERGRpnAdgVmXQ8EmmPYedBkc6BIFJVWdiIiINJbbzd6Zv4Sc78ge+yj0GeuT3QTraJ+NoYyGiIhII+187y66bfqQh11TeemrrsxMKvB6l9JgHu2zMZTREBERaYxFz9Ntxb94rew0nnGd67NJ0FrKRGsKNEREpFVrVPXE6o/gk99ReMyp/JVrCDfGZyNxBvNon42hqhMREWm1GlU9sfk7eHs69EgjbtqrvLKjxKcjcQbzaJ+NoUBDRERarQZPRrZrJbxxKcT3Jmvcc3z33Q5GJ3XmplP6V1ms0bO81qM5E60FCwUaIiLSajVoHpPCLfDaFIhqy/JTXmLqa2trzIC0lMab3qY2GiIi0mpVVE/cfsagmgODg/nw6gVQegiueIdvd0fX2kCzcnakpNTNE3PWhXS3VG9RRkNERFq1WqsnSg7C6xfBvq3OgFxdhzL6cEGtGZCK7EhJqRs38N2GPSzavLfVZzaU0RAREamurNSZJG37UrjwReg9Bqg7A1Lx3okDEggzhHy3VG9RRkNERKQytxvevxk2fAHn/gMGn1Pl7eoZkOoNQH9z2kAWbd5bd7uPVkSBhoiISGVz7oPls+CUeyD9qjoXra0BaEvoluotCjREREQqfP8UfP8PGHUdjLuj3sVr6x7bErqleovaaIiIiAAsmwWf3w1Dz4OzHgZj6l2lpYze6UvKaIiIiKz5GGbfCH1/Aec/C2HhDVpN1ST1U6AhIiKtW/bX8NbV0GMkTH0dIqMbtbqqSeqmqhMREWm9cjOdocU794fL34I27QJdohZHgYaIiLROu1bBzCnQLtEZkCu2U6BL1CIp0BARkdZn7yZ49XyIiIYr34f23QJdohbLK4GGMeZMY8xaY8wGY8wfvLFNERGR5srMKeDpuRuqzjmyfwe8OhnKjjiZjPg+AStfa9DsxqDGmHDgaeB0IBdYZIz5wFq7qrnbFhERaaoaB9NKtE4m4+AeuOoD6DIk0MVs8byR0TgO2GCtzbbWlgCzgPO8sF0REZEmqz6YVua6LTDzQtibDZe+AT3TA13EVsEbgUZPYGul/+eWv1aFMeZ6Y8xiY8zivLw8L+xWRERaoxqrQ2pQeTCtthEupmb/AbZnwUUzoO84/xRW/DeOhrX2WeBZgIyMDOuv/YqISMtR29wiNakYTGvhhp1cuvluOmz9Hs7/Nww+u87ta/At7/JGoLENOKbS/3uVvyYiIuJVtc0tUpv0Xu1JX3ArbP0SznkcUqbWumxjghhpOG9UnSwCBhhj+hpjooCpwAde2K6IiEgVjZpbxF0Gs38Nqz+ACX+FUb+sc9s1BTHSfM3OaFhrXcaYm4HPgHDgRWvtymaXTEREpJoGzy3idsOHt8GK/8Cp98IJN9a77YogptTl1gRpXmSs9X9ziYyMDLt48WK/71dERFoBa+GTO2DR8zDuThh/d4NX9VUbDWstZbbMebidZ7d143K7cFv3Ue95nhuwXJXXK73msi7c7vJn66bMXcalQy6lTXgbr/1eFYwxmdbajJre06RqIiJSJ7d1U3ikkD3Fe9hzaA/5h/M5UnYEAIul4obV84wlZ+9BNu85SO/OsRzTKcbzfpXlsVVer7y9iv9XX6/ycs4/W3U71mKz58K2xbiHn0pZ+zaULXqkysW9+oW8yoW5/IKctbaMsjUNDAps2VEXdM865a+5rdvXf6YGmdx/sk8Cjboo0BARCWK+7AVxpOwIe4r3kHcoj/zifOfn4jwnoCh/5BXnsbd4Ly7ratI+5tfdA9XrDGCsxcTFEVa8mfC1WwkzYYSHhRNuKj3CwgkzYUSERTjvV3q94ueK96NMVO3rm4gq26+8zervVd5+vfsO+3n96stVea2B5ap4jo2I9e8fBAUaIiJBqym9IKy17Duyr9agIb843/N6UUnRUesbDJ2iO5EYm0jnmM4MiB9AQkyC55EY47xecVdsMBhjPM8AL323mWfmbcRaCDOGG0/uzy/HJnner1i++vqeMlTaXuXlnH+VXqu2X755DL76E4ycBuf+A8I0nVcwUKAhIhKkqveC+GFjHr0SSth+cDvbDmxjW9E2dh3adVQA4XIfnX2IDo92AoXYRPrH9Wd099FVAofEmEQSYhKIj44nIqx5l4bxA8J54es8SsucRpUnD+hLXHRcs7ZZl8ycAoq/fpKx2X+HERfBuU8qyAgiCjRERIKEtZb8w/meIGJP+Eaiu5Zj2TsAACAASURBVC+DiL2ERRbwQu4+/r21tMo68W3iSYh1Aoa+HfselXmoCCDaRrb9+c7fxxrcM8QLMnMK+PiFB7g37CU+s8eRkPZX0sPCfbY/aTwFGiIifmKtZe/hvWw/sJ1tB7c5z0XbPD9vP7Dd08iyQlxCHNEmgT4dRzC8ax96tu1Jj3Y96Nm+J93bdicmIiZAv03d0nvH+2WwqwPfPsO9YS/xRVkat7lu5pbN+0jvm+jz/UrDKdAQEfGSivYR2w46GYntB8qrOA6UBxIHt1PsKq6yTsc2HenZrif94/ozruc4erbvSc92PenRtgc92vUgNtL/jfdCxsLn+MWGh/nKpnOr61aIiNLYF0FIgYaISCNYa9lTvIeN+zaSXZjNlqItVbISB0sPVlm+fVR7erbrSe8OvRnTc4wniOjZ3nluF9UuQL9JiFv4nDNWxsCziBv9BDfnHND8JEFKgYaISA3c1s2OgzvYWLiRTfs2sbFwI9n7sskuzKao9OfeGrERsZ4sxHHdjvMEET3bOVUcHaI6BPC38D+/TEq26PnyIONMuPhl0iLakJbk3V1ocjXvUaAhIq2ay+1ia9FWTxCRvS+bjYUb2bx/c5Vqjk7RnegX14+zk84mqWMS/eL6kdQxiYSYBL81sgx2fpmUbNHz8PH/lAcZr0CE9wef0uRq3qVAQ0RahVJ3KZv2baoSTGTvyyZnfw6l7p97cnRr241+HfuR3jXdE0wkdUzyaffMQPPW3XtjZ1ZtND8EGeCH36OVUaAhIi3OYddh1hesZ/Xe1c4jfzXrC9ZT4i4BIMyE0atdL5I6JjGu1zhPhqJvx760jWwb4NL7lzfv3n06KdmiF5wgY8CEBgUZzQmeNLmadynQEJGQdqDkAGv2rmH13tWs2buGVfmr2LRvE2W2DIAOUR0Y0mkIlw25jEGdBjEgbgC9O/QmOiI6wCUPDt68e/fZ+BmLXoCPb3eCjEtebVCQ0ZzgyZ/jgLQGCjREJGTsPbyXNflrWLV3lRNc5K9mS9EWz/uJMYkM7jSY8ceOZ0inIQzpPIQebXuoDUUdvH337vXxMxoZZIB3gid/jQPSGijQEJGgc9h1mM37N7OhcAPZhdmeapBdh3Z5lunZridDOw/lvP7neYKKhJiEAJY6NDX07r2pVRHNav/xw//BZ3fVGmTUtm1VfQQXUzFdrz9lZGTYxYsX+32/IhJcDpUeYvP+zWws3Og89jnPuUW5nqm/I0wEx3Y4liGdhzgBRachDOo0iI5tOga49K1HU6simlWF8e3j8OUDMORcmPIiREQ1atsNCXDUhdV7jDGZ1tqMmt5TRkNEfKpi/o5N+zZVeWTvy2bHwR2e5SLCIujToQ9DOg1hYtJE+sX1o1/HfvTu0JvI8MgA/gbS1KqIJq1nLcz7G3z9Nxh+IZz/bwg/+lJV37brq/pQF1b/UaAhIk1W5i5jX8k+Co8UUnC4gLxDeew+tJu8Yuc590Aum/ZtqjIdeUxEDH079iWtaxp9O/Slb8e+9I/rzzEdjiEyTAFFMGpqVUSj17MW5twH3z0JqZfDpH9CLROkNbd6RF1Y/UeBhogAzkiYRSVFFBwu8AQOhUcKKTjiPBceLv/5cKHn9f1H9nuqOCprE96GxJhEurfrztl9z6ZvRyegSOqYRJfYLoQZTeEdSpraC6NR61kLn/4BfvwXZEyHs/+3zqnem9szRO04/EdtNESaodhVTMHhAlxuFy7rwuV2UeZ2ulWGmTDCTThhYeXP5f+PCIsgKiyKqPAoIsMjiTARzeoVYa1lf8l+8g7lkXsgl61FWykqKeJw2WEOuyo9ymp5rvRzTUEDQGRYJPHR8cS3iScuOs55bhNHfPTPzx3bdKRLTBcSYxPpENVBPT2k4dxu+Pi3kDkDRt8IE/4Cfvj8qI2G96iNhkgTlLnL2H1oNzsO7mDnwZ3sPLSTHQd2sPPQTuf/B3dSeKSw2fsxGKLCo4gKcwKPip+jwqOIDIv0PIeZMIwxhBFGmAnjQOkB9hTvYU/xnqOmFgcnqxAdEU2b8DbERMQQHR5Nm4g2xITH0CG2g+f9mIgYz89xbeI8gUPloCImIkaBg/iGuwzevxmWvQ5jb4dT7/VLkAHqwuovCjREgH1H9rG+YD3rCtZ5HhsKNxw1pXf7yPZ0a9eNbrHdGJEwgu5tu9M5pjORYZFEhEUQbsIJL69Tdls3ZbYMt9t5tljK3GWUukspKSvxPJe4SygtK6XEXeL8v4bXSt2luNwuLBa3deO2bmIjYxnZZSQJMQkkxCTQJbYLPdv15Jj2x9CxTUdVT0jwKyuFd6+Hle/CyX+EX9zptyBD/EeBhrQqLreLLUVbWLf354BibcFadh7c6Vkmrk0cg+IHMWXAFJLikujetjvd23anW9turW54ahGfKT0Mb0+HtR/DaQ/A2N/UuJiqN0KfAg1psQ6UHGBV/qoqAcXGwo2eaoYIE0Gfjn1I65LGwPiBDOo0iIHxA0mMSVQ1gYgvHSmCWZfBpm/grEfg+BtqXExdUFsGBRrSYuw+tJslu5ewdNdSluxewrqCdbitG3Cm+B4YP5Cpg6YysNNABsYPJKljElHhUfVsVUS86tBemHkhbM+Cyf+C1EtrXbRyF9SSUjdPzFnHb04bqGAjxCjQkJBU6i5lQ8EGsvKyyNqdxbK8ZWw7sA1wxmlITkzmhuQbSElMYVCnQRqaWiQY7N8Br54Pe7OdIcUHnwNUrR4BPD9XdEEtKXXjBr7bsIdFm/cqsxFiFGhI0Cpzl7Hj4A627N9CTlEOOfudx5b9W9h+YDsu6wKcibRSu6Ry2eDLSOuaxqBOgzTwk0iw2ZsNr0yGQ/lwxdvQdxxQtXokIsyAMbjKfq4qmXntaJ6Ys47vNuzR4FohSoGGBIVSdylr8tewdPdSsvKy2FC4gdyiXErdpZ5lYiJi6N2hN4M7DWZCnwn0j+tPapdUurftrjYVIsFs10onk1FWAld+AL3SPW9VGaGzzEL5aC4VAcVNp/TnN6cNZNHmvRpcK0Qp0JCA2HdkH8vylrF091KW7l7Kyj0rOVx2GHBm5RzcaTAnH3Myvdv35tgOx9K7Q2810hQJRVsXOW0yImPgmv9ClyFV3q48Qmd4eUajrKxqQNHcUUAlsDQyqPictZYtRVucbMXuLJbuXkr2vmzA6fkxuNNgUrukktollZFdRtIltkuASywiFZrVvXTjXJh1ObTrAlfOhvg+9e4DUEARgjQyqPhVSVkJq/JXebIVy/KWsffwXgDaR7UnNTGViUkTSe2SyvCE4cRExAS4xCJSk2Z1L131AbzzS+g8AKa9C+271bpo9RE6FWC0LAo0pNmKXcUsy1tG5q5MFu9czPK85ZS4SwDo3aE3Y3uOZWSXkYzsMpK+HftqxEqRENHkGU4XvQCf3AE90+Gy/0Bsp0bvWwN1tRwKNKTRCg8XsnzPcpbsWkLmrkx+yv8Jl9tFmAljcKfBTB08lbSuaaQmptI5Ro22REJVk6Z5n/dX+PphGHAGXDQDoho/mq4G6mpZFGhIncrcZWwo3MCyvGUsy1vG8rzlbN6/GXDaVwxNGMqVQ68ko2sGI7uMpF1Uu8AWWES8pqGNMDNzCvhx4y4u2vl3EtfNgtQr4NwnILxp3cybnEmRoKRAQ6qoyFZk7c5i+Z7l/LTnJw6WHgQgvk08KYkpnNf/PFISUxjWeRixkbEBLrGI+FJ9M5xm5hTwy+e/5jGeJDF8CTuSb6b7eX9u1uRojc6kSFBToNGK1ZWtCDfhDIwfyMSkiaQkppCamEqv9r3UvVREqli6diMvmD8z0mzg3tJr6Bp/DTc18zzh6+6sav/hXwo0WpEq2Yq85azYs4JDrkOAMxdIcmKyshUi0nCFW7h85fWEmS3c5LqNuWGjmdmA7ENDLvT1ZVKaSu0//E+BRgvVkGzFuf3OVbZCRJpm10p4bQoxpYdYe/ZMhh/qx7UNyBAE+kKv9h/+p0CjhdhTvIcVeStYsWfFUW0rlK0QEa/aPB/euMzpUXLNpwzqOpRBDVw10Bd6tf/wPwUaIehI2RHW7F3jVH/kOYFFxcylESaCAfED1LZCRHxj+Vvw/o3QKQmueAc69mrU6oG+0Gs4c/9r1hDkxphHgXOBEmAjcI21trC+9TQEecNZa8ktymXZnmVOUJG3nDUFa3C5nZlLu7XtxoiEEaQkpjAiYQRDOg/RSJsiQaTFNDy0Fr55DOb+GXqPdaZ5b8JAXNCCjol41DUEeXMDjTOAr6y1LmPMwwDW2t/Xt54CjdrtL9nPT3k/sXzPcpbnOVUgBUcKAGf20mGdh5GcmExyQjIjEkdoXhCRIBbo9ghe4yqBj34LWa9B8lSY9E+IiAp0qSSI+GyuE2vt55X+uwC4sDnba21cbhfrC9Y77SrylrN8z3I27dsEgMGQ1DGJk485mRGJI0hOSKZfXD8iwlTbJRIqAt0eAbyQPSguhP9Mg03fwMl3wS9+36wxMnxN2ZLg482r1nTgTS9ur8XZeXAnK/asYEXeCpblLWP13tUUu4qB8gabCclMTJrIiIQRDE8YTvuo9gEusYg0R6DbIzQ7o1KQA69fDPkbYfK/IPVS3xXWC1pMBqmFqTfQMMbMAWqadu9ua+375cvcDbiAmXVs53rgeoBjjz22SYUNJYdKD7Eqf1WVbMXuQ7sBiAyLZEinIUwZMIURCSNITkymZ7uearAp0sIEuuFhszIq2zLh9alQdgSmvQd9T/JtYb0gGDJIcrR6Aw1r7Wl1vW+MuRqYCJxq62jwYa19FngWnDYajStmcHNbN5v3bfa0q1ixZwXrC9ZTZssA6NWuFxldMzxtKwZ1GkRUeMut31TqUuRnvhp4qiGanFFZ/RG8cy206wJXfwSJDe28GliBziBJzZrbGPRM4HHgF9bavIauF+qNQQ+VHmLp7qUs3b3U02CzqLQIgHaR7RiRMMLTrmJE4gg6RTetZXYoUupSmkLBqe806thaCwuegc/+6EzxfuksaJfon4J6iT5LgeGzxqDAU0Ab4IvytP8Ca+2vmrnNoFMRWCzauYhFuxaxcs9KymwZYSaMgfEDObPvmZ4upn069iHMhAW6yAGj1KU0loJT32pwRsVVAv/9HWTOgCGT4Px/Q1ToDewXyAyS1Ky5vU76e6sgweRg6UFPYLF452JW5juBRYSJYHjCcKYPn05GtwxSE1M1wmY1Sl1KYyk4DQIH8+E/V0LOfBh7O4z/fxDWem+YxLvUVxIodZeStTuL77Z9x6Kdi34OLMIiGJEwgunDpzOq2yhSElMUWNQj0I3fJPQoOA2w3avh9UugaCdc8BwkXxzoEkkL06w2Gk0VDG00dh7cyfxt85m/bT4LdizgYOlBIkwEyYnJpHdNV2Ah4keqVw+QtZ86jT6jYmHq69Crxip2kXr5so1GyCgtK2XJ7iWe4GJD4QbAGcL7rL5nMbbnWI7vdjztotoFuKQirY/q1f3MWvj+H/DFfdA9Gaa+AR17BrpU0kK16EBjx4EdfLvtW+Zvm8+PO37kkOsQEWERpHdNZ3L/yZzY40T6xfXT+BUi0nq4jsCHv4Flr8PQyTD5mZBs9Cmho0UFGiVlJWTuyvRkLbL3ZQPQo20PJiZNdLIW3Y9XdYiItE4HdsObV8DWH+HkP8Iv7gzq4cSlZWgxgcah0kOMf2s8B0sPEhkWSUbXDKYMmMLYXmPp26GvshYi0rptz3KCjIN74KKXYdhkv+5e7XBarxYTaMRGxnLdiOvoH9efUd1GKWshIlJh2Sz48DaI7QzTP4UeqfWu4s3AQGOltG4tJtAA+OWIXwa6CCIiwaOsFD6/B378F/Q5CS58qUEjfXo7MNBYKa2bRmQREWmJDuyGV85zgozRN8G02Q0eTrymwKA5KsZKCTdUGSslM6eAp+duIDOnoFnbl+DWojIaIiIC5C6GN6dBcQFc8DwkX9So1b09iFpNA/mpOqX1UKAhItKSZL4Mn9wB7bvDtV9AtxGN3oQvRvitPlaKqlNaDwUaIiItgesI/PdOZ1K0fuNhygsQ2/SZo309iJqGnm89FGiIiIS6/dudSdFyF8HY35ZPihYe6FLVSfMitR4KNEREQtnGr5z5SkoPVxkfIxTGrdDQ862DAg0RkVDkLoOvH4GvH4bEwXDxK5A4kMycAt5Zksvbmbm4ytTQUgJPgYaI+F0o3G0HtQN58O61kD0PUi6Fc/4Xotp6enIcKXVTMS+3GlpKoCnQEBG/UrfGZsr5Ht66Bg4XwqSnYOQVnvlKKnpyVAQZBtTQUgJOgYaI+JW6NTaR2+1M7f7lgxDfB654+6iuq5V7coSHGS7KOIYL0nrp+EpAKdAQEb9St8YmOLQXZt8I6/7rTO0+6Z8Q3eGoxfzdk0NVYNIQxlpb/1JelpGRYRcvXuz3/YpIcGjMBSpQF7OguYjmZsJbV0PRDpjwFzjuOk9VSSDLqCowqcwYk2mtzajpPWU0RMTvGtqtMVAXs6C4iLrd8N0TMPchaN8Dpn8GvdKDpoyqApOG0qRqIhK0vD25V7DvF5wA4qVPf2D/cxPhywdg8ET41bdVgoxAlxFqnyhNpDplNEQkaAWqPUeg9puZU8Bzzz/NQ2H/IoISNo99mD6n3eCpKgmGMlbQyJ7SUGqjISJBpXq7g1bTRqP0MMtm3EbKtlmscvfmNtfNTD59PDed0j94yihSC7XREJGQUFu7g0BcRP2637y18PYvSdm1gpfdZ/G30kuwEdH1Zik0hLeEAgUaIhI0WlIDwwZlG6yFJa/Af38PUbFw6ZsMjz6em5WlkBZEgYaIBI1Atzvwlgb1CDmYDx/9BlZ/AH1/Aef/Gzp0Jx08VUZPz92ggENCngINEQkaLaWBYb2ZmXWfwfs3Q3EBnHY/jLkNwn7uBBjIrqtq9yHepkBDRIJKS2h3UGtm5sgB+OyPsORl6DIMpr171DDi4JsqpIYEEIEem0NaJgUaIuI3/rxbDuSdeY2ZmS0L4L0boCAHxtwK4++BiDY1ru/tKqSGBhAtqY2MBA8FGiLiF/68Ww6GO3NPZsZ1BObcD989CR17wTWfQO8x9a7rzSqkhgYQLaWNjAQXBRoi4hf+vFsOmjvzXSvh3eth108wchqc+Vdo075Bq3qzCqmhAURLaSMjwUWBhoj4hT/vlgN+Z17mgh+ecuYpie4IU9+AwWf7twyVNCaAaAltZCS4aGRQEfGbVtFGY9cqeP8m2L7Emafk3CehbYL/9i8SABoZVESCgj/vlv1+Z15WCvP/Dl8/AtEd4MIXYdgFNc5T0twgSF1QJZQo0BARaa4dy2D2TbBrBQyfAmc9UmsWo7kNVYOhoatIY2iaeBGRpnIdgS//BM+eAgd3wyUznUxGHVUlzZ3ePdDTw4s0ljIaIq2IUu7ekZlTwKaseZyT/Wdi9m2A1Ctgwp8hpv5j2tyGqt5o6KrPgfiTGoOKtBJKuXvH0g25ZL1yJ1eaT9hFJw5OeJwBYyY3ahuBbKOhz4H4ghqDikjwjC0RytZ8Qv/3fsPIsF285jqVR8su5fojw9nfyAt/cxuqNmd9fQ7E37wSaBhj/gd4DEi01u7xxjZ9TalDaW0CPrZEKNuX60zlvuYjIuIGcemhG1lYNoDIiDDiY6NCKkOgz4H4W7MDDWPMMcAZwJbmF8c/lDqU1kijPjZBmQsW/hvm/gXcZXDa/cSccDN35B7wHMfGZAiC4QZHnwPxN29kNP4O3Am874Vt+YVSh9JaadTH+lUEA+Pb5zJk8f+DncthwBlw9qMQ3wc4+jg2JEMQTDc4+hyIPzUr0DDGnAdss9YuMzUMShOslDoUkZpk5hRww/NfcStvMChsDiWxiURd9DIMPa/Ggbeg4RkC3eBIa1VvoGGMmQN0q+Gtu4E/4lSb1MsYcz1wPcCxxx7biCJ6n1KHIi2DV6sirGXvD6/ycdj/ksg+XnOfzpG0P3LdsJH1rtqQDIFucKS1anL3VmPMCOBL4FD5S72A7cBx1tqdda2r7q0iLUMg2xx4tSpiexb8907Y+iMrbBL/r/Qa1oQP8Hr1hq+OVzC0/ZDWzSfdW621K4AulXayGcgIlV4nItI8gW5z4JWqiIN74Ks/QebLENsZJj1FSaezOX1TAf/PBxdtX7SNCPTfQaQ+GkdDRJok0G0OmlUVUeaCxS8407gfOQCjb4Rf3AkxcaQD6X1Cp1oj0H8Hkfp4LdCw1vbx1rZEJPgFus1Bk9tabfrGGRNj9yro+wtnArQug31bWB9qzt9BVS7iDxqCXESarKYLVdBevAo2wxf3warZEHcsTPgLDJ5Ya2+SUNKUY64qF/EmDUEuARW0Fx5ptuptDoLy4lVcAN88BgufBRMOJ/8RTrwVImMCWy68991oStsPVbmIvyjQ8CFdYIP0wtMCBOtnK6guXq4jsOh5+PoROLwPUi+H8XdDhx6BKU81gf5uBLrqS1oPBRo+EuiTSLAIqgtPCxHMn62guHhZCyvfgzn3Q2EO9BsPpz8I3Ub4vyx1CPR3Q+MJib+0qEAjmO7yAn0SCRZBceFpYYL5sxXwi1fOD/D5PbBtMXQZBle8A/1P828ZGigYvhtN7W4bTOdaCX4tJtAItru8YDiJBIOAX3haIF9/tpp7EQnIPBp5a+HLB2HNR9C+O5z3NKRcCmHhzd60ry6qofrdCLZzrQS/FhNoBNtdXqieRHxBEzh5ly8/W6FyEam4+I9LPMiI9c/A8jchMhZOuQdOuBGi2nptP748HqH43Qi2c60EvxYTaARjBiEUTyISGnz12QqFi0hmTgG3P/8xN/Aug8Pm4Y6IIOyEm+DE30DbhBqXb2pQFgrHw9+C8Vwrwa3FBBrKIIg0XzBdRGoMEA7kEf75fXwe9h8Mbma5x+Ma9T9cc8YJtW6jORmJYDoewULnWmmsFhNogDIIIs1V+SISHxvFgux8z+v+VD1AmDVtCKlbX4EF/yLFVcy7dhxPlp7P7oiuzBxS+6iezc1I6KJaM51rpTFaVKARCGp9LS1Nxec4GCZMa28PMN1+ypA3P4eyAzB8Cubku+hzMIFLavneVf5OeiMjoYuqSPMo0GiGUGk4J62LN4LfQLdNGNvdTWTkLC4zn9POHKag5xm0Ofs+6DYcgPSEmrMsNX0nfZmR0I2GSP0UaDRDoE/GItV5K/gNWNuEfdvg+3+QkjmD5PAS1ieeTukJv2XYyJrbYFRX03fyplP6++R7qRsNkYZp0YGGr+821FBMgo23gl+/t03Yuwm+ewKWzgQsJE/FjP0tAxP6N2oz/vxOBuJGQxkUCUUtNtDw9d1GxRf+3onDKDhUElRffJ2MWi9vXmj90jZh9xqY/3dY8ZYzuFbalXDibRDfu0mba2qA1JTvjL9vNJRBkVDVYgMNX95tBOIL39AToU5GrVtI9JKwFjZ9Dd8/BRu+cAbaGv1rOOFm6NC92ZuvK0CqbVr7pnxn/H2sVVUroarFBhq+vNvw9xe+MSdCnYxCVyCnDPdHuXCVwE/vwA9Pw64V0LaLM5JnxnRo6/tqx9q+R835zvizR4qqaiVUtdhAw5d3G/7+wjfmRKiTUWgK1kxU9XI1qaqwuAAWvwQLn4WiHZA4GCY9BSMugsho3/4CldT2PQqV70xIZKtEatCyAo01H0Ov46BdIuC7uw1ff+Gr30E29EQYzO1GGqKltS1pzO8TrJmoyuUqKXVz7/s/4ba2YcHQ3mxY8C9Y+hqUHoSkk50Ao/+pYEyTytOcz0ht36NQuoBrTA8JRS0n0CguhLeuASwMnQyjroVjjvOc0Lx9EfPVF762O9v6ToTBekfcUL4ovz8Cl9r20djfJ1jvqiuXyxiD29oagyHPcegTR3rJIlj0PGyYA2GRMOJCOOEm6DaiWWVp7mekru+RLuAivtNyAo2YOPjVt7DoBVj2Bqz4D3QdAaN+ydK407n85RUhcRGu7c62vhOhL+6I/Zlh8Hb5/RF41bWPxv4+wXpXXX1I8gc/WnlUMJSZU8Atz3/GZDuXbuFzwOxxpmo/+S5Iu8orDTzBO58RBRQi/tdyAg2AxEFw9iNw6r1Od7lFz8NHv2FoeFt+b8fyGqex2dUzaNLSNWnqna2374j9nSGpXP7wMMP2wmIycwqCemTLuvbRlL9HsF4EK5drULf2PwdDx8bBlh9p9/HfmRv2BW2Mix/cQ1k+7E7OmjKdzNwDLMjMZ3RS0/+OlQVr1kdE6mastX7faUZGhl28eLHvd2QtbF1I/rz/o/3Gj4gyLn6ww+h6yq9JGnsxRLTxfRmaoKmZhKasV9s6T8/dwP9+vha3hXADt58xiJtOadzgSY2VmVPAO0tyeTszF1dZ8wKcikCp4qLky4xGbftoaW1OPA7vgxVvOw08d62gLLI9rx85kVddp7Il/BhmXjsa8M1cKaFwTEOhjCLeZozJtNZm1Pheiw40Klm2Zj2HfpxBWt57tDmwDaLjIPliSL0cuqc0uXFaQwXjyaeurIU/LtQ1qSnAGZ3U2W+BV2MF49/VJ9xuZ+yLrJmw+kNwHYauw522UCMuInNnaZXjEIhANRiEelspkaaqK9BoWVUndUgZPAAGPwTuB50T5tLXIPNlp8td1+FOwJF8MbRN8PrFI1hPPnWl/gPVZqB6ejw+NqrJx84fVRHBWt3hNQWbIet1yHoD9m2B6I7Od2XkFdBjpCdAT+9ddZKz1lrNEay9h0QCqdUEGh5h4dBvvPMoLnAGEFo6Ez67C764l4JjTuW57BF86UomPCLSK0FBMJ58MnMK2FZYTER4GGVlNV8MAnERrR7gBOOxCzWNDpxLDsHqD5xgfPO3gIF+p8Bp98HgiRAZ7Wxz3sZatxmsjVt9rbUGWCJ1aX2BRmUx8U7qd9S1sGsVZM2kzeLX+Vf4p+SFdeC/7tFsWlpM+rHnN6tqJdhOPpUzLBFhhqnHHcsFab2C5mJQPcAJpmMXahqcTSsrhex5TiPqNR9DyQGI7wvj74GUS6FjpeLyCgAAFBJJREFUr0ZvsyGBakuremqtAZZIXVp3oFFZ16Ew4SFWD7yNF178N+fwLReHzSU663PYfB8Mn+KMZNh1WKM3HWwnn8pZgjK3pUdcTMDLVJtgO3YVQqX9R50ZIbcbti5wGnaufA+K9zpVI8MvgOSp0HtMjQF2Y7NM3hprJFS0+Oo0kUZSoFFNet8ucO3NLMi+lNW9ohh56HvnLu+7fzizTCYOcU7EQyZBl8EN324QnXyCLcNSn0Afu+oXykCP0dEYR/2t+8bD1oWw6n1YORv250JEDAw+G4Zf6IzaWU9vrMZ8frw51og3tbRMikgwU6BRSeWTz88t5I+FlKlwcI9z1/fTOzD3IeeRMNAJOIZOgm7JPu+54i2BzBKE2gm+pgtloMfoaIz03vHMnD6KLVlzOLHke7q8czsUbXdG7Ow3Hk67HwadBW3aNW6bDfz8eHusEW9oThAXap9fkWCgQKNcvSeftglw3HXOY/8OWPORc1c4/3H49jGI6w1DznUay/UaBeE1H9pgOVEFIksQTKnyhv4darpQ+uMC2ex9lB52GnKu/pD0NR+TfmgPRERD/9NgyP0wcIIzmm4TNfTzU9fvEaiAt6lBXDB9fkVCiQKNco06+XTo/nPQcTAf1n4Mqz6AH/8NPzzlNDLtfzoMOhP6neo5obf2E1Ww9CBpzN+hpgulPy6QTdrH/h2w/jNY95nTsLP0EES1c4KKIZOcIKMRmQtvqO/3CETA29QgLlg+vyKhRoFGuSbfQbbtDGlXOo/D+2DjV86Jft1nznwrJtxpVDdwAuv2DqTEVYbbmlZ5ogqWtiGNuWDUdqEMijE63GWwfSms/wLWfQo7spzXOx7jjHUx8EzoM9avU7HXxB/HqjGZwsp/0/jYKBZk53ter0uwfH5FQk2rGRm0IbxareEug9zFzgVg3aewexUAu2w8890j+MEkM+2yq52BxFqRYKg6CtSop15RsBk2znUC2k1fO8EtxpmpeOAEJ7joMrRJ7YWC4W/TFE3NFDZlvVA9RiK+piHIg0HhFtg4l70rPiM2dz7Rrn3O691GQNIp0OckOHY0RHcIbDkbqa4TbzCflIO5bFUcyIOc75z2Fhu/gr3ZzusdejqDaCWVP9qG1iR63tTU4c5b6zDpIr6gIciDQdyxkH4VndKvcrIdO7LK70znwoJn4Pt/gAlzeq/0GQu9T4TeJzjtPYJUQ+ZKCdYLV6C7zNZq/47ywGK+87xnnfN6ZFvnc3HcDU5vkYQB9WYtGhNMhXL7g2CZ8VhEatYiAw1v3a3WtB2v3MGHhUPPdOcx7g5nyOfchWxf9iV283y6L3yWsB+eAowzD8sxo5yeLL1GQef+QdONtq6Lk8ZIaIAyl1OllrvQqWbb+uPPGYuo9k6GK/Uy6D0WeqRCeGSDN93YQC+UL7pNbZwbrIPBibQ0LS7Q8NaddE3bgdqnvm7WfqNiyQxP4fIlxZS4RtMuwsVbE6MYVLwctvxQPiX3i86y0XE/Bx290qF7qtP1NgDqujiF4hgJPmUt7MuFHctg22LYugi2L3F6hgC0TYRex0HGdCeb1S251i7StakcYDU20Av1i25TM1RBm9kSaUFaXKDhrTvpmrYD+OwOvvL6B10RzDk0gEGnnOW86XbDnrWQu8h5bF0EG+YA5e1rOvR0prrvnuJcoLqnQIcePs981HVxCrUxErzK7YaCTU5QUflRvNd5PyzC+TulXVkeMGY447A04+9VPcC6d+KwRgd6uuiKiC+0uEDDW3fStW3HV3fwda4fFgZdhjiPtCsBWLo+h5wV35PeJpdjDq9zLmRr/4sn+IiJd4ZL7zK46nO7xCYdjwrVqyXqujiF0hgJTVKRpchbA7tX//y8Z50zKRk4I3B2HQqDz6kUDI6AyBivFqV6gFVwqCSkMxQi0nK0yF4nQd9Go5nlrrV64MgB2LXSCTp2r/z/7d1tjFxXfcfx78/Pjh0/x3GajU1NMRioCvGC3BS1hFhViBAppan6oiJpoS6krciLCkWKFKl900LVilZNhaI0EkgIKAkPaQGRGAwIpCReR0kcEuKsU29tx8R27KyzxFl7vacv7l3veD2zc2fv853fRxrN3Z27s/8zZ/ee/z0P9zJ26BkWnHyeJROvTf/wZWujS6ev2Tz9WPvm6Hnx5V3jy2pYIs95FJm+dwhw5hS8ciCaP3Eyfn7lALwyDOOnp/ddtn46odvwziipuGIrLFiULoYEel2yW5t5LGZWC7kub5X0N8BfAeeB74QQPtPtZ/pyeWuGkizLm04KzjOwYJT7PricLTocnXFPNZRjv7z4jZddEa2OWTkQXfRp5cD0Y8UA9zx+in9+5IXUywErNY/i/AT86hiMHoHRQ1EPxYXHIXh1JL5WxRRFn83azdHE3PVb4x6jrXDZmtzDzSLRrdTnb2aNkNvyVknXAzcDvxVCGJe0Ps37WTJJhgemu9LFkYlVPDL+VrZcf/PFO42PRXMJTr44nXyMHoaXn4X9D8PEmYt2v13zuWXR5ZwIKzmplWw9/Bvw8ECUoCxdFU1UXbJyenvpqmj1xLx5HWLLeB7F5PkoKXjjVTjz6sXbZ05FN8YbezlKLMaOR8+vn+TCcNOUxSumE6yB90z3+Kx5M6ze1PXupnnpliAkHaqqxDwWM+sbaedofAr4xxDCOEAI4Vj6kGxKpzPUJBMtE81VWLw8mi+w4TcvfS2EqBEePQSnj/B//7ufY0cPsWryFEtfP867551m2Yk9cPA7cH589oIsWBrNSVh4GSxcyp+FRWxfNMHZMJ9Jzeedw2vgpSXRst9586PLthOixCFMRs+TExDOR9sT43DuTLRio/W5WxwLl0VzVJatj5KHjdth+ZWwfH1LD87VUbJUQVklCHVeympm9ZNq6ETSk8C3gRuBN4C/DSHs6bDvTmAnwMaNG7eNjIzM+fdmqapj1Vl0b2c5V6VjLCHA+GtRz8Ebo5f2JIyfjpOBMxclBadfO83Yr8ZYsXgeyxcqTiIm4+cJQNNJR2sCMm9+dBfSOGlpTWBYeFl0ZdWp3pQlKy/uZVm0bM6fQRVkeen0qv7dm1k9pRo6kbQL2NDmpbvin18DbAfeA/yXpM2hTfYSQrgXuBeiORrJw89Plceqszh7zWrVx6yxSHHj3tul01fEj7T6qcHMcsmwl7KaWVG6JhohhB2dXpP0KeAbcWLxuKRJYB1wPLsQ81PlseoqdW9XKZZWVU4U8+IEwczqJu0cjW8B1wO7JW0BFgEnUkdVkKo2oJD87LWIM/qqXjUy60Sxqr0jVY3LzCyJtInG/cD9kp4BzgK3ths2qapeGtAyDvbdzl6LPKOv4pl0loliVXtHqhqXmVlSqRKNEMJZ4E8ziqUUSRrQqh7sqzz0U4Qse1qSfpZFJ5z9XsdmVn+NuwR5HvI82KdpuKo89FOUrHpaknyWZSScruP+4OExazInGgnkcbDfO3KKB584zAN7DzNxfm4NV15zJ/rxoJfksyyjdyHv+TH9WNdVU9UeU7OsONFIIOuD/dSBZfzc5IVrUua9hNWXp+6u22c514QzbWOe1/yYfq7rKvHwmDWdE42EsjzYTx1YppIMQa7d4r00KEUf9Op0Rj2XhLPKjbkbuGrw8Jg1nRONErQeWObPE7cMXsMfXjuQ20G+lwalyINelRvhTnpNOLt99mUmWm7gqqGqy8fNsuJEowRFH1h6aVCKjK2MM+qib08/22dfdqLlBq46qrh83CwrTjRKUuSBpdcGpajYsj6j7pZE5Nmwd3rvmZ89wD27h9m+eW0lhi7cwJlZ3pxo9IkqNihZnlEnSSJ6bdh76f1ofe+z5yb5/K793LFjy4XPfdum1ZfEePeH3uGhCzNrPCcaVqpCbvwW66UHpdfej6n3PntukkngZ8Mn2HPw5EU/NzPGU6+f9dCFmTWeEw1rhCRJRC89KL32fky99+d37ednwyfa/ly7GKvY02RmliUnGpaZIlZQdPodSZOIpA37XOaPbNu0mjt2bGHPwZNtf86TL82sH6mMe6ANDg6GoaGhwn+v5aeIFRRFr9KYa+JUp2uDmJllQdLeEMJgu9fco2GZKGIFRR6/Y7akYK7DGh4OMTOb5kTDLqjaDd5mxpPHcti6XTDMzKxunGgYkL7Rzet+MDPjyfJ3VOE6FmZmTedEw4BsGt087gczM54sf0enHhLPsTAzy07fJRpuRNqr2n0vsoynl5UqHk4xM8tWXyUabkQ6q9rSy6zi6VbnM3tIqjCc4mTYzJqkrxKNKjQiVVa11RJZxNNrnZfds+Nk2Myapq8SjbIbESter3Veds+Ok2Eza5q+SjTKbkQsO0mHF+ZS52X27DgZNrOm8ZVBrXaaPrzgORpmVje+Mqg1StOHF6o2V8bMLI15ZQdg1qup4YX5wsMLZmYV5x4Nq50mzLXJanjEwyxmVnVONKyW6jy8kNUck6bPVTGzZvDQiVnB2s0xKfN9zMzy5ETDrGBZzTHxXBUzqwMvbzUrgedomFmTeHmrWcVkNcekznNVzKw/eOikz+wdOcU9u4fZO3Kq7FDMzKwPuEejj3iVgpmZFc09Gn3EqxTMzKxoTjT6iFcpmJlZ0Tx0koOqrgRowhU1zcysXpxoZKzq8yC8SsHMzIrkoZOMeR6EmZnZNCcaGfM8CDMzs2keOslYv8yDqOo8FDMzqxYnGjnIcx5EFRr4qs9DMTOz6kiVaEh6F/AFYAkwAdweQng8i8DsUlVp4NvNQ3GiYWZm7aSdo/E54O9CCO8C7o6/tpxUZaKp56GYmVlSaYdOArAi3l4JvJTy/WwWUw38uYnJUhv4fpmHYmZm6aW6TbykrcD3ARH1jlwXQhjpsO9OYCfAxo0bt42MtN3NuqjCHA0zM7NWs90mvmuiIWkXsKHNS3cBNwA/DiE8KOmPgZ0hhB3dAhocHAxDQ0PdIzczM7PKmy3R6Dp0MlviIOlLwKfjL78O3DenCM3MzKyR0k4GfQn4vXj7A8ALKd/PzMzMGiTtZNC/AP5V0gLgDeI5GGZmZmaQMtEIIfwU2JZRLGZmZtYwvteJmZmZ5caJhpmZmeXGiYaZmZnlxomGmZmZ5caJhpmZmeXGiYaZmZnlxomGmZmZ5SbVTdXm/Eul40Bed1VbB5zI6b2rwmVsBpexGVzGZnAZ09kUQrii3QulJBp5kjTU6cYuTeEyNoPL2AwuYzO4jPnx0ImZmZnlxomGmZmZ5aaJica9ZQdQAJexGVzGZnAZm8FlzEnj5miYmZlZdTSxR8PMzMwqovaJhqR/kvQLSU9L+qakVR32u1HS85KGJd1ZdJxpSLpF0s8lTUrqOGNY0kFJ+yQ9KWmoyBjT6qGMda7HNZIekfRC/Ly6w37n4zp8UtJDRcc5F93qRdJiSV+LX39M0puKjzKdBGW8TdLxlrr7RBlxzpWk+yUdk/RMh9cl6d/i8j8t6dqiY0wrQRnfL2m0pQ7vLjrGtCRdI2m3pGfjY+qn2+xTbF2GEGr9AH4fWBBvfxb4bJt95gMHgM3AIuAp4O1lx95DGbcCbwV+BAzOst9BYF3Z8eZVxgbU4+eAO+PtO9v9rcavjZUda4/l6lovwO3AF+LtPwG+VnbcOZTxNuDfy441RRl/F7gWeKbD6zcB3wMEbAceKzvmHMr4fuB/yo4zZRmvAq6Nty8H9rf5Wy20LmvfoxFCeDiEMBF/+Sgw0Ga39wLDIYQXQwhnga8CNxcVY1ohhOdCCM+XHUeeEpax1vVIFOsX4+0vAn9QYixZSlIvrWV/ALhBkgqMMa26/+11FUL4CXByll1uBr4UIo8CqyRdVUx02UhQxtoLIRwNITwRb78GPAdcPWO3Quuy9onGDH9OlKXNdDVwqOXrw1z6wTdBAB6WtFfSzrKDyUHd6/HKEMLRePuXwJUd9lsiaUjSo5LqkIwkqZcL+8QnBqPA2kKiy0bSv72Pxl3RD0i6ppjQClP3/7+kflvSU5K+J+kdZQeTRjxE+W7gsRkvFVqXC/J64yxJ2gVsaPPSXSGEb8f73AVMAF8uMrasJCljAu8LIRyRtB54RNIv4gy+EjIqY6XNVsbWL0IIQVKnJV+b4nrcDPxQ0r4QwoGsY7XM/TfwlRDCuKS/JOrB+UDJMVlvniD6/xuTdBPwLeAtJcc0J5KWAw8Cd4QQTpcZSy0SjRDCjtlel3Qb8CHghhAPQM1wBGg9uxiIv1cZ3cqY8D2OxM/HJH2TqLu3MolGBmWsdT1KelnSVSGEo3E35bEO7zFVjy9K+hHRGUmVE40k9TK1z2FJC4CVwCvFhJeJrmUMIbSW5z6iOTlNUvn/v7RaG+QQwncl/YekdSGEWt0DRdJCoiTjyyGEb7TZpdC6rP3QiaQbgc8AHw4hvN5htz3AWyT9uqRFRJPRajGbPylJyyRdPrVNNEm27czqGqt7PT4E3Bpv3wpc0osjabWkxfH2OuB3gGcLi3BuktRLa9n/CPhhh5OCqupaxhlj3B8mGhtvkoeAj8UrFrYDoy1DgY0gacPU3CFJ7yVqI+uUEBPH/5/AcyGEf+mwW7F1WfYM2bQPYJhorOnJ+DE1s/3XgO+27HcT0ezbA0Rd9aXH3kMZP0I0hjYOvAx8f2YZiWbDPxU/ft7EMjagHtcCPwBeAHYBa+LvDwL3xdvXAfvietwHfLzsuBOW7ZJ6Af6e6AQAYAnw9fj/9XFgc9kx51DGf4j/954CdgNvKzvmHsv3FeAocC7+X/w48Engk/HrAu6Jy7+PWVbAVfWRoIx/3VKHjwLXlR3zHMr4PqL5ek+3tIs3lVmXvjKomZmZ5ab2QydmZmZWXU40zMzMLDdONMzMzCw3TjTMzMwsN040zMzMLDdONMzMzCw3TjTMzMwsN040zMzMLDf/D++v8du5CF9qAAAAAElFTkSuQmCC",
            "text/plain": [
              "<Figure size 648x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(x.numpy(), y.numpy(), '.', label='data')\n",
        "plt.plot(x, f(x),  label='Ground truth')\n",
        "plt.plot(x, model(x), label='Untrained predictions')\n",
        "plt.title('Before training')\n",
        "plt.legend();"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yUvRBoIzbnds"
      },
      "source": [
        "Write a basic training loop"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W9yx8akVbmzg",
        "outputId": "b34b1b4c-3e20-4306-9299-01a612144992"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mean squared error: 13.370\n",
            "Mean squared error: 1.066\n",
            "Mean squared error: 1.018\n",
            "Mean squared error: 0.990\n",
            "Mean squared error: 0.969\n",
            "Mean squared error: 0.955\n",
            "Mean squared error: 0.945\n",
            "Mean squared error: 0.936\n",
            "Mean squared error: 0.931\n",
            "Mean squared error: 0.926\n"
          ]
        }
      ],
      "source": [
        "variables = model.variables\n",
        "\n",
        "optimizer = tf.optimizers.SGD(learning_rate=0.01)\n",
        "\n",
        "for step in range(1000):\n",
        "  with tf.GradientTape() as tape:\n",
        "    prediction = model(x)\n",
        "    error = (y-prediction)**2\n",
        "    mean_error = tf.reduce_mean(error)\n",
        "  gradient = tape.gradient(mean_error, variables)\n",
        "  optimizer.apply_gradients(zip(gradient, variables))\n",
        "\n",
        "  if step % 100 == 0:\n",
        "    print(f'Mean squared error: {mean_error.numpy():0.3f}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 390
        },
        "id": "ZxuWXFSQbqpA",
        "outputId": "b1f666ef-2984-4317-dfc3-51fd1df5c8f9"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 648x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(x.numpy(),y.numpy(), '.', label=\"data\")\n",
        "plt.plot(x, f(x),  label='Ground truth')\n",
        "plt.plot(x, model(x), label='Trained predictions')\n",
        "plt.title('After training')\n",
        "plt.legend();"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZPRStJnjbuA7"
      },
      "source": [
        "That's working, but remember that implementations of common training utilities are available in the **tf.keras** module. So consider using those before writing your own. To start with, the **Model.compile and Model.fit** methods implement a training loop for you:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "9BaGczntbySb"
      },
      "outputs": [],
      "source": [
        "new_model = Model(64)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "muiFAP29b0e-",
        "outputId": "e473c56b-d7b8-4c79-e337-0e92b61dfd6c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Assets written to: ./my_model/assets\n"
          ]
        }
      ],
      "source": [
        "new_model.compile(\n",
        "    loss=tf.keras.losses.MSE,\n",
        "    optimizer=tf.optimizers.SGD(learning_rate=0.01))\n",
        "\n",
        "history = new_model.fit(x, y,\n",
        "                        epochs=100,\n",
        "                        batch_size=32,\n",
        "                        verbose=0)\n",
        "\n",
        "model.save('./my_model')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 404
        },
        "id": "5IbcaHZyb2MG",
        "outputId": "104d7c77-c8cd-427a-f854-ab4f108f6337"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 648x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(history.history['loss'])\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylim([0, max(plt.ylim())])\n",
        "plt.ylabel('Loss [Mean Squared Error]')\n",
        "plt.title('Keras training progress');"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "authorship_tag": "ABX9TyMgFHcJ1tO0DBcqXbs5Zm/K",
      "include_colab_link": true,
      "name": "Tensorflow - Basics.ipynb",
      "provenance": []
    },
    "interpreter": {
      "hash": "0d7fd96aeadd740978789f2880dd43822d8681a39e327029c33ff72656207c4b"
    },
    "kernelspec": {
      "display_name": "Python 3.10.4 64-bit",
      "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.10.4"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}