matplotlib.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "matplotlib.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NBaXDWeLSmPb",
        "colab_type": "text"
      },
      "source": [
        "# [Aman's AI Journal](https://aman.ai) | Primers | Matplotlib Tutorial\n",
        "\n",
        "## Introduction\n",
        "\n",
        "- [Matplotlib](http://matplotlib.org/) is a plotting library.\n",
        "- This tutorial offers a brief overview of the `matplotlib.pyplot` module, which provides a plotting system similar to that of MATLAB (which is where Matplotlib gets its name from!).\n",
        "- Matplotlib can output graphs using various backend graphics libraries, such as Tk, wxPython, etc. When running python using the command line, the graphs are typically shown in a separate window. In a Jupyter/Colab notebook, we can simply output the graphs within the notebook itself by running the `%matplotlib inline` magic command.\n",
        "- Run this cell if you're viewing this in Colab:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "izstqYuQSmPc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%matplotlib inline"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pcnoKhevSmPe",
        "colab_type": "text"
      },
      "source": [
        "## Plotting 2D data\n",
        "\n",
        "### Python lists\n",
        "\n",
        "- The most important function in the `matplotlib.pyplot` module is `plot`, which allows you to plot 2D data. Here is a simple example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8N96VmRYSmPf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.plot([1, 2, 4, 7, 4, 2, 1])\n",
        "plt.show() # You must call plt.show() to render your final plot."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5amlqWdkSmPh",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/1.jpg?raw=1)\n",
        "\n",
        "- In the above example, we simply called the `plot` function with some data, and then called the `show` function to render your plot onto the screen.\n",
        "- Note that if the `plot` function is given one array of data, it will use it as the coordinates on the vertical axis, and it will just use each data point's index in the array as the horizontal coordinate.\n",
        "- You can also provide **two arrays**: one for the horizontal axis `x`, and the second for the vertical axis `y`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WMjd8juDSmPk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.plot([-3, -2, 5, 0], [1, 6, 4, 3])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BcNThuh8SmPp",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/2.jpg?raw=1)\n",
        "\n",
        "### NumPy arrays\n",
        "\n",
        "- You can plot NumPy arrays using Matplotlib using the same syntax as what we saw earlier with Python lists.\n",
        "- Note that by default, Matplotlib connects **consecutive points** with a **line** when drawing a \"vanilla\" 2D plot (using the `plot` function). Since we're looking to view the vectors in isolation (and not by connecting them together with a line), we utilize a scatter plot (using the `scatter` function) which helps observe data points individually."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aye9QBAsSmPp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "x = np.array([1, 2])\n",
        "y = np.array([3, 4])\n",
        "plt.scatter(x, y, color=[\"r\",\"b\"]) # Read more on the color argument in the examples section below.\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9lrfwEllSmPs",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/2a.jpg?raw=1)\n",
        "\n",
        "### 2D vectors\n",
        "\n",
        "- To plot 2D vectors using Matplotlib, we use Python's inbuilt `zip()` function which aggregates elements from its inputs by returning an iterator of tuples where the \\\\(i^{th}\\\\) tuple contains the \\\\(i^{th}\\\\) element from each of the input iterables. To read more about the `zip()` function, refer our [Python tutorial](../python3).\n",
        "- Using `zip()`, we populate lists with the X and Y components of the vectors \\\\(u\\\\) and \\\\(v\\\\):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YGcXZhMjSmPs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "u = np.array([1, 2])\n",
        "v = np.array([3, 4])\n",
        "x, y = zip(u, v)\n",
        "plt.scatter(x, y, color=[\"r\",\"b\"])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GHA3cJTwSmPu",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/2b.jpg?raw=1)\n",
        "\n",
        "- Since vectors are usually represented with arrows, let's create a quick convenience function to draw arrows for the vectors \\\\(u\\\\) and \\\\(v\\\\):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-hjArIRoSmPu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "def plot_vector2d(vector2d, origin=[0, 0], **options):\n",
        "    return plt.arrow(origin[0], origin[1], vector2d[0], vector2d[1], head_width=0.2, \n",
        "           head_length=0.3, length_includes_head=True, **options)\n",
        "\n",
        "u = np.array([1, 2])\n",
        "v = np.array([3, 4])\n",
        "x, y = zip(u, v)\n",
        "plt.scatter(x, y, color=[\"r\",\"b\"])\n",
        "plot_vector2d(u, color=\"r\")\n",
        "plot_vector2d(v, color=\"b\")\n",
        "plt.axis([0, 9, 0, 6]) # Read more on the axis argument in \"Axes extents\" section below.\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lvOe5VGZSmP1",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/2c.jpg?raw=1)\n",
        "\n",
        "### Examples\n",
        "\n",
        "- Now, let's plot a mathematical function. We use NumPy's `linspace` function (to learn more about NumPy and its `linspace` function, refer to our [NumPy tutorial](../numpy)) to create an array `x` containing \\\\(500\\\\) floats ranging from \\\\(-2\\\\) to \\\\(2\\\\), then we create a second array `y` computed as the square of `x`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jsagcva3SmP1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "x = np.linspace(-2, 2, 500)\n",
        "y = x**2\n",
        "\n",
        "plt.plot(x, y)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kQUZ-y3vSmP4",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/4.jpg?raw=1)\n",
        "\n",
        "- And here's how you can get a sine wave:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ysZPkt5SmP5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# Compute the X and Y coordinates for points on a sine curve\n",
        "x = np.arange(-2*np.pi, 2*np.pi, 0.1)\n",
        "y = np.sin(x)\n",
        "\n",
        "# Plot the points using matplotlib\n",
        "plt.plot(x, y)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jfs6ksuBSmP9",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/sine.jpg?raw=1)\n",
        "\n",
        "## Plotting 3D data\n",
        "\n",
        "- Plotting 3D vectors is relatively straightforward using Matplotlib's `Axes3D`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WRV5PrGdSmP9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "import numpy as np\n",
        "\n",
        "a = np.array([1, 2, 3])\n",
        "b = np.array([4, 5, 6])\n",
        "\n",
        "subplot3d = plt.subplot(111, projection='3d')\n",
        "x_coords, y_coords, z_coords = zip(a,b)\n",
        "subplot3d.scatter(x_coords, y_coords, z_coords)\n",
        "subplot3d.set_zlim3d([0, 9])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1-AcMM6NSmP-",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/3d1.jpg?raw=1)\n",
        "\n",
        "- To make visualization of the two vectors easier, let's add vertical \"grounding\" lines by creating a quick convenience function to plot a list of 3D vectors with vertical lines attached:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZSb8l1aPSmQA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "import numpy as np\n",
        "\n",
        "def plot_vectors3d(ax, vectors3d, z0, **options):\n",
        "    for v in vectors3d:\n",
        "        x, y, z = v\n",
        "        ax.plot([x,x], [y,y], [z0, z], color=\"gray\", linestyle='dotted', marker=\".\")\n",
        "    x_coords, y_coords, z_coords = zip(*vectors3d)\n",
        "    ax.scatter(x_coords, y_coords, z_coords, **options)\n",
        "\n",
        "a = np.array([1, 2, 3])\n",
        "b = np.array([4, 5, 6])\n",
        "\n",
        "subplot3d = plt.subplot(111, projection='3d')\n",
        "subplot3d.set_zlim([0, 9])\n",
        "plot_vectors3d(subplot3d, [a,b], 0, color=(\"r\",\"b\"))\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9bCOTJTxSmQC",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/3d2.jpg?raw=1)\n",
        "\n",
        "## Axes extents\n",
        "\n",
        "- The axes in Matplotlib plots **automatically match** the extent of the data. \n",
        "- If we wish to override the axes extents of plots, for e.g., to give the graph a bit more room, we can call the `axis` function to change the extent of each axis with `[xmin, xmax, ymin, ymax]`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s6bIXOduSmQC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.plot([-3, -2, 5, 0], [1, 6, 4, 3])\n",
        "plt.axis([-4, 6, 0, 7])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DF4Xd0ePSmQE",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/3.jpg?raw=1)\n",
        "\n",
        "## Additional plot attributes\n",
        "\n",
        "- With just a little bit of extra work we can superimpose multiple lines on the same graph, add a title, legend, axis labels and draw a grid:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1CSq01nMSmQE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# Compute the X and Y coordinates for points on sine and cosine curves\n",
        "x = np.arange(-2*np.pi, 2*np.pi, 0.1)\n",
        "y_sin = np.sin(x)\n",
        "y_cos = np.cos(x)\n",
        "\n",
        "# Plot the points using matplotlib\n",
        "plt.plot(x, y_sin)\n",
        "plt.plot(x, y_cos)\n",
        "\n",
        "# Axes labels\n",
        "plt.xlabel('Radians')\n",
        "plt.ylabel('Magnitude')\n",
        "\n",
        "# Custom X and Y axis limits\n",
        "plt.xlim(np.ceil(-2*np.pi), np.floor(2*np.pi))\n",
        "plt.ylim(-1, 1)\n",
        "\n",
        "# Add a plot title\n",
        "plt.title('Sine and Cosine')\n",
        "\n",
        "# Add a legend\n",
        "plt.legend(['Sine', 'Cosine'])\n",
        "\n",
        "# Show the grid\n",
        "plt.grid() # Same effect as plt.grid(True)\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X3-C2uTQSmQJ",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/sine_cosine.jpg?raw=1)\n",
        "\n",
        "- For more on the `plot` function, refer the [Matplotlib documentation](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot).\n",
        "\n",
        "## Line style and colors\n",
        "\n",
        "- Let's start with a plot that contains several points connected together with straight lines:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MsPYrjQESmQJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.plot([0, 100, 100, 0, 0, 100, 0, 100], [0, 0, 100, 100, 0, 100, 100, 0])\n",
        "plt.axis([-10, 110, -10, 110])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m6f58HrXSmQN",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/5.jpg?raw=1)\n",
        "\n",
        "- Overriding the `linestyle` (or `ls`) argument changes the line's style. The three most common linestyles are `-` (or `solid`) for a solid line, `--` (or `dashed`) for a dashed line, and `:` (or `dotted`) for a dotted line."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EmL1EO8ZSmQN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.plot([0, 100, 100, 0, 0, 100, 0, 100], [0, 0, 100, 100, 0, 100, 100, 0], ls=\"--\")\n",
        "plt.axis([-10, 110, -10, 110])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sXgHtQ9cSmQS",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/6.jpg?raw=1)\n",
        "\n",
        "- Overriding the `color` argument changes the line's color."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z_dWkrEFSmQS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.plot([0, 100, 100, 0, 0, 100, 0, 100], [0, 0, 100, 100, 0, 100, 100, 0], ls=\"--\", color=\"purple\")\n",
        "plt.axis([-10, 110, -10, 110])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ENISIBA9SmQW",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/7.jpg?raw=1)\n",
        "\n",
        "- To define linestyle and color all rolled into one argument, send in a third positional argument over to `plot()`. In the below code snippet, `\"g--\"` means \"green dashed line\"."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ATY3wiHpSmQW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.plot([0, 100, 100, 0, 0, 100, 0, 100], [0, 0, 100, 100, 0, 100, 100, 0], \"g--\")\n",
        "plt.axis([-10, 110, -10, 110])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g8QZvQxbSmQY",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/8.jpg?raw=1)\n",
        "\n",
        "- To plot multiple lines on one graph, just pass in multiple `x` and `y` arrays (and optionally, their respective styles) as: `x1, y1, [style1], x2, y2, [style2], ...`\n",
        "\n",
        "For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KlyVdO_6SmQY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.plot([0, 100, 0, 100], [0, 100, 100, 0], \"g--\", [0, 100, 100, 0, 0], [0, 0, 100, 100, 0], \"r-\")\n",
        "plt.axis([-10, 110, -10, 110])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D3cIQi0bSmQb",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/9.jpg?raw=1)\n",
        "\n",
        "- We can also achieve the same result as above by simply calling `plot` multiple times before calling `show`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lKGFB3RHSmQc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.plot([0, 100, 0, 100], [0, 100, 100, 0], \"g--\")\n",
        "plt.plot([0, 100, 100, 0, 0], [0, 0, 100, 100, 0], \"r-\")\n",
        "plt.axis([-10, 110, -10, 110])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lweOya-XSmQf",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/9.jpg?raw=1)\n",
        "\n",
        "- You can also draw simple points instead of lines. Here's an example with green dashes, red dotted line and blue triangles."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qRX5UsIkSmQf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "x = np.linspace(-2.0, 2.0, 30)\n",
        "plt.plot(x, x, 'g--', x, x**2, 'r:', x, x**3, 'b^')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OMo66EIMSmQi",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/10.jpg?raw=1)\n",
        "\n",
        "- Check out the [Matplotlib documentation](http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot) for the full list of style and color options.\n",
        "\n",
        "- The plot function returns a list of `Line2D` objects (one for each line). You can set extra attributes on these lines, such as the **line width**, the **dash style** or the **alpha level**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iWEffTA7SmQi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "x = np.linspace(-2.0, 2.0, 30)\n",
        "line1, line2, line3 = plt.plot(x, x, 'g--', x, x**2, 'r:', x, x**3, 'b^')\n",
        "line1.set_linewidth(3.0)\n",
        "line1.set_dash_capstyle(\"round\")\n",
        "line3.set_alpha(0.2)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fAAKFkklSmQi",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/11.jpg?raw=1)\n",
        "\n",
        "- For a full list of line properties and attributes, refer the [Matplotlib documentation](http://matplotlib.org/users/pyplot_tutorial.html#controlling-line-properties).\n",
        "\n",
        "## Saving a figure\n",
        "\n",
        "- Saving a figure to disk is as simple as calling [`savefig`](http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.savefig) with the name of the file (or a file object). The available image formats depend on the graphics backend you use."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zaMzORDcSmQj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "x = np.linspace(-2.0, 2.0, 30)\n",
        "plt.plot(x, x**2)\n",
        "plt.show()\n",
        "\n",
        "# Save figure\n",
        "plt.savefig(\"my_square_function.png\", transparent=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jg_jrtR-SmQl",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/12.jpg?raw=1)\n",
        "\n",
        "## Subplots\n",
        "\n",
        "- A Matplotlib figure may contain multiple subplots. These subplots are organized in a grid. To create a subplot, just call the `subplot` function, and specify the number of rows and columns in the figure, and the index of the subplot you want to draw on (starting from \\\\(1\\\\), then left to right, and top to bottom). \n",
        "- Note that pyplot keeps track of the currently active subplot (which you can get a reference to by calling `plt.gca()`), so when you call the `plot` function, it draws on the *active* subplot."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ske3w3teSmQl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "x = np.linspace(-2.0, 2.0, 30)\n",
        "\n",
        "plt.subplot(2, 2, 1) # 2 rows, 2 columns, 1st subplot = top left\n",
        "plt.plot(x, x)\n",
        "plt.subplot(2, 2, 2) # 2 rows, 2 columns, 2nd subplot = top right\n",
        "plt.plot(x, x**2)\n",
        "plt.subplot(2, 2, 3) # 2 rows, 2 columns, 3rd subplot = bottow left\n",
        "plt.plot(x, x**3)\n",
        "plt.subplot(2, 2, 4) # 2 rows, 2 columns, 4th subplot = bottom right\n",
        "plt.plot(x, x**4)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "11CJ1SJHSmQp",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/13.jpg?raw=1)\n",
        "\n",
        "- Note that `subplot(223)` is a shorthand for `subplot(2, 2, 3)`.\n",
        "\n",
        "- It is easy to create subplots that span across multiple grid cells like so:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rmBtQfFWSmQp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "plt.subplot(2, 2, 1)  # 2 rows, 2 columns, 1st subplot = top left\n",
        "plt.plot(x, x)\n",
        "plt.subplot(2, 2, 2)  # 2 rows, 2 columns, 2nd subplot = top right\n",
        "plt.plot(x, x**2)\n",
        "plt.subplot(2, 1, 2)  # 2 rows, *1* column, 2nd subplot = bottom\n",
        "plt.plot(x, x**3)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N8BcL831SmQr",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/14.jpg?raw=1)\n",
        "\n",
        "- If you need even more flexibility in subplot positioning, check out the [GridSpec documentation](http://matplotlib.org/users/gridspec.html).\n",
        "\n",
        "- Here's an example that combines subplots with a couple of the other concepts (title, axes limits etc.) that we discussed earlier:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rYBzA-gtSmQr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# Compute the X and Y coordinates for points on sine and cosine curves\n",
        "x = np.arange(-2*np.pi, 2*np.pi, 0.1)\n",
        "y_sin = np.sin(x)\n",
        "y_cos = np.cos(x)\n",
        "\n",
        "# Set up a subplot grid that has height 2 and width 1, \n",
        "# and set the first such subplot as active.\n",
        "# (2, 1, 1) thus indicates total number of rows, columns, and figure number respectively\n",
        "plt.subplot(2, 1, 1)\n",
        "\n",
        "# Make the first plot\n",
        "plt.plot(x, y_sin)\n",
        "plt.title('Sine')\n",
        "\n",
        "# Custom X and Y axis limits for the first subplot\n",
        "plt.xlim(np.ceil(-2*np.pi), np.floor(2*np.pi))\n",
        "plt.ylim(-1,1)\n",
        "\n",
        "# Set the second subplot as active, and make the second plot\n",
        "plt.subplot(2, 1, 2)\n",
        "\n",
        "plt.plot(x, y_cos)\n",
        "plt.title('Cosine')\n",
        "\n",
        "# Custom X and Y axis limits for the second subplot\n",
        "plt.xlim(np.ceil(-2*np.pi), np.floor(2*np.pi))\n",
        "plt.ylim(-1,1)\n",
        "\n",
        "# Automatically adjust padding between subplots\n",
        "# Optionally, pass in a float parameter to specify the amount of padding between subplots\n",
        "plt.tight_layout()\n",
        "\n",
        "# Show the figure.\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jkvh6aevSmQt",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/sine_cosine_subplot.jpg?raw=1)\n",
        "\n",
        "- You can read much more about the `subplot` function in the [Matplotlib documentation](http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.subplot).\n",
        "\n",
        "## Adding text\n",
        "\n",
        "- You can call `text` to add text at any location in the graph. Just specify the horizontal and vertical coordinates and the text, and optionally some extra attributes. \n",
        "- Any text in Matplotlib may contain TeX equation expressions, see the [Matplotlib documentation](http://matplotlib.org/users/mathtext.html) for more details."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5LSG4HCjSmQu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "x = np.linspace(-2, 2, 30)\n",
        "px = 1.414\n",
        "py = px**2\n",
        "\n",
        "plt.plot(x, x**2, \"b-\", px, py, \"ro\")\n",
        "\n",
        "plt.text(0, 3.0, \"Square function\\n$y = x^2$\", fontsize=20, color='blue', horizontalalignment=\"center\")\n",
        "plt.text(px - 0.08, py, \"Beautiful point\", ha=\"right\", weight=\"heavy\")\n",
        "plt.text(px, py, \"x = %0.2f\\ny = %0.2f\"%(px, py), rotation=50, color='gray')\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4mMeoi5NSmQw",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/15.jpg?raw=1)\n",
        "\n",
        "- Note: `ha` is an alias for `horizontalalignment`.\n",
        "- For more text properties, refer the [Matplotlib documentation](http://matplotlib.org/users/text_props.html#text-properties).\n",
        "- It is quite frequent to annotate elements of a graph, such as the beautiful point above. The `annotate` function makes this easy: just indicate the location of the point of interest, and the position of the text, plus optionally some extra attributes for the text and the arrow."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lHQOSMlBSmQy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "x = np.linspace(-2, 2, 30)\n",
        "px = 1.414\n",
        "py = px**2\n",
        "\n",
        "plt.plot(x, x**2, px, py, \"ro\")\n",
        "plt.annotate(\"Beautiful point\", xy=(px, py), xytext=(px-1.5, py+0.5),\n",
        "             color=\"blue\", weight=\"light\", fontsize=14,\n",
        "             arrowprops={\"facecolor\": \"blue\"})\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "REaU1LsASmQ1",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/16.jpg?raw=1)\n",
        "\n",
        "- You can also add a bounding box around your text by using the `bbox` attribute:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "62F6YBFFSmQ1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "x = np.linspace(-2, 2, 30)\n",
        "px = 1.414\n",
        "py = px**2\n",
        "\n",
        "plt.plot(x, x**2, px, py, \"ro\")\n",
        "\n",
        "bbox_props = dict(boxstyle=\"rarrow,pad=0.3\", ec=\"b\", lw=2, fc=\"lightblue\")\n",
        "plt.text(px-0.2, py, \"Beautiful point\", bbox=bbox_props, ha=\"right\")\n",
        "\n",
        "bbox_props = dict(boxstyle=\"round4,pad=1,rounding_size=0.2\", ec=\"black\", fc=\"#EEEEFF\", lw=5)\n",
        "plt.text(0, 3.0, \"Square function\\n$y = x^2$\", fontsize=20, color='black', ha=\"center\", bbox=bbox_props)\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DKmIZMv6SmQ3",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/17.jpg?raw=1)\n",
        "\n",
        "- Just for fun, if you want an [xkcd](http://xkcd.com)-style plot, just call `plt.xkcd()` before you do your plotting!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H_aNLXBkSmQ3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "x = np.linspace(-2, 2, 30)\n",
        "px = 1.414\n",
        "py = px**2\n",
        "\n",
        "with plt.xkcd():\n",
        "    plt.plot(x, x**2, px, py, \"ro\")\n",
        "    bbox_props = dict(boxstyle=\"rarrow,pad=0.3\", ec=\"b\", lw=2, fc=\"lightblue\")\n",
        "    plt.text(px-0.2, py, \"Beautiful point\", bbox=bbox_props, ha=\"right\")\n",
        "    bbox_props = dict(boxstyle=\"round4,pad=1,rounding_size=0.2\", ec=\"black\", fc=\"#EEEEFF\", lw=5)\n",
        "    plt.text(0, 3.0, \"Square function\\n$y = x^2$\", fontsize=20, color='black', ha=\"center\", bbox=bbox_props)\n",
        "    plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2po9oUfKSmQ5",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/18.jpg?raw=1)\n",
        "\n",
        "- For more examples on xkcd plots, check [\"XKCD Plots have Landed in Matplotlib!\"](https://jakevdp.github.io/blog/2013/07/10/XKCD-plots-in-matplotlib/)\n",
        "\n",
        "## Legends\n",
        "\n",
        "- The simplest way to add a legend is to set a label on all lines, then just call the `legend` function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1-58Ds4BSmQ6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "x = np.linspace(-2, 2, 50)\n",
        "plt.plot(x, x**2, \"r--\", label=\"Square function\")\n",
        "plt.plot(x, x**3, \"g-\", label=\"Cube function\")\n",
        "plt.legend(loc=\"best\")\n",
        "plt.grid(True)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sQnCDwacSmQ9",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/19.jpg?raw=1)\n",
        "\n",
        "## Fonts\n",
        "\n",
        "- To change the font size of the legend, axis title or plot title of a Matplotlib plot, override their respective `fontsize` arguments:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "il1nR5kXSmQ9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "x = np.linspace(-2, 2, 50)\n",
        "plt.plot(x, x**2, \"r--\", label=\"Square function\")\n",
        "\n",
        "# Add a legend\n",
        "plt.legend(['Square plot'], fontsize=7)\n",
        "\n",
        "# Set X and Y Labels\n",
        "plt.xlabel('x', fontsize=12)\n",
        "plt.ylabel('x^2', fontsize=12)\n",
        "\n",
        "# Add a plot title\n",
        "plt.title('Square function', fontsize=15)\n",
        "\n",
        "plt.grid(True)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H-ZdG2PqSmRL",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/29.jpg?raw=1)\n",
        "\n",
        "- Note that with the above method you can set the font size for each plot attribute (legend, axis title, plot title etc.) individually at creation (allowing you to have multiple plots in the same Python source with different font sizes for each of their attributes). \n",
        "- However, if you wish to set the same attributes for all plots in the same Python session/source, you can set the sizes calling the `rc` (runtime commands) method on Matplotlib:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fb-AcHBqSmRM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "SMALL_SIZE = 7\n",
        "MEDIUM_SIZE = 10 # Default Matplotlib font size\n",
        "BIGGER_SIZE = 15\n",
        "\n",
        "plt.rc('font', size=SMALL_SIZE)         # Controls default text sizes\n",
        "plt.rc('axes', titlesize=SMALL_SIZE)    # Font size of the axes title\n",
        "plt.rc('axes', labelsize=MEDIUM_SIZE)   # Font size of the x and y labels\n",
        "plt.rc('xtick', labelsize=SMALL_SIZE)   # Font size of the tick labels\n",
        "plt.rc('ytick', labelsize=SMALL_SIZE)   # Font size of the tick labels\n",
        "plt.rc('legend', fontsize=SMALL_SIZE)   # Legend font size\n",
        "plt.rc('figure', titlesize=BIGGER_SIZE) # Font size of the figure title\n",
        "\n",
        "x = np.linspace(-2, 2, 50)\n",
        "plt.plot(x, x**2, \"r--\", label=\"Square function\")\n",
        "\n",
        "# Add a legend\n",
        "plt.legend(['Square plot'])\n",
        "\n",
        "# Set X and Y Labels\n",
        "plt.xlabel('x')\n",
        "plt.ylabel('x^2')\n",
        "\n",
        "# Add a plot title\n",
        "plt.suptitle('Square function')\n",
        "\n",
        "plt.grid(True)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DdSDKeCpSmRN",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/30.jpg?raw=1)\n",
        "\n",
        "- For a full list of rcParams, refer the [Matplotlib documentation](https://matplotlib.org/tutorials/introductory/customizing.html).\n",
        "\n",
        "## Non-linear scales\n",
        "\n",
        "- Matplotlib supports non linear scales, such as logarithmic or logit scales."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QdeMuyhHSmRO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "x = np.linspace(0.1, 15, 500)\n",
        "y = x**3/np.exp(2*x)\n",
        "\n",
        "plt.figure(1)\n",
        "plt.plot(x, y)\n",
        "plt.yscale('linear')\n",
        "plt.title('linear')\n",
        "plt.grid(True)\n",
        "\n",
        "plt.figure(2)\n",
        "plt.plot(x, y)\n",
        "plt.yscale('log')\n",
        "plt.title('log')\n",
        "plt.grid(True)\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eFlhv9SMSmRR",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/21.jpg?raw=1)\n",
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/22.jpg?raw=1)\n",
        "\n",
        "## Histograms\n",
        "\n",
        "- As an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9h1DUBanSmRT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "data = [1, 1.1, 1.8, 2, 2.1, 3.2, 3, 3, 3, 3]\n",
        "plt.subplot(211)\n",
        "plt.hist(data, bins = 10, rwidth=0.8)\n",
        "\n",
        "plt.subplot(212)\n",
        "plt.hist(data, bins = [1, 1.5, 2, 2.5, 3], rwidth=0.95)\n",
        "plt.xlabel(\"Value\")\n",
        "plt.ylabel(\"Frequency\")\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cKRJ4Zg8SmRX",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/23.jpg?raw=1)\n",
        "\n",
        "- Another example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dHU_cbFtSmRX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "data1 = np.random.randn(400)\n",
        "data2 = np.random.randn(500) + 3\n",
        "data3 = np.random.randn(450) + 6\n",
        "data4a = np.random.randn(200) + 9\n",
        "data4b = np.random.randn(100) + 10\n",
        "\n",
        "plt.hist(data1, bins=5, color='g', alpha=0.75, label='bar hist') # default histtype='bar'\n",
        "plt.hist(data2, color='b', alpha=0.65, histtype='stepfilled', label='stepfilled hist')\n",
        "plt.hist(data3, color='r', histtype='step', label='step hist')\n",
        "plt.hist((data4a, data4b), color=('r','m'), alpha=0.55, histtype='barstacked', label=('barstacked a', 'barstacked b'))\n",
        "\n",
        "plt.xlabel(\"Value\")\n",
        "plt.ylabel(\"Frequency\")\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kYByDbHRSmRd",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/24.jpg?raw=1)\n",
        "\n",
        "## Images\n",
        "\n",
        "- You can use the `imshow` function to show images. Here is an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_hp_I3PySmRf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from scipy.misc import imread, imresize\n",
        "\n",
        "img = imread('cat.jpg')\n",
        "img_tinted = img * [1, 0.95, 0.9]\n",
        "\n",
        "# Show the original image\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.imshow(img)\n",
        "\n",
        "# Show the tinted image\n",
        "plt.subplot(1, 2, 2)\n",
        "\n",
        "# A slight gotcha with imshow is that it might give strange results\n",
        "# if presented with data that is not uint8. To work around this, we\n",
        "# explicitly cast the image to uint8 before displaying it.\n",
        "plt.imshow(np.uint8(img_tinted))\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0dl70X7pSmRi",
        "colab_type": "text"
      },
      "source": [
        "![](/assets/matplotlib/cat_tinted_imshow.jpg)\n",
        "\n",
        "- It's just as easy to generate your own image:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cPYtWSc5SmRi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "img = np.arange(100*100).reshape(100, 100)\n",
        "plt.imshow(img)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r5IqeAM0SmRl",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/25.jpg?raw=1)\n",
        "\n",
        "- As we did not provide RGB levels, the `imshow` function automatically maps values to a color gradient. By default, the color gradient goes from blue (for low values) to red (for high values), but you can select another color map. For e.g.:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QlkkLvhiSmRm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "img = np.arange(100*100).reshape(100, 100)\n",
        "plt.imshow(img, cmap=\"hot\")\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0LR_1UXSSmRo",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/26.jpg?raw=1)\n",
        "\n",
        "- You can also generate an RGB image directly:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yz6YrUdMSmRp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "img = np.empty((20, 30, 3))\n",
        "\n",
        "# 1, 0, 0 for the color red\n",
        "img[:, :10] = [1, 0, 0]\n",
        "\n",
        "# 0, 1, 0 for the color green\n",
        "img[:, 10:20] = [0, 1, 0]\n",
        "\n",
        "# 0, 0, 1 for the color blue\n",
        "img[:, 20:] = [0, 0, 1]\n",
        "plt.imshow(img)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8IxRy-isSmRr",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/27.jpg?raw=1)\n",
        "\n",
        "- Since the `img` array is just quite small, i.e., of size \\\\(20 \\times 30\\\\), when the `imshow` function displays it, it grows the image to the figure's size. Imagine stretching the original image, leaving blanks between the original pixels. How does `imshow` fill the blanks? By default, it just colors each blank pixel using the color of the nearest non-blank pixel. This technique can lead to pixelated images. \n",
        "- If you prefer, you can use a different interpolation method, such as [bilinear interpolation](https://en.wikipedia.org/wiki/Bilinear_interpolation) to fill the blank pixels. This leads to blurry edges, which many be nicer in some cases:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cAP6mYleSmRr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "img = np.empty((20,30,3))\n",
        "img[:, :10] = [1, 0, 0]\n",
        "img[:, 10:20] = [0, 1, 0]\n",
        "img[:, 20:] = [0, 0, 1]\n",
        "plt.imshow(img, interpolation=\"bilinear\")\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LWGZRMPpSmRu",
        "colab_type": "text"
      },
      "source": [
        "![](https://github.com/amanchadha/aman-ai/blob/master/assets/matplotlib/28.jpg?raw=1)\n",
        "\n",
        "## References and Credits\n",
        "\n",
        "- Aurélien Geron's [Notebook on Matplotlib](https://github.com/ageron/handson-ml2/blob/master/tools_matplotlib.ipynb) and [Hands-on Machine Learning with Scikit-Learn, Keras and TensorFlow](https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/) served as a major inspiration for this tutorial.\n",
        "- Parts of this tutorial were originally contributed by [Justin Johnson](http://cs.stanford.edu/people/jcjohns/).\n",
        "- Stanford's [CS231N Python/Numpy Tutorial](https://cs231n.github.io/python-numpy-tutorial/).\n",
        "- [Matplotlib documentation](https://matplotlib.org/api/index.html).\n",
        "- [How to set the spacing between subplots in Matplotlib in Python](https://www.kite.com/python/answers/how-to-set-the-spacing-between-subplots-in-matplotlib-in-python)\n",
        "- [Improve subplot size/spacing with many subplots in Matplotlib](https://stackoverflow.com/questions/6541123/improve-subplot-size-spacing-with-many-subplots-in-matplotlib)\n",
        "- [Why do many examples use `fig, ax = plt.subplots()` in Matplotlib/pyplot/python?](https://stackoverflow.com/questions/34162443/why-do-many-examples-use-fig-ax-plt-subplots-in-matplotlib-pyplot-python)\n",
        "- [How to change the font size on a matplotlib plot?](https://stackoverflow.com/questions/3899980/how-to-change-the-font-size-on-a-matplotlib-plot)\n",
        "- [How to change legend size with matplotlib.pyplot?](https://stackoverflow.com/questions/7125009/how-to-change-legend-size-with-matplotlib-pyplot)\n",
        "- [PyPlot Legend only displaying one letter](https://stackoverflow.com/questions/44632571/pyplot-legend-only-displaying-one-letter)\n",
        "\n",
        "## Citation\n",
        "\n",
        "If you found our work useful, please cite it as:\n",
        "\n",
        "```\n",
        "@article{Chadha2020DistilledMatplotLibTutorial,\n",
        "  title   = {MatplotLib Tutorial},\n",
        "  author  = {Chadha, Aman},\n",
        "  journal = {Distilled AI},\n",
        "  year    = {2020},\n",
        "  note    = {\\url{https://aman.ai}}\n",
        "}\n",
        "```"
      ]
    }
  ]
}