MIT_TF_From_the_Ground_Up_Exercises_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "MIT: TF From the Ground Up Exercises 1.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "au5kdSKU9ddV"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# This will be an float tensor by default\n",
        "rank_0_tensor = tf.constant(4.0)\n",
        "\n",
        "# Let's make a rank_1 tensor, which is like an array\n",
        "real = tf.constant([2.25, 3.25])\n",
        "imag = tf.constant([4.75, 5.75])\n",
        "# Let's make a complex tensor\n",
        "complex_tensor = tf.complex(real, imag)  # [[2.25 + 4.75j], [3.25 + 5.75j]]\n",
        "\n",
        "# String tensor\n",
        "rank_2_tensor = tf.constant([[\"fruit\", \"bat\"],\n",
        "                            [\"fuzzy\", \"cat\"],\n",
        "                            [\"gray\", \"wolf\"]], dtype=tf.string)\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "D_Lm6FQ-0AOs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can examine their shape and other features."
      ],
      "metadata": {
        "id": "-Ry5ypCMX5GN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(rank_2_tensor.shape)\n",
        "print(rank_2_tensor.dtype)"
      ],
      "metadata": {
        "id": "AaQMR3PJX06a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rank_4_tensor = tf.zeros([3, 2, 4, 5])\n",
        "\n",
        "print(\"Type of every element:\", rank_4_tensor.dtype)\n",
        "print(\"Number of dimensions:\", rank_4_tensor.ndim)\n",
        "print(\"Shape of tensor:\", rank_4_tensor.shape)\n",
        "print(\"Elements along axis 0 of tensor:\", rank_4_tensor.shape[0])\n",
        "print(\"Elements along the last axis of tensor:\", rank_4_tensor.shape[-1])\n",
        "print(\"Total number of elements (3*2*4*5): \", tf.size(rank_4_tensor).numpy())\n"
      ],
      "metadata": {
        "id": "hmZreb1mH2A2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exercise\n",
        "\n",
        "Make three ]of your own tensors.  Try using:\n",
        "* Python\n",
        "* numpy\n",
        "* Booleans\n",
        "\n",
        "Examine their shape using `.shape`."
      ],
      "metadata": {
        "id": "mALIj8cr9p1K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mytensor_rank2 = tf.constant([[1,2],\n",
        "                  [3,4],\n",
        "                  [5,6]])\n",
        "print(mytensor_rank2.shape)\n",
        "# You rr work goes here. "
      ],
      "metadata": {
        "id": "e6mA7fmr9luu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "There are built-in operators to make tensors, too.  Make a few of your own!"
      ],
      "metadata": {
        "id": "FnpPlqx7937X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# tf.zeros(...)\n",
        "# tf.ones(...)\n",
        "\n",
        "tf.ones(3,2)\n"
      ],
      "metadata": {
        "id": "ILZjkO0or89j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Let's do a little math\n",
        "\n",
        "Note that tensor math tends to be type-sensitive.  Automatic promotion/casting of types can be surprisingly inefficient or lead to unexpected results, so TensorFlow avoids that."
      ],
      "metadata": {
        "id": "xzQrtTCj90ug"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "rank_0_tensor * tf.constant([[2.,2.],[3.,3.]])\n",
        "\n",
        "# Note that this an int type tensor \n",
        "a = tf.constant([2, 2])\n",
        "print(a)\n",
        "\n",
        "b = tf.constant([1.0, 4.0])\n",
        "print(b)\n",
        "\n",
        "try:\n",
        "  print(a * b) # This is pairwise multiplication\n",
        "except tf.errors.InvalidArgumentError as e:\n",
        "  print(\"Mismatched dtypes: \" + str(e))\n",
        "\n",
        "\n",
        "print(\"With operator overload: \" + str(tf.cast(a, tf.float32) * b))\n",
        "print(\"Without operator overload: \" + str(tf.multiply(tf.cast(a, tf.float32), b)))\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "o9clpG3b910J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## EXERCISE"
      ],
      "metadata": {
        "id": "5z-y_M-AWkxc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# EXERCISE!!\n",
        "# The operator for matrix multiply is @, or you can use tf.matmul\n",
        "# Create two matricies and multiply them together\n",
        "# Here's the first one...\n",
        "\n",
        "first_matrix = tf.constant([[1,2],[3,4]], dtype=tf.double)\n",
        "second_matrix = tf.constant([[5,6],[7,8]], dtype=tf.double)\n",
        "\n",
        "mult = first_matrix @ second_matrix\n",
        "\n",
        "print(mult)"
      ],
      "metadata": {
        "id": "TMyAUG52Wj00"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "a9JRVgM_GF1M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Solution."
      ],
      "metadata": {
        "id": "7IE8iBvBWzV4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "second_matrix = tf.constant(tf.ones([2,2], tf.double))\n",
        "\n",
        "first_matrix @ second_matrix\n"
      ],
      "metadata": {
        "id": "yF8D8eYSVUWB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Bonus! Load a built-in dataset\n",
        "\n",
        "TensorFlow not only does math quickly, it also works on large datasets, such as giant image datasets that cannot fit in memory).  With just one command, you can grab any of dozens of pre-built datasets, aleady in tensor format.\n",
        "\n",
        "tf.Data makes data pipelines, complete with pre-processing steps.  However, in this case, we'll just treat it like a regular Python iterator."
      ],
      "metadata": {
        "id": "Tt8i_lxOr_2J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow_datasets as tfds\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "RpbJKnVH0CAG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Download Fashion MNIST\n",
        "dataset, metadata = tfds.load('fashion_mnist', as_supervised=True, with_info=True)\n",
        "train_dataset, test_dataset = dataset['train'], dataset['test']"
      ],
      "metadata": {
        "id": "u5W6YO94Imca"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can check it out here [at Know Your Data.](https://knowyourdata-tfds.withgoogle.com/#tab=STATS&dataset=fashion_mnist)."
      ],
      "metadata": {
        "id": "GGrWneO6JMi7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Look at one picture\n",
        "for data, labels in train_dataset.take(1):\n",
        "#  print(\"Actual data: \" + str(data))\n",
        "  print(\"Data (a single picture, 28x28, with one color channel): \" + str(data.shape) + \", dtype= \" + str(data.dtype))"
      ],
      "metadata": {
        "id": "gDpmGdro0EHs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Render an image\n",
        "for data, labels in train_dataset.take(1):\n",
        "  plt.figure(figsize=(10,5))\n",
        "  plt.imshow(data.numpy().reshape(28,28), cmap=plt.cm.binary)\n",
        "  plt.show()"
      ],
      "metadata": {
        "id": "35r3jeKd0F2y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Now, look at the data!  It's a uint8 tensor\n",
        "print(data)"
      ],
      "metadata": {
        "id": "sAAvCH8cSzGB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# And the label is just... 2, which stands for the \"Pullover\"\n",
        "print(labels)"
      ],
      "metadata": {
        "id": "6vMY7GHAUxox"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "tbsR9vatU4ot"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}