Vectors.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "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/SrivinaySridhar/MLT_workshop/blob/main/Vectors.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Vectors\n",
        "\n"
      ],
      "metadata": {
        "id": "H729Vxqsdh5_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Import\n",
        "\n",
        "First we shall import the `NumPy` package."
      ],
      "metadata": {
        "id": "B1cOisjsIQWW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np"
      ],
      "metadata": {
        "id": "9BmIfrx3IXZz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Python Lists\n",
        "\n",
        "Consider the following vectors:\n",
        "\n",
        "$$\n",
        "\\mathbf{x} = \\begin{bmatrix}\n",
        "1\\\\\n",
        "2\\\\\n",
        "3\n",
        "\\end{bmatrix}, \\mathbf{y} = \\begin{bmatrix}\n",
        "4\\\\\n",
        "5\\\\\n",
        "6\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "We can add these two vectors:\n",
        "\n",
        "$$\n",
        "\\mathbf{z} = \\mathbf{x} + \\mathbf{y}= \\begin{bmatrix}\n",
        "5\\\\\n",
        "7\\\\\n",
        "9\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "Using Python lists:"
      ],
      "metadata": {
        "id": "q4Bvo6cKbRjQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = [1, 2, 3]\n",
        "y = [4, 5, 6]\n",
        "\n",
        "z = []\n",
        "for i in range(len(x)):\n",
        "    z.append(x[i] + y[i])\n",
        "\n",
        "print(z)"
      ],
      "metadata": {
        "id": "iBA567DMbkvS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1ed0ba92-2225-4769-adb7-e116eb9e6971"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[5, 7, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Vectors as `NumPy` arrays\n",
        "\n",
        "Consider the following vector:\n",
        "\n",
        "$$\n",
        "\\mathbf{x} = \\begin{bmatrix}\n",
        "1\\\\\n",
        "2\\\\\n",
        "3\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "In `NumPy`:"
      ],
      "metadata": {
        "id": "JvcADsvgIZE3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1, 2, 3])\n",
        "x"
      ],
      "metadata": {
        "id": "83iQmusSIstp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fe719306-83c4-4706-b006-9ab5a753a252"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Vector addition\n",
        "\n",
        "Addition is one of the elementary operations that can be performed on vectors. Given two vectors\n",
        "\n",
        "$$\n",
        "\\mathbf{x} = \\begin{bmatrix}\n",
        "1\\\\\n",
        "2\\\\\n",
        "3\n",
        "\\end{bmatrix}, \\mathbf{y} = \\begin{bmatrix}\n",
        "4\\\\\n",
        "5\\\\\n",
        "6\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "we have:\n",
        "\n",
        "$$\n",
        "\\mathbf{z} = \\mathbf{x} + \\mathbf{y}= \\begin{bmatrix}\n",
        "5\\\\\n",
        "7\\\\\n",
        "9\n",
        "\\end{bmatrix}\n",
        "$$"
      ],
      "metadata": {
        "id": "j-1J_2tTKeFn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1, 2, 3])\n",
        "y = np.array([4, 5, 6])\n",
        "z = x + y\n",
        "z"
      ],
      "metadata": {
        "id": "1Pxa2ZGULiq9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "06cf1690-0411-40eb-8b50-3173a9460607"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5, 7, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Element-wise multiplication\n",
        "\n",
        "Element-wise multiplication of two vectors is called the Hadamard product. The operator corresponding to it is $\\odot$. For example, given two vectors:\n",
        "\n",
        "$$\n",
        "\\mathbf{x} = \\begin{bmatrix}\n",
        "1\\\\\n",
        "2\\\\\n",
        "3\n",
        "\\end{bmatrix}, \\mathbf{y} = \\begin{bmatrix}\n",
        "4\\\\\n",
        "5\\\\\n",
        "6\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "we have:\n",
        "\n",
        "$$\n",
        "\\mathbf{z} = \\mathbf{x} \\odot \\mathbf{y}= \\begin{bmatrix}\n",
        "4\\\\\n",
        "10\\\\\n",
        "18\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "In `NumPy`:"
      ],
      "metadata": {
        "id": "ap_Zg_CEL9lz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1, 2, 3])\n",
        "y = np.array([4, 5, 6])\n",
        "z = x * y\n",
        "z"
      ],
      "metadata": {
        "id": "2v9T-dLrMX8l",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cef2f422-9080-4fa2-cdd6-4dfa50e33165"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 4, 10, 18])"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Scaling vectors\n",
        "\n",
        "If $\\mathbf{x}$ is a vector, scaling it by a constant $k$ is equivalent to element-wise multiplication by $k$. For example, given\n",
        "\n",
        "$$\n",
        "\\mathbf{x} = \\begin{bmatrix}\n",
        "1\\\\\n",
        "2\\\\\n",
        "3\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "we have:\n",
        "\n",
        "$$\n",
        "\\mathbf{y} = 3 \\mathbf{x} = \\begin{bmatrix}\n",
        "3\\\\\n",
        "6\\\\\n",
        "9\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "In `NumPy`:"
      ],
      "metadata": {
        "id": "Fp6OJRQZMjoW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1, 2, 3])\n",
        "y = 3*x\n",
        "y"
      ],
      "metadata": {
        "id": "NQGQmZZFM7_z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8d646902-5989-431c-cbeb-2d054dc3931a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([3, 6, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Element-wise functions of vectors\n",
        "\n",
        "Scaling a vector $\\mathbf{x}$ by a constant $k$ can be seen as the outcome of the function $f(x) = kx$ applied element-wise:\n",
        "\n",
        "$$\n",
        "\\begin{bmatrix}\n",
        "f(x_1)\\\\\n",
        "\\vdots\\\\\n",
        "f(x_d)\n",
        "\\end{bmatrix} = \\begin{bmatrix}\n",
        "kx_1\\\\\n",
        "\\vdots\\\\\n",
        "k x_d\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "`NumPy` extends this feature for any arbitrary function."
      ],
      "metadata": {
        "id": "6U2ERkN5NCPe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example-1\n",
        "\n",
        "For example, consider the function $f(x) = x^2$. This can be applied element-wise:\n",
        "\n",
        "$$\n",
        "\\begin{bmatrix}\n",
        "x_1^2\\\\\n",
        "\\vdots\\\\\n",
        "x_d^2\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "Let us do this for:\n",
        "\n",
        "$$\n",
        "\\begin{bmatrix}\n",
        "1\\\\\n",
        "2\\\\\n",
        "3\\\\\n",
        "4\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "In `NumPy`:"
      ],
      "metadata": {
        "id": "jRqHYiLSXLt3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1, 2, 3, 4])\n",
        "x ** 2"
      ],
      "metadata": {
        "id": "4J5S44ynN0GR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8b4f0606-736a-454e-8e09-e890caf0a85d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 1,  4,  9, 16])"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example-2.1\n",
        "\n",
        "As another example, consider $f(x) = \\log(x)$. This can also be applied element-wise:\n",
        "\n",
        "$$\n",
        "\\begin{bmatrix}\n",
        "\\log(x_1)\\\\\n",
        "\\vdots\\\\\n",
        "\\log(x_d)\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "Let us do this for $\\begin{bmatrix}1 & 10 & 100 & 1000 & 10000 & 100000\\end{bmatrix}^T$. Use base $10$.\n",
        "\n",
        "In `NumPy`:"
      ],
      "metadata": {
        "id": "Vyz1dWlhW3_G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1, 10, 100, 1000, 10_000, 100_000])\n",
        "y = np.log10(x)\n",
        "y"
      ],
      "metadata": {
        "id": "jbQ6mp1QN-dG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "09f08c09-e6c2-4f14-c4aa-271f8b40c24d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 1., 2., 3., 4., 5.])"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example 2.2\n",
        "\n",
        "We can also use log to the base $e$, the natural logarithm. For this, let us take a specific vector:\n",
        "\n",
        "$$\n",
        "\\mathbf{x} = \\begin{bmatrix}\n",
        "1\\\\\n",
        "e\\\\\n",
        "e^2\\\\\n",
        "e^3\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "and apply the function $f(x) = \\ln(x)$ element-wise.\n",
        "\n",
        "In `NumPy`:"
      ],
      "metadata": {
        "id": "Oxn-V4AWYMbr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1, np.e, np.e**2, np.e**3])\n",
        "y = np.log(x)\n",
        "y"
      ],
      "metadata": {
        "id": "I9CwD-g-Oa1F",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4b892c53-1a59-42d5-f8b5-b2a7818a372e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 1., 2., 3.])"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example 3\n",
        "\n",
        "Just as we can scale a vector, we can also add a constant to each component. This is equivalent to applying the element-wise function $f(x) = x + c$. Let us take the case of $\\begin{bmatrix}1 & 2 & 3\\end{bmatrix}^T$ and $c = 5$.\n",
        "\n",
        "In `NumPy`:"
      ],
      "metadata": {
        "id": "CLZ6acXdZDzJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1, 2, 3])\n",
        "c = 5\n",
        "x + c"
      ],
      "metadata": {
        "id": "BHsoW6jvmQF1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7aa1285b-1da7-4c01-98f4-8f4441f5d3e0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([6, 7, 8])"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example 4\n",
        "\n",
        "Now for a slightly more involved example with $f(x) = 5x - 2$ applied element-wise on the following vector:\n",
        "\n",
        "$$\n",
        "\\mathbf{x} = \\begin{bmatrix}\n",
        "-1\\\\\n",
        "0\\\\\n",
        "1\\\\\n",
        "2\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "In `NumPy`:"
      ],
      "metadata": {
        "id": "TTTvqeYxZw0O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([-1, 0, 1, 2])\n",
        "5 * x - 2"
      ],
      "metadata": {
        "id": "-E8n9MT-aBYj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c7cb37f4-e440-48e2-cb88-dadf2bf875fd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-7, -2,  3,  8])"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Dot Product\n",
        "\n",
        "The dot product between two vectors $\\mathbf{x}$ and $\\mathbf{y}$ is given as follows:\n",
        "\n",
        "$$\n",
        "z = \\mathbf{x}^T \\mathbf{y} =  \\mathbf{x} \\cdot \\mathbf{y} = \\sum \\limits_{j = 1}^{m} x_j y_j\n",
        "$$\n",
        "\n",
        "Let us use the following vectors:\n",
        "\n",
        "$$\n",
        "\\mathbf{x} = \\begin{bmatrix}\n",
        "1\\\\\n",
        "2\\\\\n",
        "3\\\\\n",
        "4\\\\\n",
        "\\end{bmatrix}, \\mathbf{y} = \\begin{bmatrix}\n",
        "-4\\\\\n",
        "-5\\\\\n",
        "-6\\\\\n",
        "-7\\\\\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "In `NumPy`:"
      ],
      "metadata": {
        "id": "kQR9yS5ROhFR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1, 2, 3, 4])\n",
        "y = np.array([-4, -5, -6, -7])\n",
        "np.dot(x, y)"
      ],
      "metadata": {
        "id": "yIdGkJG_OxrL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "beb428bf-3993-40fb-bcd2-7ba5a6177b5f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-60"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x @ y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v0JDeJXazzdH",
        "outputId": "8eb1f844-f6b9-4a3d-d7f6-e36622b6f517"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-60"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Vector of zeros or ones\n",
        "\n",
        "On many occassions, we might want to create a `NumPy` array all of whose elements are zeros or ones or some other constant. Let us create the following vectors:\n",
        "\n",
        "$$\n",
        "\\mathbf{0} = \\begin{bmatrix}\n",
        "0\\\\\n",
        "0\\\\\n",
        "0\\\\\n",
        "0\\\\\n",
        "0\n",
        "\\end{bmatrix}, \\mathbf{1} = \\begin{bmatrix}\n",
        "1\\\\\n",
        "1\\\\\n",
        "1\\\\\n",
        "1\\\\\n",
        "1\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "In `NumPy`:"
      ],
      "metadata": {
        "id": "-oGTCbqVRqUj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "zeros = np.zeros(5)\n",
        "zeros"
      ],
      "metadata": {
        "id": "4i6VbthkT36F",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "74672ba2-d129-475f-b7c9-d87016af9d7b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 0., 0., 0., 0.])"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ones = np.ones(5)\n",
        "ones"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J6UdLbo50O6f",
        "outputId": "87ad97ab-4048-4dfc-8544-85377993735c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1., 1., 1., 1., 1.])"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "What if we wanted to create a vector all of whose elements are equal to $5$?"
      ],
      "metadata": {
        "id": "KwAXANsqb3dO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fives = np.ones(5) * 5\n",
        "fives"
      ],
      "metadata": {
        "id": "qVKkJ3Cgb8e9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3b888390-98b8-48d2-ad96-26b1d41a79cc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5., 5., 5., 5., 5.])"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Range\n",
        "\n",
        "Sometimes we might want to create a sequence of integers such as:\n",
        "\n",
        "$$\n",
        "[1 \\quad 2 \\quad 3 \\quad 4 \\quad 5]\n",
        "$$"
      ],
      "metadata": {
        "id": "sUyw2fsPk2OO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.arange(1, 6)"
      ],
      "metadata": {
        "id": "tVrjdLDxlC77",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c69c8c84-20bf-49b8-9686-59e714c159ea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Norm of a vector\n",
        "\n",
        "For a vector $\\mathbf{x}$:\n",
        "\n",
        "$$\n",
        "\\mathbf{x} = \\begin{bmatrix}\n",
        "1\\\\\n",
        "2\\\\\n",
        "3\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "The $L_2$ norm is defind as:\n",
        "\n",
        "$$\n",
        "||\\mathbf{x}||_2 = \\sqrt{1^2 + 2^2 + 3^2} = \\sqrt{14}\n",
        "$$\n",
        "\n",
        "The $L_1$ norm is defind as:\n",
        "\n",
        "$$\n",
        "||\\mathbf{x}||_1 = |1| + |2| + |3| = 6\n",
        "$$\n",
        "\n",
        "In `NumPy`:"
      ],
      "metadata": {
        "id": "vLcLxgyZGAt5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1, 2, 3])\n",
        "print(\"L2 norm: \", np.linalg.norm(x)) #L2 norm - Euclidean norm - Ridge Regression\n",
        "print(\"L1 norm: \", np.linalg.norm(x, ord = 1)) #L1 norm - Manhattan distance - Lasso Regression"
      ],
      "metadata": {
        "id": "5hiasmwYk-JK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d880899e-2f99-40c7-c357-55bdfe3c6220"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "L2 norm:  3.7416573867739413\n",
            "L1 norm:  6.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Shape and dimension of a vector\n",
        "\n",
        "Vectors are \"one dimensional\" arrays. So all vectors in `NumPy` have array-dimension equal to one. The term \"array-dimension\" here is defind for a `NumPy` array. It is different from the dimension used in the vector-space sense. The vector-space dimension can be obtaind by looking at the shape of the `NumPy` array.\n",
        "\n",
        "Explore these two ideas for:\n",
        "\n",
        "$$\n",
        "\\mathbf{x} = \\begin{bmatrix}\n",
        "1\\\\\n",
        "2\\\\\n",
        "3\\\\\n",
        "4\n",
        "\\end{bmatrix}\n",
        "$$"
      ],
      "metadata": {
        "id": "OGdzUtRAy6_g"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1, 2, 3, 4])\n",
        "print(x.shape)\n",
        "print(x.ndim)"
      ],
      "metadata": {
        "id": "Hs0Y5qRLzkXY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9bc484ca-6c35-4ac0-a976-45dbadefc1a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(4,)\n",
            "1\n"
          ]
        }
      ]
    }
  ]
}