{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting started with TensorFlow\n",
    "\n",
    "This is taken from [Getting Started with TensorFlow ](https://www.tensorflow.org/get_started/get_started).\n",
    "It covers the basic use of TensorFlow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing TensorFlow\n",
    "- TensorFlow is Python library.\n",
    "- Python libraries are imported using an `import` statement.\n",
    "- The things in TensorFlow must then be prefixed with `tensorflow`, e.g. `tensorflow.constant()`.\n",
    "- To save us some typing we can include an `as` clause to the `import` statement, giving e.g. `tf.constant()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import tensorflow with the shortened name tf.\n",
    "import tensorflow as tf"
   ]
  },
  {
   "attachments": {
    "join_reg.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtMAAADxCAYAAAAJDzslAAAdzUlEQVR4nO3dwZOb533YcfwDPdWHTi8iwzTxJI4kEnvK8MCb5AG5orSSV7IUhXJFrELKoYayLd1I25XXw9pqxxhXXKey6HjlcSymikQnZByza3MmtjMjDXVTJJ94oRs5k9hip216KHoQXurBg/d9scADAvsAn8/Mb0a7wL4PsANQX7588b6NBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA71Mc+c/HA7Scvnk6dujV+7+TFI5NYw3w4H/vMxQPTeYUAAFDp9pMXT9/+9KVu4vxz3Rp3PH3p1QmsYcIZ8hcYAACmQExnOmIaAGD2xHSmI6YBAGZPTGc6YhoAYPbEdKYjpgEAZk9MZzpiGgBg9sR0piOmAQBmT0xnOmIaAGD2xHSmI6YBAGZPTGc6YhoAYPbEdKYjpgEAZk9MZzpiGgBg9n77Uy+e+e1P/ddu0jz2jV/XrvHYn1xKXsNE8+KZab1GAACosGdlvbPr8Oe7KbP7vi/cqFtj9/1f2kpdw/TPnpX1zrReIwAAVBDTeY6YBgDYAX7jgS+f3H3ff/h5yuxaee7NujX2rKx3Utcw0dz/5S9O6zUCAAAAAAAAAAAAAAAAwAK686mLuz72mYsHUqd2jc/+5Z2TWMN8OHc+dXHXdF4hAABUcgXETMcVEAEAZk9MZzpiGgBg9sR0piOmAQBmT0xnOmIaAGD2xHSmk0lMt9vtbjHB906F32+32683Go3G2traY+12u7u2tvZGeP8yVfeNtrs/vn9vNuLbAQDGIqYznQxiut1uX2+326d6/71RRHMvgh/r/XcR1vuD4D01bNtl9+2ttxFuN7itGzyW18U0ADARYjrT2eExXcRu+L12u70/Dtje9+KYHhq58X0r1rvebrdPxbeFa6Y9SwBg4YnpTCfDmC4Eh1n0HZIxiZgumY3eXurr0WMQ0wBAOjGd6WQa03EET3jP9PW6+xZf2zMNAEyMmM50dnhMNxoDx0ZvtNvt63HYFh8gTI3p3ho3j9EOPqBYrO+YaQBg8sR0ppNHTBd7gLsVAd0tDsEIj20eN6Z7a4aHeJwquX9XTAOw8JrNZrdiriRsc6SfbTab681ms/b0XTkQ05lOBjG9U5UdQw0AC6UXzusl378yTuCOE8bzEtO/80evPPe7x77XTZs/+1XdGr97/HsX0tcw4fzOH73y3LReI7MQ79Uu+8Bi4rbslQZgcVXFdO+2a81mc3PE7S1sTO9ZWe/sOvz5bsrsvu8LN+rW2H3/l7ZS1zD9s2dlvTOt1wgAMGfqYnrfvn3H48gtvhdOsK318Pv79u07Hq1TdVvxc+tl2y3s3bv3jng7S0tLy9HzuVa1TsU2xj6cJSam8xwxDQCMrS6ml5aWlsNgLUJ67969dwQ/f6XZbF4Lvh7YyxyvUWyn2G4Q0eF2NsPtFBFcFuHF4+k9livxOsXtQUivB9u4MqmgFtN5jpgGAMZWF9NFfAbRO3DYR0nQ9sV0WVzHURtvo+yx9eL6Wnh7EftFYPce38BzCR7bwDbi55jqtx76ykdSZxprmNF+5wAApUaJ6ejnNsPDJapiOlTEbzBhTF+L71+11zg+1CSI6eIxDWyrd3tpbFd9HwAAao1zmEd4TPOwPdPBGjfDt2LPdG1Mx8c6Ly0tLcd7psseYxjj8fHW0Yz0QUvmyulGo9E1SQMAi6kupksO2Ri47zYO86g8tGKbMb0Z/HffXuqymA4FYV1so/K5AmMT0wAsriExffMY6bIPAPbusxnGdHwGkLoI3s4x09Hx0H17j4u1qmI6Xr/qsBGRDUnENACLqyokmyUXbekF7cDZMobE9EAoVxwzHR+SEZ8lpPTsHlFw9x2uEe8BjyO+bLspXAEx03EFxFRiGoDFVXMM8cAe3JJzNF+rON1cHMtX4uOdw1guDvMIorr0Q4TN6BzSvbX7Ar/kefT9RaHsOUzqdymmMx0xnUpMAwDpxHSmI6ZTiWkAIJ2YznTEdCoxDQCkE9OZjphOJaYBgHRiOtMR06nENACQTkxnOmI6lZgGANKJ6UxHTKcS0wBAOjGd6YjpVGIaAGLBBU7qZug5mquuOjjqfUZRnI+67sqIt4KYznTEdCoxDQDDFBdUGePnphrTwV8CJhro2yGmMx0xnUpMA8AwucR07/LgV4rLmoeXMb/VxHSmI6ZTiWkAGKYqpssOBwkDtgjl6JLiV6JtD8R0fOnwER5neBnzgcuJ30piOtMR06nENAAMUxbTRUgvLS0tB/fbDO8XRPRm8L1rYTzHMV1y+7b2isd7o3uPZehx3ZOyZ2W9s+vw57sps/u+L9yoW2P3/V/aSl3D9M+elfXOtF4jc0pMA8AwZUFbtke5CNoisHv36QvaOMLD7VQdntEL7Nq9zPHjKYv9W0lM5zliOpmYBoBhhu0dLm4vJgrlzZL7h4dj3Izg4pjnkvuXfr+wd+/eO8rO4NGL8IH1bwUxneeI6WRiGgCGqTvMIzxWumLP9CgxHR5bve1T8cUxH89kfxvlfuOhL+/f8+CZIymz+8Gv1u5Fn8Qapn9+a+UrH53G62OOiWkAGKbiMI+Bvb6jxHSxF7kkpkc+s0fVHugi+Kd9zmlYIGIaAIapiOmBs2UU99vOMdPBBwXDmC49nKQusocdGx1/oBGYKDENAMPUfADxZiiHh31EMd0X3SVn94jP5tF3+rx4b3fJY9ssC/D4sU/znNOwQMQ0AAxTs8d44NjkMJaLwzyiY6E3o20MPc90XQiXbTNUfDhxWh9EhAUjpgGAdLef/Kunbn/60tWU+b2nL23VrXHH05deSl3DRL/zkxePTOklMq/ENACQzhUQMx1XQEwlpgGAdGI60xHTqcQ0AJBOTGc6YjqVmAYA0onpTEdMpxLTAEA6MZ3piOlUYhoASCemMx0xnUpMJ3jh6rMHvn71c6dTZ8gaRyaxhvlwXrj67IHpvEKYpF88+fiBfzjWPp06dWu8d+zokUmsYT6cXzz5+IHpvEKYOTGd6YjpVGI6wdevfu70C289002Zs289U/vnxtm3nnk1dQ3TP8P+AsPO9A/H2qffO97uJk7t++2XT7ZfncAaJphhf4FhjojpTEdMpxLTCcR0niOm8ySm8xwxvUDEdKYjplOJ6QRiOs8R03kS03mOmF4gYjrTEdOpxHQCMZ3niOk8iek8R0wvEDGd6YjpVGI6gZjOc8R0nsR0niOmF4iYznTEdCoxnUBM5zliOk9iOs8R0wvkNx/pPP+bD/2nbtI8/J/fr1vj333y+R8mr2H655HO89N6jcwpMZ1ATOc5YjpPYjrPEdMLZM/KemfX4c93U2b3fV+4UbfG7vu/tJW6humfPSvrnWm9RuaUmE4gpvMcMZ0nMZ3niOkFIqbzHDGdTEwnENN5jpjOk5jOc8T0Atn94FeX96ysd1Jm9/1f/mLdGnsePHMkdQ0T/c4f/OrytF4jc0pMJxDTeY6YzpOYznPENDDvxHQCMZ3niOk8iek8R0wD805MJxDTeY6YzpOYznPENDDvxHSC06+1z5x+7Wg3af7i6K9r1/iLo5eS1zDRtM9M6zXC5Pzs4dUzP314tZsyf/vJ1dr3208e/sSl1DVM//zs4VXvN2CuiekEJzZWO8e+ttJNmeOdB2o/uHzi7OpW6hqmf05srPrgcobOL7c6m627uinz8sG7a99vr9zT2kpdw/TP+eWW9xsw18R0AjGd54jpPInpPEdMA/NOTCc4+Y2HTj759Qd+njKffuETb9atcWJjtZO6humfE994sPbMS+xM/+3egye/e+jjP0+ZPzv08dr32/nlVid1DdM/f374oPcbMNfENAAAjElMAwDAmMQ0AACMSUwDAMCYxHSCF64+u+uFq88eSJ26Nb5+9bN3TmIN0ze7pvMKYZJ+8cQTu37x5OMHUqdujfeOHb1zEmuYYJ54Ytd0XiEAsyGmE7gCYp7jCoh5cgXEPMcVEIF5J6YTiOk8R0znSUznOWIamHdiOoGYznPEdJ7EdJ4jpoF5J6YTiOk8R0znSUznOWIamHdiOoGYznPEdJ7EdJ4jpoF5J6YTiOk8R0znSUznOWIamHdiOoGYznPEdJ7EdJ4jpoF5J6YTiOk8R0znSUznOWIamHdiOoGYznPEdJ7EdJ4jpoF5J6YTiOk8R0znSUznOWIamHdiOoGYznPEdJ7EdJ4jpoF5J6YTiOk8R0znSUznOWIamHdiOsGZH336ua/86I+7KfMft078qm6Nr/zojy+krmH658yPPv3ctF4jTM47n3r0ub//94920+YPa99v7zz+6IX0NUw473zqUe83YK6J6Wr/ZtgdTmysdo59baWbMsc7D9yoXePs6lbqGqZ/Tmysdib3MmFC/vWwO5xfbnU2W3d1U+blg3fXvt9euae1lbqG6Z/zyy3vN2Cuielqv99oNLYajca/rbqDmM5zxPSOdFuj0TjdaDT+VdUdxHSeI6aBeSemq/1+44PfT7dREdViOs8R0zvSbY1G418ajcb/ajQapxolUS2m8xwxDcw7MV0tjOn/16iI6qe/89BHUmfYA5nEGma03zlTd1uj0fifjQ/eZ+83KqJ666FDH0mdYQ9kEmuY0X7nADkT09XCmB4a1UCSMKaLqYxqANgp4lg0o80/NRqNj438W2fWTjdm/9oxg/N/ar7/fmPIMdUAMAvdWT+AHaxsz3QxP2nYMw2TdFtjcM/0vzQajf/daDTWGyIagB1KTFcri2kRDbdGGNMiGoBsiOlqYUyXRrQrIOY5roC4I93WaDT+b6Mmol0BMc9xBURg3onpakPPMy2m8xwxvSPd1hhyTLSYznPENDDvxHS1oVdAFNN5jpjekYZeAVFM5zliGph3YjqBmM5zxHSexHSeI6aBeSemE4jpPEdM50lM5zliGph3YjqBmM5zxHSexHSeI6aBeSemE4jpPEdM50lM5zliGph3YjqBmM5zxHSexHSeI6aBeSemE4jpPEdM50lM5zliGph3YjqBmM5zxHSexHSeI6aBeSemE4jpPEdM50lM5zliGph3YjqBmM5zxHSexHSeI6aBeSemE4jpPEdM50lM5zliGph3YjrBiY3VzrGvrXRT5njngRu1a5xd3Updw/TPiY3VzrReI0zO+eVWZ7N1VzdlXj54d+377ZV7Wlupa5j+Ob/c8n4D5pqYTiCm8xwxnScxneeIaWDeiekEYjrPEdN5EtN5jpgG5p2YTnDixYf2n3zxk0fS5pHlW7+GCefplx766LReI0zOhXsP7X/18KEjKfPafa3a99sk1jD9c2FlxfsNmGtiGgAAxiSmAQBgTGIaAADGJKYBAGBMYjrBf7n6uafOvvXM1ZR54a1nturWeOGtZ15KXcNEv/Orzx6Z0kuECfofx9tPvXe8fTVtjta+3947vvZS+hqmb44dPTKllwjATIjpBK6AmOe4AmKeXAExz3EFRGDeiekEYjrPEdN5EtN5jpgG5p2YTiCm8xwxnScxneeIaWDeiekEYjrPEdN5EtN5jpgG5p2YTiCm8xwxnScxneeI6QXSffvxA92326dTp36No0cmsYYJ5/ED03mFzC0xnUBM5zliOk9iOs8R0wuk+3b7dPeddjdxat+k3Xfar05gDRPOkL/AMJSYTiCm8xwxnScxneeI6QUipjMdMZ1KTCcQ03mOmM6TmM5zxPQCEdOZjphOJaYTiOk8R0znSUznOWJ6gYjpTEdMpxLTCcR0niOm8ySm8xwxvUDEdKYjplOJ6QRiOs8R03kS03mOmF4gYjrTEdOpxHQCMZ3niOk8iek8R0wvEDGd6YjpVGI6wbMv/8Hzn/3WI92Ueebbj75ft8Znv/XID1PXMP3z7Mt/8Py0XiNMzt/cf+/zf7lyTzdlLq4crn2//dX99/wwdQ3TP39z/73eb4tCTGc6YjqVmE5wYmO1c+xrK92UOd554EbtGmdXt1LXMP1zYmO1M63XCJNzfrnV2Wzd1U2Zlw/eXft+e+We1lbqGqZ/zi+3vN8WhZjOdMR0KjGdQEznOWI6T2I6zxHTC0RMZzpiOpWYTnDyxUeWT2ysdpLmGw9+sX6NTx5JXsP0zckXH1me1muEyXntvtby+eVWJ2X+/PDB2vfbq4cPHUldw/TPa/e1vN8WhZjOdMR0KjENAKQT05mOmE4lpgGAdO/+9eqZdy6tdlPm7Yurv65b4+2Ln7iUuobpn3f/evXMtF4jc0pMAwDpLp9rdS6cvaubMt/fqP9gww++2dpKXcP0z+VzPtiQSEwDAOnEdJ4jppOJaQAg3X//1sGTF//k4z9PmUsvfvzNujUun2t1Utcw/XP5T+s/mc1QYhoAAMYkpgEAYExiGgAAxiSmAQBgTGIaAEjXffuJXd23Hz+QOrVrvHv0zkmsYcJ5Ytd0XiFzS0wDAOlcATHTcQXEVGIagMXVbDa7FXMlYZsj/Wyz2VxvNpvZ/w9ZTGc6YjpV9u9dABhbL5zXS75/ZZzAHSeMxbSYFtNZy/69CwBjq4rp3m3Xms3m5ojbE9NiOq8R06myf+8CwNjqYnrfvn3H48gtvhdOsK318Pv79u07Hq1TdVvxc+tl2y3s3bv3jng7S0tLy9HzuVa1TsU2xj6cJSamMx0xnUpMA7C46mJ6aWlpOQzWIqT37t17R/DzV5rN5rXg64G9zPEaxXaK7QYRHW5nM9xOEcFlEV48nt5juRKvU9wehPR6sI0rkwpqMZ3piOlUYhqAxVUX00V8BtE7cNhHSdD2xXRZXMdRG2+j7LH14vpaeHsR+0Vg9x7fwHMJHtvANuLnmEJMZzpiOpWYBmBxjRLT0c9thodLVMV0qIjfYMKYvhbfv2qvcXyoSRDTxWMa2Fbv9tLYrvr+qMR0piOmU4lpABbXOId5hMc0D9szHaxxM3wr9kzXxnR8rPPS0tJyvGe67DGGMR4fbx3NSB+0LCOmMx0xnUpML7iyQwCHKfuXQoAs1cV0ySEbA/fdxmEelYdWbDOmN4P/7ttLXRbToSCsi21UPtdJENOZjphOJaYX3DgxDTA3hsT0zWOkyz4A2LvPZviHaHwGkLoI3s4x09Hx0H17j4u1qmI6Xr/qsJFJRbaYznTEdCoxveDENLDQqkKyWXLRll7QDpwtY0hMD4RyxTHT8SEZ8VlCSs/uEQV33+Ea8R7wOOLLtptCTGc6YjqVmF5wZTE97DSk4b9ahp/PiX7mlv1LIuwEzeh0vuP+pfRWvF/Kdj5SoeYY4oFfYskfjtcqTjcXx/KV8Od6f2DejOXiMI8gqks/RBi/6Hpr9wV+yfPoe3GVPYdJ/S7/8aePPvePf/doN2V++bM//FXdGr/8u0cvpK5hovnpo89N6jWwoMT0gotjumLHRdkOkr6YLtsxM4kzLcFOFO8AbDTGf91POqabJZ9/g6m4fK7VuXD2rm7KfH/j7ht1a/zgm62t1DVM/1w+1+pM6zUyp/yBu+DimC47pC4+VLAipuPP5EzkTEuw0zQrPivWu23k61+IaeaGmM5zxHQyf+AuuJKYrjt8sPhA+EBMl3wmR0wzl0aN1WZ0OuKSqz/3vee2c7XnksOqwqMFKq8kDbeUmM5zxHQyMb3gbnFMJ5+2FHaaMGSHxWoz+mxXfNri3n1uvue2c7XnssNJwsNm7Zlmpt64cOgjqTONNcxov3Nq+QN3gZSFb8kHz6ti+pqYhg+UXBdjYA/ykDOpxZ8Xq7xi9HauaF3cr3e7mAaYIn/gLpg4lrdzStTtHDMtpllU8WEcxXshfm8V6v4CW3V4VPj9YXvExTQwqtOND4LQjD8skObgmTn6onfcs3mIabgZxqXHL8dTdmhV3f2bzeZm1fstegxiGgBupWb/qUq3cyrVoeeZFtPQH7LbjdqSmK784K6YnqKST3mWzdBzNJf9c98499nmOqWPM2W7AACTVPcXxd4hHNcajfIPG/Z+vi92o5geerXnYX9RrTq8hETj/i1lyjFd9uLp+6fFW8kVEDMdV0AEYIqCwzfKjm3u22tc7Cwsvq65WN62r/ZccTaPm/cR07dIrjFd9be6W0FMZzpzENPtdnt/u93urq2tPVZ3v7W1tcfa7fbI7+Pw57a7FgDVSg6FqryceLPiA4rB7cPOMz2wU7HqPNPRNid+mfKFVhXTZYeDhC+EInKjwzDiY+cGQrgZXTp8G4+vNqbHudb9qMR0pjMHMb1dk4hpAGAMZTFdceLwvn9KCCJ6M/jetTB84xAuuX3oXvEhh3lM5W9VYjrTmWFMF5G6trb2Rhir7Xa7G8z++P692Shuj/cWB7cVcyra7vWytdvt9qno516Pf65sz3T4M8Fj2F9sI3zM0/nNAsAOUxa0ZQEbH4dTdsxyHOHhduIraQVr1V5WNtrzPXAqmLRnvz1iOtPZATFdxG6j0Wj0gnWj99+nSiK7COMiUvtiuvjv4Gdufh3uYa5YO4zhIqz31x3mUfZ4w8cUBHnfcwGAhTJs73AzOhdiFMoDMRsehxPGdDO6qk9w/9LvB7dX7ZleLzu+6FYQ05nOzojp/eHX4X16sXoqvi2I1dKYDvdox+uVrR3fP9xOVUyXrVU83vi2uscFAHOv7jCP8Fjpij3To8R03R7myrNyVMV077apnKtUTGc6OzCmS2ajF6jXw5+vOsyjZDunwu+Xrd3bXnx4SG1Ml8V/77CRDTENAIGKwzwGInWUmA4uKxvH9Mhn9hgS06WPYdLEdKaz82L6et19i6+r9kzHP1e1h7km5Afi155pgPkwbIfINNevu99cfvC9IqYHTplS3G87x0wHl8EMY7r0cJJhkb2NPdO3/EOIYjrT2UEx3Wh8GKPh7cHxyds5ZrpvD3ZxW7i9srXjP7iKDybWxXTweOuOmRbTADvErGN6u3byYxtbzQcQb4ZyeNhHFNNlJxffjLZzJbr95tdlJxcveXy1x0yP85xHJaYznR0W043GwNk8TpXcPzxLRtnZPMIzaJSeeaNs7SCgu0WUtwfPBDLq2TzENDBzwZ9BpWcYaleczah3W3gGpWIbp8q2E9x/4IxMQx5XuP1T0X0Gtjfu84l2voRnaroefQD99UaNUR93/P+G6F83B55D+Nh6X5eepSorNXuMBy7dHcZycYhFdCz0ZrSNoeeZHnae6LpjrdOf/faI6Uwn0/NMt0uOoQagXBhuva8HzpZUdjaj4rbi54IIrdrO9XbFGZnqHtfa2tob0fb3121v3OfTrtgz3YvVYp3Xh8XqOI87Xr/uOZT9i2i8dt3jI1NiOtPJJKaDP3S2vccDgA+0a/61LP6ztOS+A/8aV/avcHVnZBr2uMLtFx/krtveuM+nKqZ7X79RrLHd32fZ444fW9njLvvcTdXvsmx7zCkxnelkEtMAjK8u3Hpfl57NqHfbSDFdMpUXrCoLxTimy7Y37vOpiuniefWexxuj/j7LHnd4/zi0R4np3s+XnqWKOXP5XKtz4exd3ZT5/sbdN+rW+ME3W1upa5j+uXyu1ZnWawSA2dhOuNWE6SgxPdLhd2V7eNv91xco3d64z2dITL/em6FXq6173GWhHd82akyXrT38t0t2xHSeI6YB5t+Ie0HfaI8R072vr7crzsg05HHFx2TXbm/c5zMkpk8Ne7wjPu7tHjM97DCPvs8Iiek5JqbzHDENMP/qwq3RGH42o+3GdHF7uK3wfjWP6+YZLeKYrdveqM8njNlw28E2trVnfdTHPeRsHpX/IhA8tsqzVDFHtr5zaP+Vlw8dSZkff7tVefq/Sa1h+ucn31n56LReIwAsrnbJ6ebKYnxW2ts4JV5w3x3zuAEAWAA7Oabbg6cDLDuD1M05evTosZ3wuAEAAAAAAAAAgOnr/n37qe477atJ8+7Rrdo13l17KXkN0z9vHz0ypZcIAABVXAEx03EFRACA2RPTmY6YBgCYPTGd6YhpAIDZE9OZjpgGAJg9MZ3piGkAgNkT05mOmAYAmD0xnemIaQCA2RPTmY6YBgCYPTGd6YhpAIDZE9OZjpgGAJg9MZ3piGkAgNkT05mOmAYAmL03z9/7/E++e083ZX72vcPv163xt9+954epa5j+efP8vc9P6zUCAECFy+danQtn7+qmzPc37r5Rt8YPvtnaSl3D9M/lc63OtF4jAABUENN5jpgGANgBfvzt1vLlc61O0vzpwS/WrXHl5UNHktcwffPjb7eWp/UaAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5sH/B1sixly55yc0AAAAAElFTkSuQmCC"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data flow graphs\n",
    "\n",
    "- TensorFlow thinks of computations as graphs.\n",
    "- Starting nodes of the graph are data sources.\n",
    "- Intermediate nodes are operations.\n",
    "- Ending nodes are data outputs.\n",
    "\n",
    "![Data flow](https://raw.githubusercontent.com/ianmcloughlin/images/master/dataflow.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating data nodes\n",
    "\n",
    "- We create nodes using functions like `tf.constant()`.\n",
    "- They're just placeholders, until we `run` the graph later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(\"Const:0\", shape=(), dtype=float32) Tensor(\"Const_1:0\", shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "# Create a node representing the float value 3.0.\n",
    "node1 = tf.constant(3.0, dtype=tf.float32)\n",
    "\n",
    "# Create a node representing the valuee 4.0.\n",
    "node2 = tf.constant(4.0) # also tf.float32 implicitly\n",
    "\n",
    "# Print the nodes to the screen.\n",
    "print(node1, node2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running the session\n",
    "\n",
    "- We create a session, which encapsulates an execution of the graph, creating a scope.\n",
    "- Then we run the graph in the session.\n",
    "- It's not very interesting, our graph just contains two separate, unconnected nodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.0, 4.0]\n"
     ]
    }
   ],
   "source": [
    "# Create a new session.\n",
    "sess = tf.Session()\n",
    "\n",
    "# Run the two constant nodes in the session.\n",
    "print(sess.run([node1, node2]))"
   ]
  },
  {
   "attachments": {
    "tf_add.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Perform an operation\n",
    "- Here we create an `add` node that adds its inputs.\n",
    "- We tell it to use `node1` and `node2` as input.\n",
    "- We now have three nodes, two containing constant numbers with data flowing from these to the third node which adds them.\n",
    "\n",
    "![tf_add.png](attachment:tf_add.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "node3: Tensor(\"Add:0\", shape=(), dtype=float32)\n",
      "sess.run(node3): 7.0\n"
     ]
    }
   ],
   "source": [
    "# Create an adder node, connect constant nodes to it.\n",
    "node3 = tf.add(node1, node2)\n",
    "\n",
    "# Print the node.\n",
    "print(\"node3:\", node3)\n",
    "\n",
    "# Run the node in the session and print output.\n",
    "print(\"sess.run(node3):\", sess.run(node3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Placeholder nodes\n",
    "- Constants are fine, but what if we want to use variables?\n",
    "- We use `tf.placeholder()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create two placeholder nodes representing floats.\n",
    "a = tf.placeholder(tf.float32)\n",
    "b = tf.placeholder(tf.float32)\n",
    "\n",
    "# Create an adder node with connections from a and b, using shorthand. \n",
    "adder_node = a + b  # + provides a shortcut for tf.add(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now when we run the graph we supply the values of the placeholders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.5\n",
      "[3. 7.]\n"
     ]
    }
   ],
   "source": [
    "# Run the adder node in the session with single values supplied for a and b.\n",
    "print(sess.run(adder_node, {a: 3.0, b: 4.5}))\n",
    "\n",
    "# Run the adder node in the session with two values supplied for a and b.\n",
    "print(sess.run(adder_node, {a: [1.0, 3.0], b: [2.0, 4.0]}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implicit nodes\n",
    "- TensorFlow is clever when it comes to syntax.\n",
    "- We can create a fourth node that triples the value from `adder_node` implicitly.\n",
    "- Think of this as operator overloading."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22.5\n"
     ]
    }
   ],
   "source": [
    "# Create a new node that multiplies the output of adder_node by three.\n",
    "add_and_triple = adder_node * 3.0\n",
    "\n",
    "# Run that node in the session.\n",
    "print(sess.run(add_and_triple, {a: 3, b: 4.5}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear models with gradient descent\n",
    "- Let's have a quick look at doing something more complicated with TensorFlow.\n",
    "- We'll try to estimate the best line that fits the following data.\n",
    "- You can probably guess that the best line should have slope 2.0 and intercept -1.0.\n",
    "- Let's get TensorFlow to use a complicated algorithm to estimate this!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 2. 4. 6. 8.]\n",
      "[-1.  3.  7. 11. 15.]\n"
     ]
    }
   ],
   "source": [
    "# Import numpy.\n",
    "import numpy as np\n",
    "\n",
    "# Set the actual slope and y-intercept. We'll estimate these later.\n",
    "# Why do we call them W and b?\n",
    "W_actual = 2.0\n",
    "b_actual = -1.0\n",
    "\n",
    "# Create some example x and y values.\n",
    "x_vals = np.arange(0.0, 10.0, 2.0)\n",
    "y_vals = W_actual * x_vals + b_actual\n",
    "\n",
    "print(x_vals)\n",
    "print(y_vals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Tell Jupyter to display plots in the notebook.\n",
    "%matplotlib inline\n",
    "\n",
    "# Import matplotlib.\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Plot the x and y values we've created.\n",
    "plt.plot(x_vals, y_vals, 'k.')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialise some nodes\n",
    "- We'll create two values with guess values to start.\n",
    "- The first is `W`, and this will be the slope of the line.\n",
    "- The second is `b` and this will be the value of `y` when `x` is zero (the intercept).\n",
    "- Note that sometimes we'd call these m and c, but in tensorflow we usually use w for weight and b for bias.\n",
    "- We'll create a placeholder for our x values, called `x`.\n",
    "- Then we'll create a \"function\" which multiplies the placeholder `x` by `W` (which is 0.3 to start) and then adds `b` (which is -0.3 to start).\n",
    "- In reality we'd set these values randomly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a node for W an give it an initialvalue of 0.3.\n",
    "W = tf.Variable([.3], dtype=tf.float32)\n",
    "\n",
    "# Create a node for b an give it an initialvalue of -0.3.\n",
    "b = tf.Variable([-.3], dtype=tf.float32)\n",
    "\n",
    "# Create a placeholder for x values.\n",
    "x = tf.placeholder(tf.float32)\n",
    "\n",
    "# Create a node repesenting the line.\n",
    "linear_model = W * x + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The goal\n",
    "- Our goal will be to adjust `W` and `b` so that when we perform this \"function\" on our x values we get outputs that are close to our y values.\n",
    "- Then `W` and `b` are good fits for our data.\n",
    "- Let's get the session running."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.3         0.3         0.90000004  1.5         2.1000001 ]\n",
      "[-1.  3.  7. 11. 15.]\n"
     ]
    }
   ],
   "source": [
    "# Initialise the tensorflow global variables like W and b in the session.\n",
    "init = tf.global_variables_initializer()\n",
    "sess.run(init)\n",
    "\n",
    "# Print the current values of W * x + b where x is x_vals.\n",
    "print(sess.run(linear_model, {x: x_vals}))\n",
    "\n",
    "# Print out actual y values.\n",
    "print(y_vals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bad predictions\n",
    "- Currently our predictions are not very good.\n",
    "- We want the above values (`(W * x) + b`) to be close to our actual y values.\n",
    "- To improve them, we must somehow quantify how bad our predictions are.\n",
    "- The typical way to do this is to subtract our predictions from what we know the values should be, square each of those values and add them together. We call this *the sum of the squares*.\n",
    "- Note a key idea here: we must *know* in advance what some of the `y` values should be. This is the *supervised* part of supervised learning. It's like we're teaching the model by giving it feedback on a test we give it.\n",
    "- Let's tell TensorFlow how to quantify how bad the model is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "301.65\n"
     ]
    }
   ],
   "source": [
    "# Create a variable node for y values.\n",
    "y = tf.placeholder(tf.float32)\n",
    "\n",
    "# Create a cost function node.\n",
    "squared_deltas = tf.square(linear_model - y)\n",
    "\n",
    "# Tell tensorflow to reduce the cost function (by summing the output values).\n",
    "loss = tf.reduce_sum(squared_deltas)\n",
    "\n",
    "# Run the loss function node to calculate the current cost.\n",
    "print(sess.run(loss, {x: x_vals, y: y_vals}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Perfect fit\n",
    "- Let's compare that loss to what we know is the perfect fit model, when `W` is `W_actual` and `b` is `b_actual`.\n",
    "- We can use the `tf.assign` function to temporarily assign these values.\n",
    "- The loss is 0 then, as expected.\n",
    "- Any other values for `W` and `b` will move the loss away from 0.\n",
    "- Question: can the loss be less than 0?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "# Assign W and b\n",
    "fixW = tf.assign(W, [W_actual])\n",
    "fixb = tf.assign(b, [b_actual])\n",
    "sess.run([fixW, fixb])\n",
    "print(sess.run(loss, {x: x_vals, y: y_vals}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimisation\n",
    "- Optimisation can be tricky, and there is a lot of theory to go through.\n",
    "- Luckily TensorFlow comes with built-in optimisation methods.\n",
    "- You must understand how optimisations work to do them right.\n",
    "- For now, let's just give them a whirl in the knowledge that they're more complex.\n",
    "- One of the most popular optimisation methods is gradient descent, based on calculus.\n",
    "- It works by making small changes in the parameters (`W` and `b`) in the right direction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.train.GradientDescentOptimizer(0.001)\n",
    "train = optimizer.minimize(loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running the optimisation\n",
    "- We run the optimiser 1000 times.\n",
    "- With each iteration the values are getting closer and closer to some optimum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([1.9936954], dtype=float32), array([-0.9626834], dtype=float32), 0.0023217637]\n"
     ]
    }
   ],
   "source": [
    "sess.run(init) # reset values to incorrect defaults.\n",
    "for i in range(1000):\n",
    "  sess.run(train, {x: x_vals, y: y_vals})\n",
    "\n",
    "print(sess.run([W, b, loss], {x: x_vals, y: y_vals}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualise\n",
    "Let's have a look at our fitted line (in red) compared the actual line (in blue)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get the W and b estimated values from Tensorflow.\n",
    "W_est = W.eval(sess)\n",
    "b_est = b.eval(sess)\n",
    "\n",
    "# Plot the actual values as black circles.\n",
    "plt.plot(x_vals, y_vals, 'ko')\n",
    "# Plot the estimated line from Tensorflow.\n",
    "plt.plot(x_vals, W_est * x_vals + b_est, 'r-')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### End"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}