01_Vectors,_Matrices,_and_Arrays.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyODiLvU1G3pEugnmnhdcWYX",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ChrisMunyi/git_practice/blob/master/01_Vectors%2C_Matrices%2C_and_Arrays.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Vectors, Matrices, and Arrays\n",
        "##1.0 Introduction\n",
        "NumPy is the foundation of the Python machine learning stack. NumPy allows for efficient operations on he data structures often used in machine learning: vectors, matrices, and tensors. While NumPy is not the focus of this book, it will show up frequently throughout the following chapters. This chapter covers the most common NumPy operations we are likely to run into while working on machine learning workflows."
      ],
      "metadata": {
        "id": "RSsK1E1VVgF6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.1 Creating a Vector\n",
        "\n",
        "###Problem\n",
        "You need to create a vector\n",
        "\n",
        "###Solution\n",
        "Use NumPy to create a one-dimensional array:"
      ],
      "metadata": {
        "id": "wTTokVsUV2h5"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jJxwO1R0VT4E"
      },
      "outputs": [],
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create a vector as a raw\n",
        "vector_row = np.array([1, 2, 3])\n",
        "\n",
        "# Create a vector as a column\n",
        "vector_column = np.array([[1],\n",
        "                          [2],\n",
        "                          [3]])"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "NumPy's main data structure is the multidimensional array. To create a vector, we simply create a one-dimensional array. Just like vectors, these arrays can be represented horizontally (i.e., rows) or vertically (i.e., columns)"
      ],
      "metadata": {
        "id": "HTZ9khxRWTna"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.2 Creating a Matrix\n",
        "\n",
        "### Problem\n",
        "You need to create a matrix\n",
        "\n",
        "### Solution\n",
        "Use NumPy to create a two-dimensional array:"
      ],
      "metadata": {
        "id": "-lR3atYmWpGp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create a matrix\n",
        "matrix = np.array([[1, 2],\n",
        "                   [1, 2],\n",
        "                   [1, 2]])"
      ],
      "metadata": {
        "id": "jJfiyRqjW1Sh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Discussion\n",
        "To create a matrix we can use a NumPy two-dimensional array. In our solution, the matrix contains three rows and two columns (a column of 1s and a column of 2s).\n",
        "NumPy actually has a dedicated matrix data structure"
      ],
      "metadata": {
        "id": "hIboNQUjVd6T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "matrix_object = np.mat([[1, 2],\n",
        "                        [1, 2],\n",
        "                        [1, 2]])\n",
        "matrix_object"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vgaZhxweXOJg",
        "outputId": "1ce68a44-7bdd-4f83-e801-f9e852d7d0f1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "matrix([[1, 2],\n",
              "        [1, 2],\n",
              "        [1, 2]])"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "However, the matrix data structure is not recommended for two reasons. First, arrays are the de facto standard data structure of NumPy. Second, the vast majority of NumPy operations return arrays, not matrix objects."
      ],
      "metadata": {
        "id": "fVpjMhRAXktb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1.3 Creating a Sparse Matrix\n",
        "\n",
        "###Problem\n",
        "Given data with very few nonzero values, you want to efficiently represent it.\n",
        "\n",
        "###Solution\n",
        "Create a sparse matrix:"
      ],
      "metadata": {
        "id": "8NW1pbcVXprG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load libraries:\n",
        "import numpy as np\n",
        "from scipy import sparse\n",
        "\n",
        "# Create a matrix\n",
        "matrix = np.array([[0, 0],\n",
        "                   [0, 1],\n",
        "                   [3, 0]])\n",
        "\n",
        "# Create compressed sparse row (CSR) matrix\n",
        "matrix_sparse = sparse.csr_matrix(matrix)"
      ],
      "metadata": {
        "id": "w-DQP8Z1Xtkz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "A frequent situation in machine learning is having a huge amount of data; however, most of the elements in the data are zeros. For example, imagine a matrix where the columns are every movie on Netflix, the rows are every Netflix user, and the values are how many times a user has watched that particular movie. This matrix would have tens of thousands of columns and millions of rows! However, since most users do not watch most movies, the vast majority of elements would be zero.\n",
        "\n",
        "Sparse matrices only store nonzero elements and assume all other values will be zero, leading to significant computational savings. In our solution, we created a NumPy array with two nonzero values, then converted it into a sparse matrix.If we view the sparse matrix we can see that only the nonzero values are stored:"
      ],
      "metadata": {
        "id": "cS9K2L2nYRZ5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# View sparse matrix\n",
        "print(matrix_sparse)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CPtEiJobYmtJ",
        "outputId": "f62e15d0-bfd1-4bd9-9c8f-0407850bd031"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "  (1, 1)\t1\n",
            "  (2, 0)\t3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "There are a number of types of sparse matrices. However, in _compressed sparse row_ (CSR) matrices, (`1`, `1`) and (`2`, `0`) represent the (zero-indexed) indices of the nonzero values `1` and `3`, respectively. For example, the element `1` is in the second row and second column. We can see the advantage of sparse matrices if we create a much larger matrix with many more zero elements and then compare this larger matrix with our original sparse matrix:"
      ],
      "metadata": {
        "id": "c30ncU1rYwGg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create larger matrix\n",
        "matrix_large = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
        "                         [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],\n",
        "                         [3, 0, 0, 0, 0, 0, 0, 0, 0, 0]])\n",
        "\n",
        "# Create compressed sparse row (CSR) matrix\n",
        "matrix_large_sparse = sparse.csr_matrix(matrix_large)\n",
        "\n",
        "# View original sparse\n",
        "print(matrix_sparse)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CSw9junWZGg0",
        "outputId": "af9dbd25-cb4a-434b-85a6-8b51f654cc16"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "  (1, 1)\t1\n",
            "  (2, 0)\t3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# View larger sparse matrix\n",
        "print(matrix_large_sparse)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5DmBTET0Z8-h",
        "outputId": "1fa2322e-29d7-44ab-ac76-7ba79c77680c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "  (1, 1)\t1\n",
            "  (2, 0)\t3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see, despite the fact that we added many more zero elements in the larger matrix, its sparse representation is exactly the same as our original sparse matrix. That is, the addition of zero elements did not change the size of the sparse matrix.\n",
        "\n",
        "As mentioned, there are many different types of sparse matrices, such as compressed sparse column, list of lists, and dictionary of keys. While an explanation of the different types and their implications is outside the scope of this book, it is worth noting that while there is no “best” sparse matrix type, there are meaningful differences between them and we should be conscious about why we are choosing one type over another."
      ],
      "metadata": {
        "id": "PsUJSa3CaGid"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.4 Selecting Elements\n",
        "\n",
        "###Problem\n",
        "You need to select one or more elements in a vector or matrix.\n",
        "\n",
        "###Solution\n",
        "NumPy’s arrays make that easy:"
      ],
      "metadata": {
        "id": "ElCfdmDyaUkt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create row cector\n",
        "vector = np.array([1, 2, 3, 4, 5, 6])\n",
        "\n",
        "# Create matrix\n",
        "matrix = np.array([[1, 2, 3],\n",
        "                   [4, 5, 6],\n",
        "                   [7, 8, 9]])\n",
        "# Select third element of vector\n",
        "vector[2]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kH8j8oxmahm0",
        "outputId": "8f54c445-1b98-469a-beef-2c6b4f32885b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Select second row, second column\n",
        "matrix[1, 1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uW_wFT7Fa4Zb",
        "outputId": "d3a791e6-5c91-4b94-d60b-a1c1dacbc959"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "Like most things in Python, NumPy arrays are zero-indexed, meaning that the index of the first element is 0, not 1. With that caveat, NumPy offers a wide variety of methods for selecting (i.e., indexing and slicing) elements or groups of elements in arrays:"
      ],
      "metadata": {
        "id": "ZCGTXA6ma_mj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Select all elements of a vector\n",
        "vector[:]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U_4ayN0nbClb",
        "outputId": "424bc806-1769-46ae-a375-46a73947b802"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5, 6])"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Select everything up to and including the third element\n",
        "vector[:3]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jiokRgtQbVZL",
        "outputId": "ffdb280c-5eb1-4dcd-de13-410ec362f561"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Select everything after the third element\n",
        "vector[3:]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3cUaDZCcbY1a",
        "outputId": "2cd00e8e-868a-4ecb-ac8d-43b83d7ee0b6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([4, 5, 6])"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Select the last element\n",
        "vector[-1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PIjz3h5BbdK5",
        "outputId": "d702c079-e2fa-4a92-ec27-8ddd43febd0f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Select the first two rows and all columns of a matrix\n",
        "matrix[:2,:]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zSAoIWlRbmVS",
        "outputId": "4898a3db-14aa-4596-c402-c5568cb2d53b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Select all rows and the second column\n",
        "matrix[:,1:2]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iokXMhNQbuTa",
        "outputId": "a7e9764b-d369-4786-99c8-50c4cd4c2204"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[2],\n",
              "       [5],\n",
              "       [8]])"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.5 Describing a Matrix\n",
        "\n",
        "###Problem\n",
        "You want to describe the shape, size, and dimensions of the matrix\n",
        "\n",
        "###Solution\n",
        "Use `shape`, `size`, and `ndim`:"
      ],
      "metadata": {
        "id": "OvigJYbmb1ZE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix = np.array([[1, 2, 3, 4],\n",
        "                   [5, 6, 7, 8],\n",
        "                   [9, 10, 11, 12]])"
      ],
      "metadata": {
        "id": "Rz75uCyxcHj4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# View number of rows and columns\n",
        "matrix.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5PLF0jJYcQ54",
        "outputId": "1b696ef1-10fd-4d90-bf78-80b1132f3cf0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(3, 4)"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# View number of elements (rows * columns)\n",
        "matrix.size"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nAC0F0JtcdjP",
        "outputId": "43565f68-80e8-4265-9f94-6873fb097654"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# View number of dimensions\n",
        "matrix.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z4hrj2L-ceZ_",
        "outputId": "5783a31d-bc06-4fdd-804a-8dcb5c55b9d8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "This might seem basic (and it is); however, time and again it will be valuable to check the shape and size of an array both for further calculations and simply as a gut check after some operation."
      ],
      "metadata": {
        "id": "f019Q_21ckfg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.6 Applying Operations to Elements\n",
        "\n",
        "###Problem\n",
        "You want to apply some function to multiple elements in an array."
      ],
      "metadata": {
        "id": "Dg-Pa8kkcq83"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix = np.array([[1, 2, 3],\n",
        "                   [4, 5, 6],\n",
        "                   [7, 8, 9]])"
      ],
      "metadata": {
        "id": "x3KLxo59cxQG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create function that adds 100 to something\n",
        "add_100 = lambda i: i + 100\n",
        "\n",
        "# Create vectorized function\n",
        "vectorized_add_100 = np.vectorize(add_100)\n",
        "\n",
        "# Apply function to all elements in matrix\n",
        "vectorized_add_100(matrix)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OgCBkitPc7RQ",
        "outputId": "06f4ee29-3d4f-4421-e7a0-a0875d865600"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[101, 102, 103],\n",
              "       [104, 105, 106],\n",
              "       [107, 108, 109]])"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "NumPy's `vectorize` class converts a function into a function that can apply to all elements in an array or slice of an array. It's worth noting that `vectorize` is essentially a for loop over the elements and does not increase performance. Furthermore, NumPy arrays allow us to perform operations between arrays even if their dimensions are not the same (a process called _broadcasting_). For example, we can create a much simpler version of our solution using broadcasting:"
      ],
      "metadata": {
        "id": "jAgUMa2ldT7E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Add 100 to all elements\n",
        "matrix + 100"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ssyQmheJdDN3",
        "outputId": "7941f3f1-4790-42da-a756-1e7e93cbb58a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[101, 102, 103],\n",
              "       [104, 105, 106],\n",
              "       [107, 108, 109]])"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.7 Finding the Maximum and Minimum Values\n",
        "\n",
        "###Problem\n",
        "You need to find the maximum or minimum value in an array.\n",
        "\n",
        "###Solution\n",
        "Use NumPy's `max` and `min`:"
      ],
      "metadata": {
        "id": "P7o3-1JRdlyE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix = np.array([[1, 2, 3],\n",
        "                   [4, 5, 6],\n",
        "                   [7, 8, 9]])\n",
        "\n",
        "# Return maximum element\n",
        "np.max(matrix)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H6D1wfW6dIjd",
        "outputId": "c32d739c-c480-4ca1-c275-8f62dfa7ea88"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Return minimum elemnt\n",
        "np.min(matrix)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8JwU6Zkfd8d1",
        "outputId": "e47fd7e6-3e89-47ef-dead-ebd8979a4500"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "Often we want to know the maximum and minimum value in an array or subset of an\n",
        "array. This can be accomplished with the `max` and `min` methods. Using the `axis` parameter we can also apply the operation along a certain axis:"
      ],
      "metadata": {
        "id": "nSJ4Fm-jeB1z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Find maximum element in each column\n",
        "np.max(matrix, axis=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "01jwGxcKeIOs",
        "outputId": "1804e684-4c22-4375-ed45-c55380936d21"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([7, 8, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find maximum element in each row\n",
        "np.max(matrix, axis=1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wlnH0OwjeOYj",
        "outputId": "39aa10de-68f1-4356-9817-6b8b4f510bdd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([3, 6, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.8 Calculating the Average, Variance, and Standard Deviation\n",
        "\n",
        "###Problem\n",
        "You want to calculate some descriptive statistics about an array.\n",
        "\n",
        "###Solution\n",
        "Use NumPy's mean, var, and std:"
      ],
      "metadata": {
        "id": "N3C5KnHMeVSi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix = np.array([[1, 2, 3],\n",
        "                   [4, 5, 6],\n",
        "                   [7, 8, 9]])\n",
        "# Return mean\n",
        "np.mean(matrix)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4WxTqKO5ecuR",
        "outputId": "49b89f18-6d9c-4b1a-b9d2-24ca889b6a3c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.0"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Return variance\n",
        "np.var(matrix)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L7coO57HenyB",
        "outputId": "2649809f-18f5-4b40-c1b3-3a06b43c48db"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6.666666666666667"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Return standard deviation\n",
        "np.std(matrix)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WHai9hoPep-Z",
        "outputId": "7b6cf599-a42f-453a-8f88-a5dbb1177c9d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2.581988897471611"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "Just like with `max` and `min`, we can easily get descriptive statistics about the whole matrix or do calculations along a single axis:"
      ],
      "metadata": {
        "id": "o4p_SENGfGdw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the mean value in each column\n",
        "np.mean(matrix, axis=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f-SbmcLHfLLQ",
        "outputId": "576d9277-e2c2-483c-eeae-5953c757ae1d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([4., 5., 6.])"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.9 Reshaping Arrays\n",
        "\n",
        "###Problem\n",
        "You want to change the shape (number of rows and columns) of an array without changing the element values.\n",
        "\n",
        "###Solution\n",
        "Use NumPy's `reshape`:"
      ],
      "metadata": {
        "id": "ms0db50Aflbn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create 4x3 matrix\n",
        "matrix = np.array([[1, 2, 3],\n",
        "                   [4, 5, 6],\n",
        "                   [7, 8, 9],\n",
        "                   [10, 11, 12]])\n",
        "\n",
        "# Reshape matrix into 2x6 matrix\n",
        "matrix.reshape(2, 6)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oT_vog6_ftCg",
        "outputId": "f5db20fb-e751-43c4-8f5a-ed7b5105980c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1,  2,  3,  4,  5,  6],\n",
              "       [ 7,  8,  9, 10, 11, 12]])"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "`reshape` allows us to restructure an array so that we maintain the same data but it is organized as a different number of rows and columns. The only requirement is that the shape of the original and new matrix contain the same number of elements (i.e., the same size). We can see the size of a matrix using `size`:"
      ],
      "metadata": {
        "id": "59NGwpyUf9MW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "matrix.size"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HzKDxE_TgDo1",
        "outputId": "aa0509f0-3534-4df4-aded-abd8a4e21697"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "One useful argument in `reshape` is `-1`, which effectively means “as many as needed,” so `reshape(-1, 1)` means one row and as many columns as needed:"
      ],
      "metadata": {
        "id": "GdgeaSi8gGYt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "matrix.reshape(1, -1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZmaZsq2NgQrF",
        "outputId": "877762a7-407e-43cb-9c6d-9378be67f7a0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12]])"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finally, if we provide one integer, `reshape` will return a 1D array of that length:"
      ],
      "metadata": {
        "id": "lrPwYkkhgU88"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "matrix.reshape(12)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hDTqMypngXQV",
        "outputId": "9728808f-31ac-442e-a244-f179c90314d7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.10 Transposing a Vector or Matrix\n",
        "\n",
        "###Problem\n",
        "You need to transpose a vector or matrix.\n",
        "\n",
        "###Solution\n",
        "Use the `T` method:"
      ],
      "metadata": {
        "id": "oP1kZpvqgcFs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix = np.array([[1, 2, 3],\n",
        "                   [4, 5, 6],\n",
        "                   [7, 8, 9]])\n",
        "\n",
        "# Transpose matrix\n",
        "matrix.T"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uoTkMJPiggmU",
        "outputId": "bad6f0b9-5315-4252-a261-5ca5500d5d2a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 4, 7],\n",
              "       [2, 5, 8],\n",
              "       [3, 6, 9]])"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "Transposing is a common operation in linear algebra where the column and row indices of each element are swapped. One nuanced point that is typically overlooked outside of a linear algebra class is that, technically, a vector cannot be transposed because it is just a collection of values:"
      ],
      "metadata": {
        "id": "teWb0y1uhGyC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Transpose vector\n",
        "np.array([1, 2, 3, 4, 5, 6]).T"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X0gosVabhMeD",
        "outputId": "3e62edf8-ae07-4412-bc14-bd358b50e783"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5, 6])"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "However, it is common to refer to transposing a vector as converting a row vector to a column vector (notice the second pair of brackets) or vice versa:"
      ],
      "metadata": {
        "id": "vW8lJp0qhYJU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Transpose row vector\n",
        "np.array([[1, 2, 3, 4, 5, 6]]).T"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8-rNzaHFhaHh",
        "outputId": "7e241905-9cea-47c1-ef46-e873059a6e9f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1],\n",
              "       [2],\n",
              "       [3],\n",
              "       [4],\n",
              "       [5],\n",
              "       [6]])"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.11 Flattening a Matrix\n",
        "\n",
        "###Problem\n",
        "You need to transform a matrix into a one-dimensional array.\n",
        "\n",
        "###Solution\n",
        "Use `flatten`:"
      ],
      "metadata": {
        "id": "AwC3xybGhnu8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix = np.array([[1, 2, 3],\n",
        "                   [4, 5, 6],\n",
        "                   [7, 8, 9]])\n",
        "\n",
        "# Flatten matrix\n",
        "matrix.flatten()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XCOGnXE8hs5g",
        "outputId": "4effdb21-6470-4a8d-8e77-ddf2caa8f978"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "`flatten` is a simple method to transform a matrix into a one-dimensional array.\n",
        "Alternatively, we can use `reshape` to create a row vector:"
      ],
      "metadata": {
        "id": "59nTuqvRiNfo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "matrix.reshape(1, -1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yOvIndsUiRZ4",
        "outputId": "28e924ca-e810-46ef-9b23-9938603e8760"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.12 Finding the Rank of a Matrix\n",
        "\n",
        "###Problem\n",
        "You need to know the rank of a matrix.\n",
        "\n",
        "###Solution\n",
        "Use NumPy's linear algebra method `matrix_rank`:"
      ],
      "metadata": {
        "id": "6hpyVaT5iXu_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix = np.array([[1, 1, 1],\n",
        "                   [1, 1, 10],\n",
        "                   [1, 1, 15]])\n",
        "\n",
        "# Return matrix rank\n",
        "np.linalg.matrix_rank(matrix)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dOxsqvjEicTw",
        "outputId": "e2fee9fb-048a-4001-ea1b-0a965bd068ab"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "The rank of a matrix is the dimensions of the vector space spanned by its columns or rows. Finding the rank of a matrix is easy in NumPy thanks to `matrix_rank`."
      ],
      "metadata": {
        "id": "9OpHxq30iv0g"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.13 Calculating the Determinant\n",
        "\n",
        "###Problem\n",
        "You need to know the determinant of a matrix.\n",
        "\n",
        "###Solution\n",
        "Use NumPy's linear algebra method `det`:\n"
      ],
      "metadata": {
        "id": "T2hdMPw1i8e_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix = np.array([[1, 2, 3],\n",
        "                   [2, 4, 6],\n",
        "                   [3, 8, 9]])\n",
        "\n",
        "# Return determinant of matrix\n",
        "np.linalg.det(matrix)"
      ],
      "metadata": {
        "id": "wH9a4gWfjCT2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "It can sometimes be useful to calculate the determinant of a matrix. NumPy makes\n",
        "this easy with `det`."
      ],
      "metadata": {
        "id": "kyjj73l3jT2h"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.14 Getting the Diagonal of a Matrix\n",
        "\n",
        "###Problem\n",
        "You need to get the diagonal elements of a matrix.\n",
        "\n",
        "###Solution\n",
        "Use `diagonal`:"
      ],
      "metadata": {
        "id": "Jb8tl4CgjdNb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix = np.array([[1, 2, 3],\n",
        "                   [2, 4, 6],\n",
        "                   [3, 8, 9]])\n",
        "\n",
        "# Return diagonal elements\n",
        "matrix.diagonal()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7THVGB3pjjS0",
        "outputId": "39eceebb-9660-46c4-ea13-3945d2c89c56"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 4, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "NumPy makes getting the diagonal elements of a matrix easy with `diagonal`. It is also possible to get a diagonal off from the main diagonal by using the `offset` parameter:"
      ],
      "metadata": {
        "id": "EVFlckH2j0Ok"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Return diagonal one above the main diagonal\n",
        "matrix.diagonal(offset=1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BRc4jDIbj6U7",
        "outputId": "e7820915-f697-4ad4-e7ca-d947bc4ba3f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2, 6])"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Return diagonal one below the main diagonal\n",
        "matrix.diagonal(offset=-1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EwhlDLnhj9Bb",
        "outputId": "a28105df-9513-4067-c634-9d6f21af3718"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2, 8])"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.15 Calculating the Trace of a Matrix\n",
        "\n",
        "###Problem\n",
        "You need to calculate the trace of a matrix.\n",
        "\n",
        "###Solution\n",
        "Use `trace`:"
      ],
      "metadata": {
        "id": "yZ4zQYzDkmj4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix = np.array([[1, 2, 3],\n",
        "                   [2, 4, 6],\n",
        "                   [3, 8, 9]])\n",
        "\n",
        "# Return trace\n",
        "matrix.trace()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c7efmncLksyy",
        "outputId": "2ee71554-0009-4e21-f847-86ac81c90816"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "The trace of a matrix is the sum of the diagonal elements and is often used under the hood in machine learning methods. Given a NumPy multidimensional array, we can calculate the trace using `trace`. We can also return the diagonal of a matrix and calculate its sum:"
      ],
      "metadata": {
        "id": "Y1TQyzkek8Fg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Return diagonal and sum elements\n",
        "sum(matrix.diagonal())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vgf-W3k5lGKw",
        "outputId": "058fe956-37e1-4afb-d95d-2ca05aa3120a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.16 Finding Eigenvalues and Eigenvectors\n",
        "\n",
        "###Problem\n",
        "You need to find the eigenvalues and eigenvectors of a square matrix.\n",
        "\n",
        "###Solution\n",
        "Use NumPy's `linalg.eig`:"
      ],
      "metadata": {
        "id": "3CCN6SXAlIg_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix = np.array([[1, -1, 3],\n",
        "                   [1, 1, 6],\n",
        "                   [3, 8, 9]])\n",
        "\n",
        "# Calculate eigenvalues and eigenvectors\n",
        "eigenvalues, eigenvectors = np.linalg.eig(matrix)\n",
        "# View eigenvalues\n",
        "eigenvalues"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p1WPB7nXlO9f",
        "outputId": "9bd6e1de-7759-4d29-f57a-ee522525f3f3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([13.55075847,  0.74003145, -3.29078992])"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# View eigenvectors\n",
        "eigenvectors"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-ALPB1-ilgE_",
        "outputId": "260d74cb-4df8-436c-c206-e610cbb24dd1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-0.17622017, -0.96677403, -0.53373322],\n",
              "       [-0.435951  ,  0.2053623 , -0.64324848],\n",
              "       [-0.88254925,  0.15223105,  0.54896288]])"
            ]
          },
          "metadata": {},
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Discussion\n",
        "Eigenvectors are widely used in machine learning libraries. Intuitively, given a linear transformation represented by a matrix, $A$, eigenvectors are vectors that, when that transformation is applied, change only in scale (not direction). More formally:\n",
        "\n",
        "\\begin{align}\n",
        "  A{v} = \\lambda{v}\n",
        "\\end{align}\n",
        "\n",
        "\n",
        "where $A$ is a square matrix, $\\lambda$ contains the eigenvalues and $v$ contains the eigenvectors. In NumPy's linear algebra toolset, `eig` lets us calculate the eigenvalues, and eigenvectors of any square matrix."
      ],
      "metadata": {
        "id": "AxZyvw-FlnCv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.17 Calculating Dot Products\n",
        "\n",
        "###Problem\n",
        "You need to calculate the dot product of two vectors.\n",
        "\n",
        "###Solution\n",
        "Use NumPy's `dot`:"
      ],
      "metadata": {
        "id": "G4MzGJ8tsp4V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create two vectors\n",
        "vector_a = np.array([1,2,3])\n",
        "vector_b = np.array([4,5,6])\n",
        "\n",
        "# Calculate dot product\n",
        "np.dot(vector_a, vector_b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SdZ194ydsyN8",
        "outputId": "f2c126b3-cb15-4ba3-9f45-6feb5f81e326"
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "32"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Discussion\n",
        "The dot product of two vectors, $a$ and $b$, is defined as:\n",
        "\n",
        "\\begin{align}\n",
        "\\sum_{i=1} ^{n} a_i b_i\n",
        "\\end{align}\n",
        "\n",
        "where $a_i$ is the $i$th element of vector $a$. We can use NumPy's `dot` class to calculate the dot product. Alternatively, in Python 3.5+ we can use the new `@` operator:"
      ],
      "metadata": {
        "id": "8NcJwcXTs4UT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate dot product\n",
        "vector_a @ vector_b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5A5WGvI8uJjZ",
        "outputId": "08320e90-d098-439c-d717-b605759d8089"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "32"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.18 Adding and Subtracting Matrices\n",
        "\n",
        "###Problem\n",
        "You want to add or subtract two matrices.\n",
        "\n",
        "###Solution\n",
        "Use NumPy’s add and subtract:"
      ],
      "metadata": {
        "id": "93eps1kjuRy9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix_a = np.array([[1, 1, 1],\n",
        "                     [1, 1, 1],\n",
        "                     [1, 1, 2]])\n",
        "\n",
        "# Create matrix\n",
        "matrix_b = np.array([[1, 3, 1],\n",
        "                     [1, 3, 1],\n",
        "                     [1, 3, 8]])\n",
        "\n",
        "# Add two matrices\n",
        "np.add(matrix_a, matrix_b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cqki6hfsuVhX",
        "outputId": "e1631874-cfeb-4e5b-dfe1-a25bea21b30d"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 2,  4,  2],\n",
              "       [ 2,  4,  2],\n",
              "       [ 2,  4, 10]])"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Subtract two matrices\n",
        "np.subtract(matrix_a, matrix_b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iR8VaGbeu0pE",
        "outputId": "fe5cdb05-bc54-49ee-f73d-b0f767871441"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0, -2,  0],\n",
              "       [ 0, -2,  0],\n",
              "       [ 0, -2, -6]])"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "Alternatively, we can simply use the `+` and `-` operators:"
      ],
      "metadata": {
        "id": "54-EFObGu8vl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Add two matrices\n",
        "matrix_a + matrix_b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qTcnPuymvA11",
        "outputId": "4e680095-0913-4b05-c1d4-4d6160520891"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 2,  4,  2],\n",
              "       [ 2,  4,  2],\n",
              "       [ 2,  4, 10]])"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.19 Multiplying Matrices\n",
        "\n",
        "###Problem\n",
        "You want to multiply two matrices.\n",
        "\n",
        "###Solution\n",
        "Use NumPy's `dot`:"
      ],
      "metadata": {
        "id": "14g5kxDCvJG9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix_a = np.array([[1, 1],\n",
        "                     [1, 2]])\n",
        "\n",
        "# Create matrix\n",
        "matrix_b = np.array([[1, 3],\n",
        "                     [1, 2]])\n",
        "\n",
        "# Multiply two matrices\n",
        "np.dot(matrix_a, matrix_b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bmtd0uCRvFr0",
        "outputId": "8b18b9c8-4ab3-4933-a0ef-3dd3b2bd2574"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[2, 5],\n",
              "       [3, 7]])"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "Alternatively, in Python 3.5+ we can use the `@` operator:"
      ],
      "metadata": {
        "id": "M5k4-9kRvhb9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiply two matrices\n",
        "matrix_a @ matrix_b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6zdi8CMCvlCz",
        "outputId": "b87bd479-a4ac-4ecc-e67c-f8a7ef90c381"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[2, 5],\n",
              "       [3, 7]])"
            ]
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we want to do element-wise multiplication, we can use the `*` operator:"
      ],
      "metadata": {
        "id": "8_NJjR53voaM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiply two matrices element-wise\n",
        "matrix_a * matrix_b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IxGyhORovs77",
        "outputId": "994c1452-e703-4c04-893c-defa7b69d1fa"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 3],\n",
              "       [1, 4]])"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.20 Inverting a Matrix\n",
        "\n",
        "###Problem\n",
        "You want to calculate the inverse of a square matrix.\n",
        "\n",
        "###Solution\n",
        "Use NumPy's linear algebra `inv` method:"
      ],
      "metadata": {
        "id": "6FjyFdYbv4Vb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Create matrix\n",
        "matrix = np.array([[1, 4],\n",
        "                   [2, 5]])\n",
        "\n",
        "# Calculate inverse of matrix\n",
        "np.linalg.inv(matrix)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "udnePKxCwBsR",
        "outputId": "03fb959d-fdbb-445a-d839-0fbf47f84d62"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-1.66666667,  1.33333333],\n",
              "       [ 0.66666667, -0.33333333]])"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "The inverse of a square matrix, $A$, is a second matrix $A^{-1}$, such that:\n",
        "\n",
        "\\begin{align}\n",
        "AA^{-1} = I\n",
        "\\end{align}\n",
        "\n",
        "where $I$ is the identity matrix. In NumPy we can use 'linalg.inv' to calculate $A^{-1}$ if it exists. To see this in action, we can multiply a matrix by its inverse and the result is the identity matrix:"
      ],
      "metadata": {
        "id": "f9i6gDNSwR4q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiply matrix and its inverse\n",
        "matrix @ np.linalg.inv(matrix)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UyxlKPwxw7sB",
        "outputId": "8221622d-658a-4e78-f899-6f95b1639a28"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1.00000000e+00, 0.00000000e+00],\n",
              "       [1.11022302e-16, 1.00000000e+00]])"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.21 Generating Random Values\n",
        "\n",
        "###Problem\n",
        "You want to generate pseudorandom values.\n",
        "\n",
        "###Solution\n",
        "Use NumPy’s `random`:"
      ],
      "metadata": {
        "id": "94eP8jpoxEdx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load library\n",
        "import numpy as np\n",
        "\n",
        "# Set seed\n",
        "np.random.seed(0)\n",
        "\n",
        "# Generate three random floats between 0.0 and 1.0\n",
        "np.random.random(3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iZ6gm3eTxKIg",
        "outputId": "82e32346-3909-445f-b1aa-fe395dfd790d"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.5488135 , 0.71518937, 0.60276338])"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Discussion\n",
        "NumPy offers a wide variety of means to generate random numbers, many more than\n",
        "can be covered here. In our solution we generated floats; however, it is also common to generate integers:"
      ],
      "metadata": {
        "id": "WYut8-JTxSIQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Generate three random integers between 1 and 10\n",
        "np.random.randint(0, 11, 3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wFq6cZU0xWyJ",
        "outputId": "41c1d037-ad3b-40d9-8eea-b460b233447c"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([3, 7, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Alternatively, we can generate numbers by drawing them from a distribution:"
      ],
      "metadata": {
        "id": "8b4QIP9YxZOS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Draw three numbers from a normal distribution with mean 0.0\n",
        "# and standard deviation of 1.0\n",
        "np.random.normal(0.0, 1.0, 3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kp6egq9UxbL6",
        "outputId": "d70739f8-bc6c-4884-9a87-3a9597e34670"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-1.42232584,  1.52006949, -0.29139398])"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Draw three numbers from a logistic distribution with mean 0.0 and scale of 1.0\n",
        "np.random.logistic(0.0, 1.0, 3)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UdCCBfVVxe1-",
        "outputId": "3f0c74c1-987c-405a-f11a-c036226a059c"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-0.98118713, -0.08939902,  1.46416405])"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Draw three numbers greater than or equal to 1.0 and less than 2.0\n",
        "np.random.uniform(1.0, 2.0, 3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6j2Q0EEPxgIX",
        "outputId": "724cc6a3-0896-4dce-a408-8c5ac18c4b63"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1.47997717, 1.3927848 , 1.83607876])"
            ]
          },
          "metadata": {},
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finally, it can sometimes be useful to return the same random numbers multiple\n",
        "times to get predictable, repeatable results. We can do this by setting the “seed” (an integer) of the pseudorandom generator. Random processes with the same seed will always produce the same output. We will use seeds throughout this book so that the code you see in the book and the code you run on your computer produces the same results."
      ],
      "metadata": {
        "id": "SFxukDkDxspF"
      }
    }
  ]
}