EMNLP_IU_Boundary_code.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# EMNLP IU-Boundary Code\n",
        "This notebook defines a class to produce the raw counts, metrics, and language distribution graphs for a given transcript. Refer to the README file for our assumptions about the Excel format."
      ],
      "metadata": {
        "id": "T-0vnHaR90SI"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3UsZ8cnX9X2M",
        "outputId": "e1719c53-822f-461b-8e4b-91507bde7182"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive/; to attempt to forcibly remount, call drive.mount(\"/content/drive/\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "# mount google drive\n",
        "from google.colab import drive\n",
        "import os\n",
        "\n",
        "drive.mount('/content/drive/')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Class Definition"
      ],
      "metadata": {
        "id": "xfC0hLrn0GAK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class IUBoundaryMetrics:\n",
        "  def __init__(self, data, n_languages=2, lang_tag_col_name=\"Clean Lang Tag\", speaker_col_name=\"Speaker Type\"):\n",
        "    self.df = data\n",
        "    self.langtag_col_name = lang_tag_col_name\n",
        "    self.speaker_col = speaker_col_name\n",
        "    self.n_languages = n_languages\n",
        "    self.IU_lang_visualizations = []\n",
        "    # dictionary for the Ls counted\n",
        "    self.raw_counts_L = {\n",
        "        \"total_valid_rows\": 0,    # rows counted after filtering for desired language tags\n",
        "        \"n_speaker_rows\"  : 0,    # IU rows that are speaker\n",
        "        \"n_interviewer_rows\": 0,  # IU rows that are interviewer\n",
        "        \"across-switch\"   : 0,    # how many times is there a boundary switch?\n",
        "        \"L_count\"         : [],   # how many IUs have Ls? (and how many?)\n",
        "        \"within-switch\"   : [],   # how many switches happen within the IU?\n",
        "        \"IU_lang_rows\"    : [],   # language tag measurements after filtering out non- S/E/L\n",
        "    }\n",
        "    # dictionary for no Ls counted\n",
        "    self.raw_counts_no_L = {\n",
        "        \"total_valid_rows\": 0,    # rows counted after filtering for desired language tags\n",
        "        \"n_speaker_rows\"  : 0,    # IU rows that are speaker\n",
        "        \"n_interviewer_rows\": 0,  # IU rows that are interviewer\n",
        "        \"across-switch\"   : 0,    # how many times is there a boundary switch?\n",
        "        \"L_count\"         : [],   # how many IUs have Ls? (and how many?)\n",
        "        \"within-switch\"   : [],   # how many switches happen within the IU?\n",
        "        \"IU_lang_rows\"    : [],   # language tag measurements after filtering out non- S/E/L\n",
        "    }\n",
        "    self.M_index, self.across_I_index, self.within_I_index = 0.0, 0.0, 0.0\n",
        "\n",
        "  def process_raw_info(self, include_L=False):\n",
        "    prev_letter = \"\"\n",
        "    raw_counts = {\n",
        "        \"total_valid_rows\": 0,    # rows counted after filtering for desired language tags\n",
        "        \"n_speaker_rows\"  : 0,    # IU rows that are speaker\n",
        "        \"n_interviewer_rows\": 0,  # IU rows that are interviewer\n",
        "        \"across-switch\"   : 0,    # how many times is there a boundary switch?\n",
        "        \"L_count\"         : [],   # how many IUs have Ls? (and how many?)\n",
        "        \"within-switch\"   : [],   # how many switches happen within the IU?\n",
        "        \"IU_lang_rows\"    : [],   # language tag measurements after filtering out non- S/E/L\n",
        "    }\n",
        "\n",
        "    # loop through every IU row in the transcript\n",
        "    for i in range(len(self.df[self.langtag_col_name])):\n",
        "\n",
        "      # we want to filter out anything that isn't L or S or E (depending on our 'include_L' flag)\n",
        "      curr_tag = df[self.langtag_col_name][i]\n",
        "      if include_L:\n",
        "        curr_tag = [x for x in curr_tag if x in [\"L\", \"S\", \"E\"]]\n",
        "      else:\n",
        "        curr_tag = [x for x in curr_tag if x in [\"S\", \"E\"]]\n",
        "      # the metrics in this if statement is meant for sanity checking and ensuring majority monological transcripts\n",
        "      if (len(curr_tag) > 0):\n",
        "        raw_counts[\"total_valid_rows\"] += 1\n",
        "        if (self.df[self.speaker_col][i] == \"Participant\"):     # TODO: change the name of the column if necessary\n",
        "          raw_counts[\"n_speaker_rows\"] += 1\n",
        "        elif (self.df[self.speaker_col][i] == \"Interviewer\"):   # TODO: change the name of the column if necessary\n",
        "          raw_counts[\"n_interviewer_rows\"] += 1\n",
        "\n",
        "      # count the Ls in the current IU row\n",
        "      if include_L:\n",
        "        L_count = curr_tag.count(\"L\")\n",
        "        raw_counts[\"L_count\"].append(L_count)\n",
        "\n",
        "      # process every tag in the IU\n",
        "      curr_within_switch = 0\n",
        "      for lang_idx, lang in enumerate(curr_tag):\n",
        "        if (lang_idx == 0):\n",
        "          # for the IU token level, remember that we only consider the first tag for each IU (for M-Index)\n",
        "          raw_counts[\"IU_lang_rows\"].append(lang)\n",
        "        # this will only happen once for each for loop / IU row;\n",
        "        # the last check makes sure we don't count the first row as an across IU switch\n",
        "        if (lang_idx == 0) and (lang != prev_letter) and (prev_letter != \"\"):  # looking for across IU switching\n",
        "          raw_counts[\"across-switch\"] += 1\n",
        "        elif (lang_idx > 0) and (lang != prev_letter): # looking for within IU switching\n",
        "          curr_within_switch += 1\n",
        "        prev_letter = lang\n",
        "      raw_counts[\"within-switch\"].append(curr_within_switch)\n",
        "\n",
        "    if include_L:\n",
        "      self.raw_counts_L = raw_counts\n",
        "    else:\n",
        "      self.raw_counts_no_L = raw_counts\n",
        "    return raw_counts\n",
        "\n",
        "  # This doesn't include counting the Ls\n",
        "  def m_index(self):\n",
        "    p = {\n",
        "        \"E\": 0,\n",
        "        \"S\":0\n",
        "    }\n",
        "\n",
        "    total_rows = 0\n",
        "    for curr_lang_tag in self.raw_counts_no_L[\"IU_lang_rows\"]:\n",
        "      if curr_lang_tag == \"E\":\n",
        "        p[\"E\"] += 1\n",
        "      elif curr_lang_tag == \"S\":\n",
        "        p[\"S\"] += 1\n",
        "      total_rows += 1\n",
        "\n",
        "    assert(p[\"S\"] + p[\"E\"] == total_rows) # sanity check\n",
        "\n",
        "    for curr_p, count in p.items():\n",
        "      p[curr_p] /= total_rows\n",
        "      p[curr_p] = p[curr_p] ** 2\n",
        "\n",
        "    p_sum = p[\"E\"] + p[\"S\"]\n",
        "    self.M_index = (1 - p_sum) / ((self.n_languages - 1) * p_sum)\n",
        "\n",
        "    return self.M_index\n",
        "\n",
        "  # this function assumes the dataframe has already been processed in the ways desired (L or no L)\n",
        "  def i_index_calculations(self, dataframe):\n",
        "    # across IU only\n",
        "    self.across_I_index = dataframe[\"across-switch\"] / (dataframe[\"total_valid_rows\"] - 1)\n",
        "\n",
        "    # within IU only\n",
        "    switch_count = len([x for x in dataframe[\"within-switch\"] if x > 0])\n",
        "    self.within_I_index = switch_count / (dataframe[\"total_valid_rows\"])\n",
        "\n",
        "    return self.across_I_index, self.within_I_index\n",
        "\n",
        "  def visualize_transcript(self):\n",
        "    lang_distributions = []\n",
        "    for lang_tag in self.raw_counts_no_L[\"IU_lang_rows\"]:\n",
        "      if lang_tag == \"E\":\n",
        "        lang_distributions.append(0)\n",
        "      elif lang_tag == \"S\":\n",
        "        lang_distributions.append(1)\n",
        "    lang_distributions = np.asarray(lang_distributions).reshape(1, len(list(lang_distributions)), order=\"F\")\n",
        "    fig, ax = plt.subplots()\n",
        "    ax.pcolormesh(lang_distributions)\n",
        "    ax.set_frame_on(False)\n",
        "    return"
      ],
      "metadata": {
        "id": "4IkHRVEdBO28"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example w/ a Transcript"
      ],
      "metadata": {
        "id": "9KPJUdW-0JGX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# load the excel data\n",
        "import pandas as pd\n",
        "import matplotlib.colors as mc # For the legend\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# TODO: change this path to your data path\n",
        "filepath = \"/content/drive/MyDrive/Code-Switching-Work/updated-data/FILL_THIS_IN.xlsx\"\n",
        "df = pd.read_excel(filepath)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bnftwQK2Z8Jm",
        "outputId": "895d438d-ecaa-442b-d5cd-ca354eb97dcf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/openpyxl/worksheet/_reader.py:329: UserWarning: Unknown extension is not supported and will be removed\n",
            "  warn(msg)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "metrics = IUBoundaryMetrics(df)"
      ],
      "metadata": {
        "id": "NE8j2TLfaA21"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "no_L_raw_counts = metrics.process_raw_info(include_L = False)\n",
        "L_raw_counts    = metrics.process_raw_info(include_L = True)"
      ],
      "metadata": {
        "id": "eiMVUKjVaJ-F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Print the Raw Counts Information\n",
        "Related to information found in Table 1 of the paper."
      ],
      "metadata": {
        "id": "8F8GFWn5dR4F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# NOTE: We are exclusively looking for IUs with single language tags so as to not double count\n",
        "print(\"Total eligible IUs: \" + str(metrics.raw_counts_L[\"total_valid_rows\"]))\n",
        "\n",
        "E_count = len([x for x in metrics.raw_counts_L[\"IU_lang_rows\"] if x == \"E\"])\n",
        "S_count = len([x for x in metrics.raw_counts_L[\"IU_lang_rows\"] if x == \"S\"])\n",
        "L_count = len([x for x in metrics.raw_counts_L[\"IU_lang_rows\"] if x == \"L\"])\n",
        "mult_count = len([x for x in metrics.raw_counts_L[\"IU_lang_rows\"] if len(x) > 1])\n",
        "print(\"Total IUs counted as Es in transcript: \" + str(E_count))\n",
        "print(\"Total IUs counted as Ss in transcript: \" + str(S_count))\n",
        "print(\"Total IUs counted as Ls in transcript: \" + str(L_count))\n",
        "print(\"Total IUs with multiple language tags: \" + str(mult_count))\n",
        "\n",
        "# sanity check\n",
        "assert(E_count + S_count + L_count + mult_count == metrics.raw_counts_L[\"total_valid_rows\"])\n",
        "\n",
        "print(\"Number of switches across IUs (no Ls): \" + str(metrics.raw_counts_no_L[\"across-switch\"]))\n",
        "print(\"Number of switches across IUs (Ls incl.): \" + str(metrics.raw_counts_L[\"across-switch\"]))\n",
        "\n",
        "print(\"Within IU switches (no Ls): \" + str(len([x for x in metrics.raw_counts_no_L[\"within-switch\"] if x > 0])))\n",
        "print(\"Within IU switches (Ls incl.): \" + str(len([x for x in metrics.raw_counts_L[\"within-switch\"] if x > 0])))\n",
        "\n",
        "print(\"Number of IUs that contain Ls: \" + str(len([x for x in metrics.raw_counts_L[\"L_count\"] if x > 0])))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dXJRhulI4O7Z",
        "outputId": "b038def8-5f47-45ee-b9e7-84b8c5a4f262"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total eligible IUs: 1641\n",
            "Total IUs counted as Es in transcript: 894\n",
            "Total IUs counted as Ss in transcript: 737\n",
            "Total IUs counted as Ls in transcript: 10\n",
            "Total IUs with multiple language tags: 0\n",
            "Number of switches across IUs (no Ls): 264\n",
            "Number of switches across IUs (Ls incl.): 276\n",
            "Within IU switches (no Ls): 21\n",
            "Within IU switches (Ls incl.): 49\n",
            "Number of IUs that contain Ls: 31\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Print the Code-Switching Metrics\n",
        "Related to Table 3 of the EMNLP paper."
      ],
      "metadata": {
        "id": "q8uWj9xq0SpP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"M-Index: \" + str(round(metrics.m_index(), 2)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VwqHVSqAbZ5f",
        "outputId": "f2b3de89-870c-4ff4-b4c0-cd7604c2f637"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "M-Index: 0.98\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "across_noL, within_noL = metrics.i_index_calculations(no_L_raw_counts)\n",
        "print(\"Across IU I-Index with no Ls: \" + str(round(across_noL, 2)))\n",
        "print(\"Within IU I-Index with no Ls: \" + str(round(within_noL, 2)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MHfxUgPWbfa-",
        "outputId": "cbdd538e-f3a9-48bd-a6e6-e1a8ae7572be"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Across IU I-Index with no Ls: 0.16\n",
            "Within IU I-Index with no Ls: 0.01\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "across_L, within_L = metrics.i_index_calculations(L_raw_counts)\n",
        "print(\"Across IU I-Index with Ls: \" + str(round(across_L, 2)))\n",
        "print(\"Within IU I-Index with Ls: \" + str(round(within_L, 2)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oYw48rfOfy2f",
        "outputId": "f678532f-fb3c-4111-e05f-c9299ef6c3d9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Across IU I-Index with Ls: 0.17\n",
            "Within IU I-Index with Ls: 0.03\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Print the Language Distribution Graph\n",
        "Related to Figure 4 in EMNLP paper."
      ],
      "metadata": {
        "id": "73C_NedW0U_6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "metrics.visualize_transcript()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 435
        },
        "id": "FUZntvWYbb5V",
        "outputId": "0e7fbcb8-1541-49dc-dc61-6ccd78cba476"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}