Lab_Rotation_matrices_in_R2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMySsll3U4VdtrZt0p23EhM",
      "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/hussain0048/Natural-language-processing/blob/main/Lab_Rotation_matrices_in_R2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "import string\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from nltk.corpus import stopwords\n",
        "from nltk.stem import PorterStemmer\n",
        "from nltk.tokenize import TweetTokenizer\n",
        "import matplotlib.pyplot as plt \n",
        "\n",
        "\n",
        "def process_tweet(tweet):\n",
        "    '''\n",
        "    Input:\n",
        "        tweet: a string containing a tweet\n",
        "    Output:\n",
        "        tweets_clean: a list of words containing the processed tweet\n",
        "    '''\n",
        "    stemmer = PorterStemmer()\n",
        "    stopwords_english = stopwords.words('english')\n",
        "    # remove stock market tickers like $GE\n",
        "    tweet = re.sub(r'\\$\\w*', '', tweet)\n",
        "    # remove old style retweet text \"RT\"\n",
        "    tweet = re.sub(r'^RT[\\s]+', '', tweet)\n",
        "    # remove hyperlinks\n",
        "    tweet = re.sub(r'https?:\\/\\/.*[\\r\\n]*', '', tweet)\n",
        "    # remove hashtags\n",
        "    # only removing the hash # sign from the word\n",
        "    tweet = re.sub(r'#', '', tweet)\n",
        "    # tokenize tweets\n",
        "    tokenizer = TweetTokenizer(preserve_case=False, strip_handles=True,\n",
        "                               reduce_len=True)\n",
        "    tweet_tokens = tokenizer.tokenize(tweet)\n",
        "\n",
        "    tweets_clean = []\n",
        "    for word in tweet_tokens:\n",
        "        if (word not in stopwords_english and  # remove stopwords\n",
        "            word not in string.punctuation):  # remove punctuation\n",
        "            # tweets_clean.append(word)\n",
        "            stem_word = stemmer.stem(word)  # stemming word\n",
        "            tweets_clean.append(stem_word)\n",
        "\n",
        "    return tweets_clean\n",
        "\n",
        "\n",
        "def get_dict(file_name):\n",
        "    \"\"\"\n",
        "    This function returns the english to french dictionary given a file where the each column corresponds to a word.\n",
        "    Check out the files this function takes in your workspace.\n",
        "    \"\"\"\n",
        "    my_file = pd.read_csv(file_name, delimiter=' ')\n",
        "    etof = {}  # the english to french dictionary to be returned\n",
        "    for i in range(len(my_file)):\n",
        "        # indexing into the rows.\n",
        "        en = my_file.loc[i][0]\n",
        "        fr = my_file.loc[i][1]\n",
        "        etof[en] = fr\n",
        "\n",
        "    return etof\n",
        "\n",
        "\n",
        "def cosine_similarity(A, B):\n",
        "    '''\n",
        "    Input:\n",
        "        A: a numpy array which corresponds to a word vector\n",
        "        B: A numpy array which corresponds to a word vector\n",
        "    Output:\n",
        "        cos: numerical number representing the cosine similarity between A and B.\n",
        "    '''\n",
        "    # you have to set this variable to the true label.\n",
        "    cos = -10\n",
        "    dot = np.dot(A, B)\n",
        "    norma = np.linalg.norm(A)\n",
        "    normb = np.linalg.norm(B)\n",
        "    cos = dot / (norma * normb)\n",
        "\n",
        "    return cos\n",
        "\n",
        "# Procedure to plot and arrows that represents vectors with pyplot\n",
        "def plot_vectors(vectors, colors=['k', 'b', 'r', 'm', 'c'], axes=None, fname='image.svg', ax=None):\n",
        "    scale = 1\n",
        "    scale_units = 'x'\n",
        "    x_dir = []\n",
        "    y_dir = []\n",
        "    \n",
        "    for i, vec in enumerate(vectors):\n",
        "        x_dir.append(vec[0][0])\n",
        "        y_dir.append(vec[0][1])\n",
        "    \n",
        "    if ax == None:\n",
        "        fig, ax2 = plt.subplots()\n",
        "    else:\n",
        "        ax2 = ax\n",
        "      \n",
        "    if axes == None:\n",
        "        x_axis = 2 + np.max(np.abs(x_dir))\n",
        "        y_axis = 2 + np.max(np.abs(y_dir))\n",
        "    else:\n",
        "        x_axis = axes[0]\n",
        "        y_axis = axes[1]\n",
        "        \n",
        "    ax2.axis([-x_axis, x_axis, -y_axis, y_axis])\n",
        "        \n",
        "    for i, vec in enumerate(vectors):\n",
        "        ax2.arrow(0, 0, vec[0][0], vec[0][1], head_width=0.05 * x_axis, head_length=0.05 * y_axis, fc=colors[i], ec=colors[i])\n",
        "    \n",
        "    if ax == None:\n",
        "        plt.show()\n",
        "        fig.savefig(fname)"
      ],
      "metadata": {
        "id": "_TP2j6-1YtnH"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Vector manipulation in Python**"
      ],
      "metadata": {
        "id": "rjoM9_J0Vc-S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Transforming vectors**"
      ],
      "metadata": {
        "id": "8M-aup9dWEje"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "f4yCzN4sUhlR"
      },
      "outputs": [],
      "source": [
        "import numpy as np                     # Import numpy for array manipulation\n",
        "import matplotlib.pyplot as plt        # Import matplotlib for charts\n",
        "#from utils_nb import plot_vectors      # Function to plot vectors (arrows)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Example 1**"
      ],
      "metadata": {
        "id": "9YwEAfJjWbEi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a 2 x 2 matrix\n",
        "R = np.array([[2, 0],\n",
        "              [0, -2]])"
      ],
      "metadata": {
        "id": "iTI9Fp75WgbQ"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([[1, 1]]) # Create a 1 x 2 matrix\n"
      ],
      "metadata": {
        "id": "bXLnfhN-WjpL"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "y = np.dot(x, R) # Apply the dot product between x and R\n",
        "y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ltnypUnlWomi",
        "outputId": "cb0d9f73-3d72-46da-8739-43b4b2657a20"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 2, -2]])"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_vectors([x], axes=[4, 4], fname='transform_x.svg')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "id": "58i2-AxFY1CJ",
        "outputId": "6a64ea11-33c4-4c13-93ee-0bfd8c79fe1e"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_vectors([x, y], axes=[4, 4], fname='transformx_and_y.svg')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "id": "mj_PB4PAY6qK",
        "outputId": "d6e33eb1-6414-41b4-c8ae-979fc94bc0f9"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Example 2**"
      ],
      "metadata": {
        "id": "6va_nTcxi_la"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "angle = 100 * (np.pi / 180) #convert degrees to radians\n",
        "\n",
        "Ro = np.array([[np.cos(angle), -np.sin(angle)],\n",
        "              [np.sin(angle), np.cos(angle)]])\n",
        "\n",
        "x2 = np.array([2, 2]).reshape(1, -1) # make it a row vector\n",
        "y2 = np.dot(x2, Ro)\n",
        "\n",
        "print('Rotation matrix')\n",
        "print(Ro)\n",
        "print('\\nRotated vector')\n",
        "print(y2)\n",
        "\n",
        "print('\\n x2 norm', np.linalg.norm(x2))\n",
        "print('\\n y2 norm', np.linalg.norm(y2))\n",
        "print('\\n Rotation matrix norm', np.linalg.norm(Ro))"
      ],
      "metadata": {
        "id": "Hxy89mhTjP-c",
        "outputId": "643a78ff-1cf0-4fd5-e5dd-44ba1aff8714",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Rotation matrix\n",
            "[[-0.17364818 -0.98480775]\n",
            " [ 0.98480775 -0.17364818]]\n",
            "\n",
            "Rotated vector\n",
            "[[ 1.62231915 -2.31691186]]\n",
            "\n",
            " x2 norm 2.8284271247461903\n",
            "\n",
            " y2 norm 2.82842712474619\n",
            "\n",
            " Rotation matrix norm 1.414213562373095\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_vectors([x2, y2], fname='transform_02.svg')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "a9QXHX_0jbFJ",
        "outputId": "1178670a-47aa-4fb8-99c1-e2259c6f2e9c"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Frobenius Norm**"
      ],
      "metadata": {
        "id": "RDvAfI84kN7I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = np.array([[2, 2],              [2, 2]])"
      ],
      "metadata": {
        "id": "KiveMaiWj-Z5"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "A_squared = np.square(A)\n",
        "A_squared"
      ],
      "metadata": {
        "id": "LZ6ovesfkC_K",
        "outputId": "0f98b0de-4d71-485c-8c28-2e417bd5a64e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[4, 4],\n",
              "       [4, 4]])"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "A_Frobenius = np.sqrt(np.sum(A_squared))\n",
        "A_Frobenius"
      ],
      "metadata": {
        "id": "PZIsdJfMZfnw",
        "outputId": "5924d136-38c0-42c1-d84d-636f2ba513df",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4.0"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Frobenius norm of the Rotation matrix')\n",
        "print(np.sqrt(np.sum(Ro * Ro)), '== ', np.linalg.norm(Ro))"
      ],
      "metadata": {
        "id": "_UfGrlZFZlK8",
        "outputId": "39209781-e7f2-4106-c6fa-06b7c57de8d1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Frobenius norm of the Rotation matrix\n",
            "1.414213562373095 ==  1.414213562373095\n"
          ]
        }
      ]
    }
  ]
}