notebooks/W266_Final_Project_Evaluation.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/vagabond008/mids-266-Dipika-Jack-Ray/blob/main/W266_Final_Project_Evaluation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xvILg5xsh_KH"
      },
      "source": [
        "## 1. Setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U1qL94HGneD9",
        "outputId": "0bfc6a49-06b9-42b1-ca14-4eec9cf097e5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: utils in /usr/local/lib/python3.10/dist-packages (1.0.2)\n"
          ]
        }
      ],
      "source": [
        "# install packages\n",
        "#!pip install -q transformers==4.37.2\n",
        "!pip install -q sentencepiece\n",
        "!pip install -q evaluate\n",
        "!pip install -q tensorflow==2.15\n",
        "!pip install -q rouge_score\n",
        "!pip install -q evaluate\n",
        "!pip install utils"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {
        "id": "G4uHjAq0l9Uz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e61000c7-4d6f-4631-909e-d9681c8e37f3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.15.0\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[nltk_data] Downloading package punkt to /root/nltk_data...\n",
            "[nltk_data]   Unzipping tokenizers/punkt.zip.\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ],
      "source": [
        "# import libraries\n",
        "import os\n",
        "import re\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import evaluate\n",
        "\n",
        "import tensorflow as tf\n",
        "import tensorflow_hub as hub\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import logging\n",
        "import tensorflow_hub as hub\n",
        "\n",
        "# Set the threshold for what messages will be logged\n",
        "logging.getLogger('tensorflow').setLevel(logging.ERROR)\n",
        "\n",
        "print(tf.__version__)\n",
        "\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "\n",
        "from transformers import TFPegasusForConditionalGeneration, PegasusTokenizer\n",
        "\n",
        "#from utils import angular_similarity, frechet_distance\n",
        "\n",
        "from google.colab import drive\n",
        "\n",
        "# Rouge\n",
        "from rouge_score import rouge_scorer\n",
        "\n",
        "\n",
        "# BLEU\n",
        "import nltk\n",
        "from nltk.translate.bleu_score import sentence_bleu\n",
        "from nltk.translate.bleu_score import SmoothingFunction\n",
        "nltk.download('punkt')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o4N5QZwQmbb5",
        "outputId": "f888b66b-b8ff-4d16-b706-e257b572a73f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "# mount Colab to Google Drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SaMha8DNmjFg"
      },
      "outputs": [],
      "source": [
        "# verify data exists in Google Drive dir\n",
        "#!ls 'drive/My Drive/W266'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MjySjw3dmp3h"
      },
      "source": [
        "## 2. Load Data"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Load Pegasus, T5, and GPT-2 results containing Reddit posts, generated titles, and the original title (*ground truth*)"
      ],
      "metadata": {
        "id": "dmdDOqgej0OP"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "p8snJGQumomB"
      },
      "outputs": [],
      "source": [
        "# set display to max width\n",
        "pd.set_option('display.max_colwidth', None)\n",
        "\n",
        "# load cleaned Reddit ds - Pegasus\n",
        "df_peg = pd.read_csv('drive/My Drive/W266/pegasus_results.csv')\n",
        "\n",
        "# load cleaned Reddit ds - T5\n",
        "df_t5 = pd.read_csv('drive/My Drive/W266/t5_results.csv')\n",
        "\n",
        "# load cleaned Reddit ds - GPT-3\n",
        "df_gpt = pd.read_csv('drive/My Drive/W266/gpt_results.csv')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(df_peg.info(),\"\\n\")\n",
        "print(df_t5.info(),\"\\n\")\n",
        "print(df_gpt.info(),\"\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QGtpG76NvOIr",
        "outputId": "e534ffd1-b1f0-48bb-f5ef-1774fe8344b1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 1250 entries, 0 to 1249\n",
            "Data columns (total 4 columns):\n",
            " #   Column           Non-Null Count  Dtype \n",
            "---  ------           --------------  ----- \n",
            " 0   Index_ID         1250 non-null   int64 \n",
            " 1   ref_post         1250 non-null   object\n",
            " 2   ref_title        1250 non-null   object\n",
            " 3   candidate_title  1250 non-null   object\n",
            "dtypes: int64(1), object(3)\n",
            "memory usage: 39.2+ KB\n",
            "None \n",
            "\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 1250 entries, 0 to 1249\n",
            "Data columns (total 4 columns):\n",
            " #   Column           Non-Null Count  Dtype \n",
            "---  ------           --------------  ----- \n",
            " 0   Index_ID         1250 non-null   int64 \n",
            " 1   ref_post         1250 non-null   object\n",
            " 2   ref_title        1250 non-null   object\n",
            " 3   candidate_title  1250 non-null   object\n",
            "dtypes: int64(1), object(3)\n",
            "memory usage: 39.2+ KB\n",
            "None \n",
            "\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 1250 entries, 0 to 1249\n",
            "Data columns (total 4 columns):\n",
            " #   Column           Non-Null Count  Dtype \n",
            "---  ------           --------------  ----- \n",
            " 0   Index_ID         1250 non-null   int64 \n",
            " 1   ref_post         1250 non-null   object\n",
            " 2   ref_title        1250 non-null   object\n",
            " 3   candidate_title  1250 non-null   object\n",
            "dtypes: int64(1), object(3)\n",
            "memory usage: 39.2+ KB\n",
            "None \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "def subset_columns(df):\n",
        "    \"\"\"\n",
        "    Takes a DataFrame and returns subsets containing 'ref_post', 'ref_title',\n",
        "    and 'candidate_title' columns.\n",
        "\n",
        "    Parameters:\n",
        "    - df: The input DataFrame from which the subsets will be created.\n",
        "\n",
        "    Returns:\n",
        "    - A tuple of DataFrames containing the specified columns.\n",
        "    \"\"\"\n",
        "    ref_post = pd.DataFrame(df['ref_post'])\n",
        "    ref_title = pd.DataFrame(df['ref_title'])\n",
        "    candidate_title = pd.DataFrame(df['candidate_title'])\n",
        "\n",
        "    return ref_post, ref_title, candidate_title"
      ],
      "metadata": {
        "id": "8gCkKbz-iauJ"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Set the number of test samples to evaluate\n",
        "sample_size = 1250"
      ],
      "metadata": {
        "id": "r9EmWerRtc1I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3. Angular Similarity and Fréchet's Distance\n",
        "Here we define functions for **Angular Similarity** and **Fréchet's distance**.\n",
        "\n",
        "Angular Similarity is a measure related related to [Cosine Similarity](https://en.wikipedia.org/wiki/Cosine_similarity). It's refers to the normalized angle between two vectors and bounded between 0 and 1. An Angular Similarity that's close to $1$ suggests that embeddings are similar in terms of semantic meaning while $0$ suggest otherwise.\n",
        "\n",
        "[Frechet's distance](https://https://en.wikipedia.org/wiki/Fr%C3%A9chet_distance) is a measure of similarity between two curves that takes into account the ordering and location of points. For NLP, it can be used as a quantitative measure of semanatic similarity between machined generated and human texts. Unlike Angular Similarity, lower values of Fréchet's distance indicate greater similarity.  "
      ],
      "metadata": {
        "id": "aLTCZ3uRaPwK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "def angular_similarity(tensor_a, tensor_b):\n",
        "  #normalize tensors\n",
        "  norm_a = tf.nn.l2_normalize(tensor_a, axis=1)\n",
        "  norm_b = tf.nn.l2_normalize(tensor_b, axis=1)\n",
        "\n",
        "  #cosine similarity\n",
        "  cosine_similarity = tf.reduce_sum(tf.multiply(norm_a, norm_b), axis=1)\n",
        "\n",
        "  #angular similarity\n",
        "  angular_similarity = (1 - tf.acos(cosine_similarity) / np.pi).numpy()\n",
        "\n",
        "  return angular_similarity\n",
        "\n",
        "def frechet_distance(tensor_a, tensor_b):\n",
        "  #euclidean distance\n",
        "  frechet_distance = tf.norm(tensor_a - tensor_b, ord='euclidean').numpy()\n",
        "\n",
        "  #print(\"Fréchet Distance :\", frechet_distance)\n",
        "\n",
        "  return frechet_distance"
      ],
      "metadata": {
        "id": "3Xu2Sn-Gplwo"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Test the Angular Similarity and Frechet's Distance\n",
        "tensor_a = tf.constant([[1, 1]], dtype=tf.float32)\n",
        "tensor_b = tf.constant([[1, 1]], dtype=tf.float32)\n",
        "print(\"Angular Sim :\",angular_similarity(tensor_a, tensor_b))\n",
        "print(\"Frechet :\",frechet_distance(tensor_a, tensor_b))"
      ],
      "metadata": {
        "id": "LKbvo04EqVi5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "657a378c-988a-4fee-def2-220a1141f952"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Angular Sim : [0.9998901]\n",
            "Frechet : 0.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4. Universal Sentence Encoder"
      ],
      "metadata": {
        "id": "iJDs-Ui9rLfX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import the Universal Sentence Encoder's TF Hub module\n",
        "\n",
        "# Assume module_url is defined somewhere in your code\n",
        "module_url = \"https://tfhub.dev/google/universal-sentence-encoder/4\"\n",
        "embed = hub.load(module_url)"
      ],
      "metadata": {
        "id": "LqmYzdWMrQ_z"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5. Model Evaluation: Angular Embedding Similarity and Fréchet's Distance"
      ],
      "metadata": {
        "id": "t0Kh5E5QtnQ6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Pegasus"
      ],
      "metadata": {
        "id": "I4CZSwi5q1nL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Encode Pegasus with USE\n",
        "ref_post, ref_title, candidate_title = subset_columns(df_peg)\n",
        "\n",
        "# Embed data\n",
        "# original post\n",
        "ref_post_embeddings = embed(ref_post[:sample_size].values.flatten())\n",
        "\n",
        "# original title (ground truth)\n",
        "ref_title_embeddings = embed(ref_title[:sample_size].values.flatten())\n",
        "\n",
        "# generated title\n",
        "candidate_title_embeddings = embed(candidate_title[:sample_size].values.flatten())\n",
        "\n",
        "# print first 5 records\n",
        "candidate_title.head(5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "otI1GilkqS03",
        "outputId": "bc774b2f-f10f-43f7-ea6c-6836df732e10"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                                                  candidate_title\n",
              "0                       what are some good data science bootcamps\n",
              "1  is there a better way to store and train a model for later use\n",
              "2          how to deal with missing values in logistic regression\n",
              "3          how do i go about retraining my google analytics model\n",
              "4        how do i deal with missing values in logistic regression"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-c5f44378-e0b4-4f66-ad79-d53746de008e\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>candidate_title</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>what are some good data science bootcamps</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>is there a better way to store and train a model for later use</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>how to deal with missing values in logistic regression</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>how do i go about retraining my google analytics model</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>how do i deal with missing values in logistic regression</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-c5f44378-e0b4-4f66-ad79-d53746de008e')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-c5f44378-e0b4-4f66-ad79-d53746de008e button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-c5f44378-e0b4-4f66-ad79-d53746de008e');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-dfd4eadc-c255-448b-80c9-065e9726ff78\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-dfd4eadc-c255-448b-80c9-065e9726ff78')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-dfd4eadc-c255-448b-80c9-065e9726ff78 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "variable_name": "candidate_title",
              "summary": "{\n  \"name\": \"candidate_title\",\n  \"rows\": 1250,\n  \"fields\": [\n    {\n      \"column\": \"candidate_title\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 995,\n        \"samples\": [\n          \"resume critique\",\n          \"is it worth getting a masters in data science if i already have a job as a lawyer\",\n          \"question about batch normalization\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {},
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Angular Similarity Calculation\n",
        "ang_sim_gen_title_ref_post = []\n",
        "ang_sim_ref_title_ref_post = []\n",
        "\n",
        "# Fréchet's Distance Calculation\n",
        "fd_gen_title_ref_post = []\n",
        "fd_ref_title_ref_post = []\n",
        "\n",
        "for i in range(len(candidate_title_embeddings)):\n",
        "\n",
        "  gen_title = np.expand_dims(candidate_title_embeddings[i], axis=0)\n",
        "  ref_title = np.expand_dims(ref_title_embeddings[i], axis=0)\n",
        "  ref_post = np.expand_dims(ref_post_embeddings[i], axis=0)\n",
        "\n",
        "  # compare Angular Sim - generated title vs original post\n",
        "  ang_sim_gen_title_ref_post.append(float(angular_similarity(gen_title, ref_post)[0]))\n",
        "\n",
        "  # compare Angular Sim - original title (ground truth) vs original post\n",
        "  ang_sim_ref_title_ref_post.append(float(angular_similarity(ref_title, ref_post)[0]))\n",
        "\n",
        "  # compare Fréchet's Distance - generated title vs original post\n",
        "  fd_gen_title_ref_post.append(float(frechet_distance(gen_title, ref_post)))\n",
        "\n",
        "  # compare Fréchet's Distance -  original title (ground truth) vs original post\n",
        "  fd_ref_title_ref_post.append(float(frechet_distance(ref_title, ref_post)))\n",
        "\n",
        "print(\" Pegasus Results \".center(50, \"*\"))\n",
        "print(\"Shape :\",candidate_title_embeddings.shape)\n",
        "\n",
        "# Angular Similarity\n",
        "summary_ang_sim_gen_title_ref_post = np.mean(ang_sim_gen_title_ref_post)\n",
        "print(\"Angular Sim - Candidate Title vs Ref Post :\\t\\t\",summary_ang_sim_gen_title_ref_post)\n",
        "summary_ang_sim_ref_title_ref_post = np.mean(ang_sim_ref_title_ref_post)\n",
        "print(\"Angular Sim - Ref Title vs Ref Post :\\t\\t\\t\",summary_ang_sim_ref_title_ref_post,\"\\n\")\n",
        "\n",
        "# Fréchet's Distance\n",
        "summary_fd_gen_title_ref_post = np.mean(fd_gen_title_ref_post)\n",
        "print(\"Fréchet's Distance - Candidate Title vs Ref Post :\\t\",summary_fd_gen_title_ref_post)\n",
        "\n",
        "summary_fd_ref_title_ref_post = np.mean(fd_ref_title_ref_post)\n",
        "print(\"Fréchet's Distance - Ref Title vs Ref Post :\\t\\t\",summary_fd_ref_title_ref_post)"
      ],
      "metadata": {
        "id": "QEaumFg7s05K",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7ba460d4-bdba-46b0-f633-12250fa3385b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "**************** Pegasus Results *****************\n",
            "Shape : (1250, 512)\n",
            "Angular Sim - Candidate Title vs Ref Post :\t\t 0.6372447463512421\n",
            "Angular Sim - Ref Title vs Ref Post :\t\t\t 0.640458917093277 \n",
            "\n",
            "Fréchet's Distance - Candidate Title vs Ref Post :\t 1.0755447518825532\n",
            "Fréchet's Distance - Ref Title vs Ref Post :\t\t 1.0669682736873627\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Angular Similarity - Generated Title vs. Reference Post\n",
        "sns.histplot(ang_sim_gen_title_ref_post, kde=True)\n",
        "plt.xlabel('angular similarity')\n",
        "plt.ylabel('count')\n",
        "plt.title('Angular Similarity - Generated Title vs. Reference Post')\n",
        "plt.axvline(summary_ang_sim_gen_title_ref_post,linestyle='-.', color='red')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 489
        },
        "id": "iIELbvEm85zC",
        "outputId": "bdf75b4d-23f7-454e-872f-3155c5f71d78"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.lines.Line2D at 0x784e4b512260>"
            ]
          },
          "metadata": {},
          "execution_count": 87
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Angular Similarity - Reference Title vs. Reference Post\n",
        "sns.histplot(ang_sim_ref_title_ref_post, kde=True)\n",
        "plt.xlabel('angular similarity')\n",
        "plt.ylabel('count')\n",
        "plt.title('Angular Similarity - Reference Title vs. Reference Post')\n",
        "plt.axvline(summary_ang_sim_ref_title_ref_post,linestyle='-.',color='red')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 489
        },
        "id": "rzD-VqT29rPd",
        "outputId": "c82bbdf1-1169-437e-cd3b-71043194d852"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.lines.Line2D at 0x784e0e364220>"
            ]
          },
          "metadata": {},
          "execution_count": 88
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### T5"
      ],
      "metadata": {
        "id": "IQSkeBuKrIe0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Encode T5\n",
        "ref_post, ref_title, candidate_title = subset_columns(df_t5)\n",
        "\n",
        "# Embed data\n",
        "# original post\n",
        "ref_post_embeddings = embed(ref_post[:sample_size].values.flatten())\n",
        "\n",
        "# original title (ground truth)\n",
        "ref_title_embeddings = embed(ref_title[:sample_size].values.flatten())\n",
        "\n",
        "# generated title\n",
        "candidate_title_embeddings = embed(candidate_title[:sample_size].values.flatten())\n",
        "\n",
        "# print first 5 records\n",
        "candidate_title.head(5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "GbZPmSbZrQeo",
        "outputId": "4c6acd7e-61ee-4cce-dcb4-15fad93990cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                                                                    candidate_title\n",
              "0                    what is the best way to get a job in the field of data science\n",
              "1                                                           python spacy for ngrams\n",
              "2              what is the best way of calculating the weights for a neural network\n",
              "3  what is the best way of storing a large amount of data in the retraining process\n",
              "4                      how do i get the best results out of the mahalanobis dataset"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-4ca9e357-bb92-4bac-b91e-582d5d3a124c\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>candidate_title</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>what is the best way to get a job in the field of data science</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>python spacy for ngrams</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>what is the best way of calculating the weights for a neural network</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>what is the best way of storing a large amount of data in the retraining process</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>how do i get the best results out of the mahalanobis dataset</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-4ca9e357-bb92-4bac-b91e-582d5d3a124c')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-4ca9e357-bb92-4bac-b91e-582d5d3a124c button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-4ca9e357-bb92-4bac-b91e-582d5d3a124c');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-7664f9e8-1a11-4d38-91d9-ddc56e564281\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-7664f9e8-1a11-4d38-91d9-ddc56e564281')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-7664f9e8-1a11-4d38-91d9-ddc56e564281 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "variable_name": "candidate_title",
              "summary": "{\n  \"name\": \"candidate_title\",\n  \"rows\": 1250,\n  \"fields\": [\n    {\n      \"column\": \"candidate_title\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 1122,\n        \"samples\": [\n          \"what are the skills i should have in a ds team\",\n          \"how do i train a neural network with pytorch in tensorflow\",\n          \"how do i get better at data science\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {},
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Angular Similarity Calculation\n",
        "ang_sim_gen_title_ref_post = []\n",
        "ang_sim_ref_title_ref_post = []\n",
        "\n",
        "# Fréchet's Distance Calculation\n",
        "fd_gen_title_ref_post = []\n",
        "fd_ref_title_ref_post = []\n",
        "\n",
        "for i in range(len(candidate_title_embeddings)):\n",
        "\n",
        "  gen_title = np.expand_dims(candidate_title_embeddings[i], axis=0)\n",
        "  ref_title = np.expand_dims(ref_title_embeddings[i], axis=0)\n",
        "  ref_post = np.expand_dims(ref_post_embeddings[i], axis=0)\n",
        "\n",
        "  # compare Angular Sim - generated title vs original post\n",
        "  ang_sim_gen_title_ref_post.append(float(angular_similarity(gen_title, ref_post)[0]))\n",
        "\n",
        "  # compare Angular Sim - original title (ground truth) vs original post\n",
        "  ang_sim_ref_title_ref_post.append(float(angular_similarity(ref_title, ref_post)[0]))\n",
        "\n",
        "  # compare Fréchet's Distance - generated title vs original post\n",
        "  fd_gen_title_ref_post.append(float(frechet_distance(gen_title, ref_post)))\n",
        "\n",
        "  # compare Fréchet's Distance -  original title (ground truth) vs original post\n",
        "  fd_ref_title_ref_post.append(float(frechet_distance(ref_title, ref_post)))\n",
        "\n",
        "print(\" T5 Results \".center(50, \"*\"))\n",
        "print(\"Shape :\",candidate_title_embeddings.shape)\n",
        "\n",
        "# Angular Similarity\n",
        "summary_ang_sim_gen_title_ref_post = np.mean(ang_sim_gen_title_ref_post)\n",
        "print(\"Angular Sim - Candidate Title vs Ref Post :\\t\\t\",summary_ang_sim_gen_title_ref_post)\n",
        "summary_ang_sim_ref_title_ref_post = np.mean(ang_sim_ref_title_ref_post)\n",
        "print(\"Angular Sim - Ref Title vs Ref Post :\\t\\t\\t\",summary_ang_sim_ref_title_ref_post,\"\\n\")\n",
        "\n",
        "# Fréchet's Distance\n",
        "summary_fd_gen_title_ref_post = np.mean(fd_gen_title_ref_post)\n",
        "print(\"Fréchet's Distance - Candidate Title vs Ref Post :\\t\",summary_fd_gen_title_ref_post)\n",
        "\n",
        "summary_fd_ref_title_ref_post = np.mean(fd_ref_title_ref_post)\n",
        "print(\"Fréchet's Distance - Ref Title vs Ref Post :\\t\\t\",summary_fd_ref_title_ref_post)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6-t6q8o-rHl_",
        "outputId": "5a126a6d-9b9b-4b36-ca6f-3b794dd645dd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "******************* T5 Results *******************\n",
            "Shape : (1250, 512)\n",
            "Angular Sim - Candidate Title vs Ref Post :\t\t 0.6484775321960449\n",
            "Angular Sim - Ref Title vs Ref Post :\t\t\t 0.640458917093277 \n",
            "\n",
            "Fréchet's Distance - Candidate Title vs Ref Post :\t 1.046222029018402\n",
            "Fréchet's Distance - Ref Title vs Ref Post :\t\t 1.0669682736873627\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Angular Similarity - Generated Title vs. Reference Post\n",
        "sns.histplot(ang_sim_gen_title_ref_post, kde=True)\n",
        "plt.xlabel('angular similarity')\n",
        "plt.ylabel('count')\n",
        "plt.title('Angular Similarity - Generated Title vs. Reference Post')\n",
        "plt.axvline(summary_ang_sim_gen_title_ref_post,linestyle='-.', color='red')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 489
        },
        "id": "P8t9NcPV8uua",
        "outputId": "06f4af46-e400-4e7f-f6de-65d2b8405b73"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.lines.Line2D at 0x784e0e2117b0>"
            ]
          },
          "metadata": {},
          "execution_count": 91
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Angular Similarity - Reference Title vs. Reference Post\n",
        "sns.histplot(ang_sim_ref_title_ref_post, kde=True)\n",
        "plt.xlabel('angular similarity')\n",
        "plt.ylabel('count')\n",
        "plt.title('Angular Similarity - Reference Title vs. Reference Post')\n",
        "plt.axvline(summary_ang_sim_ref_title_ref_post,linestyle='-.',color='red')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 489
        },
        "id": "oFQhEjyw9CLr",
        "outputId": "a96e9481-524c-427b-c5da-affdd4e90ea4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.lines.Line2D at 0x784e0e1d9ed0>"
            ]
          },
          "metadata": {},
          "execution_count": 92
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### GPT-2"
      ],
      "metadata": {
        "id": "4tevP21sty0F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Encode GPT with USE\n",
        "ref_post, ref_title, candidate_title = subset_columns(df_gpt)\n",
        "\n",
        "# Embed data\n",
        "# original post\n",
        "ref_post_embeddings = embed(ref_post[:sample_size].values.flatten())\n",
        "\n",
        "# original title (ground truth)\n",
        "ref_title_embeddings = embed(ref_title[:sample_size].values.flatten())\n",
        "\n",
        "# generated title\n",
        "candidate_title_embeddings = embed(candidate_title[:sample_size].values.flatten())\n",
        "\n",
        "# print first 5 records\n",
        "candidate_title.head(5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 536
        },
        "outputId": "6727c5ad-7b12-43b8-8152-cd8820f100fd",
        "id": "54g6869891eD"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           candidate_title\n",
              "0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             some background i have been learning python for over a year now and i know some sql a bit of r and i have completed some small projects using data science data engineering practices i also know how to work in excel but i do not really have experience using databases i am totally willing to make the time and money investment in something like a bootcamp and i have the means to do fulltime training but i do not want to do this if there is a better faster way to get into the industry what i really want to know is what can i do that will get me a job in the field asap is there some specific bootcamp that will make this happen if so what are the best bootcamps or some particular tech skill i could learn that would basically guarantee that i am hireable very soon if i something like learned microsoft sql server or tableau and given my other skills would this be likely to get me hired i have been looking into bootcamps like thinkful springboard and data application lab the concern i have about these is actually that i already know a lot of the stuff they teach and i am worried that these will be a waste of time and not elevate me to where i want to be i also worry about it taking months to complete these programs as they estimate i would like to be finished in no more than about months thoughts\n",
              "1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hi all i have created a python module to extract sngrams which is different from traditional ngrams as it embodies linguistic syntactic trees thus making it less arbitrary than traditional ngrams as it goes without saying quality of input feature affects model performance this will help you improve your model accuracy even further built on language models of spacy it can help especially for text classification information extraction query understanding machine translation question answering systems below is an example from sngramextractor import sngramextractor ampxb sngram_objsngramextractortextmeta_tagoriginaltrigram_flagyes texteconomic news have little effect on financial markets outputsngram_objget_sngram printtext print isngram bigramoutput isnbigram print isngram trigramoutput isntrigram economic news have little effect on financial markets sngram bigram cloud_every has_cloud lining_a lining_silver has_lining sngram trigram has_lining_silver ampxb textevery cloud has a silver lining outputsngram_objget_sngram printtext print isngram bigramoutput isnbigram print isngram trigramoutput isntrigram ampxb every cloud has a silver lining sngram bigram cloud_every has_cloud lining_a lining_silver has_lining sngram trigram has_lining_silver ampxb pypi\n",
              "2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i am looking at some of the modeling programs the company has been using and there are options to smooth binned data layered linear on bin linear on avg linear on log avg and variable gradient are these methods commonly used in any algorithms i am not sure how i would implement it into r ampxb variable gradient is the most confusing it groups data from neighboring bins with a bin factor being determined the level of smoothing is determined by the radius all bins contribute to the calculation of the bin factor with decreasing weight as the distance from the target bin increases the weight is equal to radius distance radius ampxb once you calculate the overall factor a calculation is performed for each bin weighted by an exposure with various radii and a selected credibility level the calculation that yields the largest distance from is then selected as the factor to be used for that bin ampxb over multiple iterations of the model the factors are blended until the model converges and we receive a final coefficient for that bin ampxb since it is a program i have no clue what is going on in the background to calculate the convergence or what type of model this is it ends up being a multiplicative model so i am guessing it is a log linked glm\n",
              "3                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      let is say i have created a fraud detection model i already have a process that cleans the data and stores the trainable data in a table in a database and now i want to set up a recurring job that retrains my model every x time period how do people go about this when we want to retrain the model does not that data have to be loaded into the environment that the new model is going to be retrained i guess i am confused at how exactly the model takes the data from the database and starts training on it do people use spark to load it into the environment with the modeltobe then start the retraining process does not that mean that the retraining environment has to have enough space to cover that data being brought in apologies if this has already been asked but i have not seen a clear answer from this subredditfrom what i have found on google thanks so much for any assistance\n",
              "4  i am working with a dataset of patient performancedata and patient demographics for people with a medical condition i am trying to assess the effect of a treatment on the patients and as i am trying to replicate a randomized experiment from a observational study i am performing matching between the treatment and control group when i try to perform mahalanobis distance matching however i keep getting the following warning on matlab warning matrix is close to singular or badly scaled results may be inaccurate rcond e the warning was caused because the determinant of my covariance matrix was very close to so when i calculated the inverse of this matrix as i need to do for finding the mahalanobis distance the matrix element values become very close to as well after reading about this warning a little bit i found that when this warning is displayed the results of mahalanobis distance matching is not very reliable i thought this was because my matrix became very sparse after i introduced onehotencoding to split the multicategorical features into many different features and hence some of my new features were for category values that had very few occurrences less than to address this issue i got rid of the category values with very low occurrences less than or binned them together with other lowoccurrence category values into slightly larger bins so their chances of occurring increased and my datamatrix was less sparse so i reduced the number of features from to and i plotted the histograms for all my features to see their distributions and this is what it looked like note that the element values have been normalized to by subtracting the feature mean and then divided by the feature standard deviation it looked visually satisfactory to me but i still kept getting the same warning in matlab when i tried finding the determinant of my new covariance matrix it was still very small e in a further attempt to fix this issue i checked whether removing all of the categorical features if we consider the onehot encoded features made things any better by making the matrix less sparse the new featurehistogram looked like this this time when i tried mahalanobis distance matching the warning was removed because the determinant of the covariance matrix was larger e so i tried to see if i could include one of the removed multicategorical features without facing the same problem as these are important features i would prefer to include when doing my matching i added a categorical feature with possible values and all the values very well distributed see histogram below but alas simply including these new onehotencoded features seems to cause the determinant of the covariance matrix to become so small that i start getting"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-8a520cd6-7805-4be4-95fd-48c24ffe59c0\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>candidate_title</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>some background i have been learning python for over a year now and i know some sql a bit of r and i have completed some small projects using data science data engineering practices i also know how to work in excel but i do not really have experience using databases i am totally willing to make the time and money investment in something like a bootcamp and i have the means to do fulltime training but i do not want to do this if there is a better faster way to get into the industry what i really want to know is what can i do that will get me a job in the field asap is there some specific bootcamp that will make this happen if so what are the best bootcamps or some particular tech skill i could learn that would basically guarantee that i am hireable very soon if i something like learned microsoft sql server or tableau and given my other skills would this be likely to get me hired i have been looking into bootcamps like thinkful springboard and data application lab the concern i have about these is actually that i already know a lot of the stuff they teach and i am worried that these will be a waste of time and not elevate me to where i want to be i also worry about it taking months to complete these programs as they estimate i would like to be finished in no more than about months thoughts</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>hi all i have created a python module to extract sngrams which is different from traditional ngrams as it embodies linguistic syntactic trees thus making it less arbitrary than traditional ngrams as it goes without saying quality of input feature affects model performance this will help you improve your model accuracy even further built on language models of spacy it can help especially for text classification information extraction query understanding machine translation question answering systems below is an example from sngramextractor import sngramextractor ampxb sngram_objsngramextractortextmeta_tagoriginaltrigram_flagyes texteconomic news have little effect on financial markets outputsngram_objget_sngram printtext print isngram bigramoutput isnbigram print isngram trigramoutput isntrigram economic news have little effect on financial markets sngram bigram cloud_every has_cloud lining_a lining_silver has_lining sngram trigram has_lining_silver ampxb textevery cloud has a silver lining outputsngram_objget_sngram printtext print isngram bigramoutput isnbigram print isngram trigramoutput isntrigram ampxb every cloud has a silver lining sngram bigram cloud_every has_cloud lining_a lining_silver has_lining sngram trigram has_lining_silver ampxb pypi</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>i am looking at some of the modeling programs the company has been using and there are options to smooth binned data layered linear on bin linear on avg linear on log avg and variable gradient are these methods commonly used in any algorithms i am not sure how i would implement it into r ampxb variable gradient is the most confusing it groups data from neighboring bins with a bin factor being determined the level of smoothing is determined by the radius all bins contribute to the calculation of the bin factor with decreasing weight as the distance from the target bin increases the weight is equal to radius distance radius ampxb once you calculate the overall factor a calculation is performed for each bin weighted by an exposure with various radii and a selected credibility level the calculation that yields the largest distance from is then selected as the factor to be used for that bin ampxb over multiple iterations of the model the factors are blended until the model converges and we receive a final coefficient for that bin ampxb since it is a program i have no clue what is going on in the background to calculate the convergence or what type of model this is it ends up being a multiplicative model so i am guessing it is a log linked glm</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>let is say i have created a fraud detection model i already have a process that cleans the data and stores the trainable data in a table in a database and now i want to set up a recurring job that retrains my model every x time period how do people go about this when we want to retrain the model does not that data have to be loaded into the environment that the new model is going to be retrained i guess i am confused at how exactly the model takes the data from the database and starts training on it do people use spark to load it into the environment with the modeltobe then start the retraining process does not that mean that the retraining environment has to have enough space to cover that data being brought in apologies if this has already been asked but i have not seen a clear answer from this subredditfrom what i have found on google thanks so much for any assistance</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>i am working with a dataset of patient performancedata and patient demographics for people with a medical condition i am trying to assess the effect of a treatment on the patients and as i am trying to replicate a randomized experiment from a observational study i am performing matching between the treatment and control group when i try to perform mahalanobis distance matching however i keep getting the following warning on matlab warning matrix is close to singular or badly scaled results may be inaccurate rcond e the warning was caused because the determinant of my covariance matrix was very close to so when i calculated the inverse of this matrix as i need to do for finding the mahalanobis distance the matrix element values become very close to as well after reading about this warning a little bit i found that when this warning is displayed the results of mahalanobis distance matching is not very reliable i thought this was because my matrix became very sparse after i introduced onehotencoding to split the multicategorical features into many different features and hence some of my new features were for category values that had very few occurrences less than to address this issue i got rid of the category values with very low occurrences less than or binned them together with other lowoccurrence category values into slightly larger bins so their chances of occurring increased and my datamatrix was less sparse so i reduced the number of features from to and i plotted the histograms for all my features to see their distributions and this is what it looked like note that the element values have been normalized to by subtracting the feature mean and then divided by the feature standard deviation it looked visually satisfactory to me but i still kept getting the same warning in matlab when i tried finding the determinant of my new covariance matrix it was still very small e in a further attempt to fix this issue i checked whether removing all of the categorical features if we consider the onehot encoded features made things any better by making the matrix less sparse the new featurehistogram looked like this this time when i tried mahalanobis distance matching the warning was removed because the determinant of the covariance matrix was larger e so i tried to see if i could include one of the removed multicategorical features without facing the same problem as these are important features i would prefer to include when doing my matching i added a categorical feature with possible values and all the values very well distributed see histogram below but alas simply including these new onehotencoded features seems to cause the determinant of the covariance matrix to become so small that i start getting</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-8a520cd6-7805-4be4-95fd-48c24ffe59c0')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-8a520cd6-7805-4be4-95fd-48c24ffe59c0 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-8a520cd6-7805-4be4-95fd-48c24ffe59c0');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-f2cc7d07-ffd6-49db-a2ea-7801fe05fbd0\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-f2cc7d07-ffd6-49db-a2ea-7801fe05fbd0')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-f2cc7d07-ffd6-49db-a2ea-7801fe05fbd0 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "variable_name": "candidate_title",
              "summary": "{\n  \"name\": \"candidate_title\",\n  \"rows\": 1250,\n  \"fields\": [\n    {\n      \"column\": \"candidate_title\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 1249,\n        \"samples\": [\n          \"if i sound like a complete novice please bear with me i am trying to extract keyvalue pairs from invoice pdfs such as invoiceto addressofvendor tablesthis seems tough to implement and receipt images such as vendor subtotal date etc i have tried to ocr the reciepts and nonsearchable pdfs while i am getting good results with tesseract spacial information such as for tables is getting jumbled up how do i find the keyvalue pairs what could be the dataset for the machine learning model would named entity recognition be enough from unstructured text i think with only nlp i might not be able to detect tables i am trying to construct a general purpose pipeline so i can use a minimum of rulebased matching or templatematching i am open to any more ideas\",\n          \"ive been a digital strategist for the better part of my career and adulthood and in an effort to remain relevant and employable i have been toying with the idea of transitioning into cyber security or going down deeper the rabbit hole or so i think of digital strategy by arming myself with data science and analytics skill sets ive registered for a data science certificate course with ryerson university in toronto and thought i get a head start by doing some self study through the course of my research i came across tomi mester where his untold truths about data science hit home he sounds like the real deal but thought i ask some budding data science honchos and aspirants here has anyone taken his course is this guy a good start to sink my teeth in what would be an area to define the rest of my career any recommendations on other portals for a noob like me thank you all\",\n          \"i applied for an internship position as a data scientist in a startup i had one technical interview of hour regular coding questions and ml questions then an open question feature prediction for which i had week to complete then two hour technical tests onsite on g\\u00e9n\\u00e9ral coding skills and ml knowledge i have my final interview with the data science director tomorrow it is expected to last between min and hour the recruiter told me there might be a technical part what kind of questions do you think the data science director could ask i want to prepare it the best i can but i am not sure if i should focus on ml algorithms the theory behind them or maybe prepare present yourself and why join us questions i know no one can know but maybe some of you went through a lot of processes and have more experience with it thanks in advance i spent so much time on this application more than hr in total i really do not want to screw this also the company is very well reviewed on glassdoor and i had a great impression when i did my onsite tests\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {},
          "execution_count": 93
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Angular Similarity Calculation\n",
        "ang_sim_gen_title_ref_post = []\n",
        "ang_sim_ref_title_ref_post = []\n",
        "\n",
        "# Fréchet's Distance Calculation\n",
        "fd_gen_title_ref_post = []\n",
        "fd_ref_title_ref_post = []\n",
        "\n",
        "for i in range(len(candidate_title_embeddings)):\n",
        "\n",
        "  gen_title = np.expand_dims(candidate_title_embeddings[i], axis=0)\n",
        "  ref_title = np.expand_dims(ref_title_embeddings[i], axis=0)\n",
        "  ref_post = np.expand_dims(ref_post_embeddings[i], axis=0)\n",
        "\n",
        "  # compare Angular Sim - generated title vs original post\n",
        "  ang_sim_gen_title_ref_post.append(float(angular_similarity(gen_title, ref_post)[0]))\n",
        "\n",
        "  # compare Angular Sim - original title (ground truth) vs original post\n",
        "  ang_sim_ref_title_ref_post.append(float(angular_similarity(ref_title, ref_post)[0]))\n",
        "\n",
        "  # compare Fréchet's Distance - generated title vs original post\n",
        "  fd_gen_title_ref_post.append(float(frechet_distance(gen_title, ref_post)))\n",
        "\n",
        "  # compare Fréchet's Distance -  original title (ground truth) vs original post\n",
        "  fd_ref_title_ref_post.append(float(frechet_distance(ref_title, ref_post)))\n",
        "\n",
        "print(\" GPT Results \".center(50, \"*\"))\n",
        "print(\"Shape :\",candidate_title_embeddings.shape)\n",
        "\n",
        "# Angular Similarity\n",
        "summary_ang_sim_gen_title_ref_post = np.mean(ang_sim_gen_title_ref_post)\n",
        "print(\"Angular Sim - Candidate Title vs Ref Post :\\t\\t\",summary_ang_sim_gen_title_ref_post)\n",
        "summary_ang_sim_ref_title_ref_post = np.mean(ang_sim_ref_title_ref_post)\n",
        "print(\"Angular Sim - Ref Title vs Ref Post :\\t\\t\\t\",summary_ang_sim_ref_title_ref_post,\"\\n\")\n",
        "\n",
        "# Fréchet's Distance\n",
        "summary_fd_gen_title_ref_post = np.mean(fd_gen_title_ref_post)\n",
        "print(\"Fréchet's Distance - Candidate Title vs Ref Post :\\t\",summary_fd_gen_title_ref_post)\n",
        "\n",
        "summary_fd_ref_title_ref_post = np.mean(fd_ref_title_ref_post)\n",
        "print(\"Fréchet's Distance - Ref Title vs Ref Post :\\t\\t\",summary_fd_ref_title_ref_post)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "19d21bb2-fc09-4610-8837-cebb3dc406b0",
        "id": "WXN0sMDv91eO"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "****************** GPT Results *******************\n",
            "Shape : (1250, 512)\n",
            "Angular Sim - Candidate Title vs Ref Post :\t\t nan\n",
            "Angular Sim - Ref Title vs Ref Post :\t\t\t 0.640458917093277 \n",
            "\n",
            "Fréchet's Distance - Candidate Title vs Ref Post :\t 0.011734050008654594\n",
            "Fréchet's Distance - Ref Title vs Ref Post :\t\t 1.0669682736873627\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Angular Similarity - Generated Title vs. Reference Post\n",
        "sns.histplot(ang_sim_gen_title_ref_post, kde=True)\n",
        "plt.xlabel('angular similarity')\n",
        "plt.ylabel('count')\n",
        "plt.title('Angular Similarity - Generated Title vs. Reference Post')\n",
        "plt.axvline(summary_ang_sim_gen_title_ref_post,linestyle='-.', color='red')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 489
        },
        "id": "vYkkhvKo91eO",
        "outputId": "906089c8-c368-405d-ad7c-363542c63c87"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.lines.Line2D at 0x784e0e12bb20>"
            ]
          },
          "metadata": {},
          "execution_count": 95
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Angular Similarity - Reference Title vs. Reference Post\n",
        "sns.histplot(ang_sim_ref_title_ref_post, kde=True)\n",
        "plt.xlabel('angular similarity')\n",
        "plt.ylabel('count')\n",
        "plt.title('Angular Similarity - Reference Title vs. Reference Post')\n",
        "plt.axvline(summary_ang_sim_ref_title_ref_post,linestyle='-.',color='red')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 489
        },
        "id": "iqxpMQrc91eO",
        "outputId": "0702b451-19e1-40f9-ce18-9d789968ff31"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.lines.Line2D at 0x784e0e12bfa0>"
            ]
          },
          "metadata": {},
          "execution_count": 96
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Additional Evaluation\n",
        "Randomly sample 15 posts/titles for human evaluaton from model with the best overal metrics"
      ],
      "metadata": {
        "id": "bwN82C3lXuXz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# create a randomly sample dataframe\n",
        "sample_t5 = df_t5.sample(n=30, random_state=1)\n",
        "display(sample_t5)\n",
        "\n",
        "# create convert dataframe to list for Rouge and BLEU eval\n",
        "ref_post_list = sample_t5['ref_post'].tolist()\n",
        "ref_title_list = sample_t5['ref_title'].tolist()\n",
        "candidate_title_list = sample_t5['candidate_title'].tolist()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "ig2AVbUwZJEc",
        "outputId": "9ee2c121-ef3f-4538-d832-79f1a057f91a"
      },
      "execution_count": 138,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "      Index_ID  \\\n",
              "408        408   \n",
              "711        711   \n",
              "1114      1114   \n",
              "699        699   \n",
              "236        236   \n",
              "119        119   \n",
              "262        262   \n",
              "107        107   \n",
              "267        267   \n",
              "268        268   \n",
              "491        491   \n",
              "108        108   \n",
              "661        661   \n",
              "951        951   \n",
              "977        977   \n",
              "966        966   \n",
              "759        759   \n",
              "315        315   \n",
              "963        963   \n",
              "955        955   \n",
              "422        422   \n",
              "1085      1085   \n",
              "554        554   \n",
              "1247      1247   \n",
              "1076      1076   \n",
              "912        912   \n",
              "348        348   \n",
              "877        877   \n",
              "325        325   \n",
              "647        647   \n",
              "\n",
              "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ref_post  \\\n",
              "408                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           suppose you are on a data science team and are given a dataset and problem statement after preliminary steps you know you need to train for example a classifier what does this process look like if you are trying to follow a principled data science workflow and organize yourself according to something like cookiecutter data science the goal is to have a reproducible workflow that is transparent so that anyone on your team could see how you arrived at your results and do it themselves this process naturally involves a lot of experimentation with pipeline steps and model selection as well as hyperparameter tuning one approach i could think of would be to do all of the experimentation with interleaved commentsdiscussion in a notebook say experimentsipynb and then once i pin down the best pipeline configuration for my problem reproduce the entire pipeline in a script modelpy which trains a model from the raw data and saves it are there better ways to do this it is hard to find examples of professionallevel implementations of tools like sklearn amidst the masses of beginnerlevel tutorials out there links to example projects would be appreciated   \n",
              "711                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i would like to request a datasite that ranks the best films of all time using the average of the films performances with academy awards box office and critic amp audience rating flickmetrixcom has a similar system but it only ranks the data using aggregate critic and audience scores thats why i believe adding in the other data will give us a more accurate idea of what the best movies are in the method im suggesting i was able to figure out gone with the wind is likely the best movie of all time its in weighted box office sales won oscars including of the main categories and has an on flickmatrix which has already compiled the other scores for me im just unable to create a system or dataset like flickmatrix that uses my system and i had to manually figure out the data for box office and academy awards and add it to flickmatrix data   \n",
              "1114                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i have been considering a midcareer switch from a nontechnical field to a more quantitative one i have some math and cs backgroundhopefully enough to get into a ms in data science program but probably not enough to get into a quantitative phd program an ideal path for me would be to do an ms in data science work for a few years in the field and evaluate whether i should do a phd eg in stats or computer science so that i can advance further in a subdiscipline like machine learning my question is assuming my background in math think singlevariable calc and linear algebra and cs think introlevel college is not enough for a phd program now will the ms in data science put me in a position to be a phd candidate in the future or do data science masters programs teach mostly professional skills and so would not be a good preparation for phd studies thank you   \n",
              "699                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hi everyone i am a practicing attorney considering making the leap to data science my ultimate goal would be to work in financial servicesfinancial industrylegal analytics as that is where my experience is and i feel very comfortable in the corporatebankingfinancial world i have a few questions i was hoping some of you may be able to help me with has anyone else made the leap to data science from a nontechnical career if so how was the experience and are you glad you did it i would be especially interested in hearing experiences from former lawyers or current lawyers who have folded data science into their work what math would you recommend that i learn to prepare for a masters in data science my last math class was over years ago and i think it is fair to say that i am probably at the calc i level on a good day someone recommended that i learn python does anyone have any good recommendations books online class etc for selfteaching specific recommendations would be highly appreciated what are the job prospects for an older studententrylevel job seeker assume earlymid s when finishing the degree i am not worried about the school side so much since i have always been a good student passed two bar exams etc but am concerned that employers may view me as damaged goods because of a previous career thank you so much for your time   \n",
              "236                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hey everyone i want to become a data analyst and then down the road transition into a data science career i have an applied economics bachelor is and a supply chain management master is i have learned r and python during school and also javascript on my own i have javascript frontend apps projects is my bachelor is and master is combination a good combination for this path field i started learning sql power bi tableau python on my own at freecodecamp is there a roadmap or anything for becoming a data analyst also my previous javascript knowledge and projects would help me in any way getting my first data analyst job a last question a company reached out to me with a supply chain analyst job should i accept it or just focus on the general data analyst path sorry if i am asking stupid questions   \n",
              "119                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    so i am working on a modelling problem and trying different techniques to build a model my target variable is not following a normal distribution it is more of a uniform distribution with higher frequency bars gradually increasing towards right irrespective of the modelling techniquei have tried various linear models and their families tree based regressors and ensemble models like xgboost or iterations of the same with transformed variables i notice that the distribution of my predicted variable is always normally distributed why is this happening the distribution of the actual and the predicted variables should be similar in order to effectively call that the model gives out decent results please let me know if anyone has answers as to why would this happen and what are the work arounds google was of not much help   \n",
              "262                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       hey everyone i am one of the creators of sieve and i am looking for general thoughts on this problem part of what we are trying to do is build easy ways for software engineers and data scientists to interact with rich data imagine making queries and aggregations on videos in the same way you might with numbers and text right now the way we are thinking about it is to turn videos into something that works with the structure of a database like mongodb everything in an image or a video is an object even the frame itself is an object with a large bounding box and each of these objects has some attributes and can be tracked over time with some form of object tracking given that the objects are tracked they can each basically be returned as a timeseries of each of the attributes associated with that object a separate part of our api is a system that automatically allows one to define entities like people dog car cell dirty kitchen or any other object by making api calls in which they are basically providing labeling data that automatically trains a fewshot classifier on these objects our longterm goal is to build a general index over visual data and we think building a great query language great ways to define entities within the query language are important this can be the simple abstraction such that anyone can process and understand visual data such that they do not even need to know computer vision or deep learning for that matter ampxb find all intervals where a person is walking slow get all parts of the video where motorcycles are entering the intersection with speed greater than find all intervals of video with a clean kitchen   \n",
              "107                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i am studying for my final exam in business analytics at university of ottawa i am confused about the question below what confuses me the most is the following x x x lt y or x x x lt y x x x lt y or x x x lt y why do we set y y to could i have gotten the marks correctly had i chosen another large number say also what is the purpose to setting a large number to y in integer binary programming what does it actually do i am overall pretty confused with the steps in this question and how we got to the solution and why we set the variables in the way we have set them for example x x x lt y or x x x lt y also these constraints confuse me why do we set the variables to fractions x x less than equal to p x x less than equal to p x x less than equal to p your help is greatly appreciated the research and development department of dwr ltd has developed new game consoles zbox and ybox production of these consoles requires setting up computerized and fully automated production lines that would cost for zbox and for ybox once the initial costs are covered each console generates hefty profits unit for zbox and unit for ybox in its current production facilities in kanata dwr ltd has space for creating three production lines capable of manufacturing the consoles and each line can be used to manufacture both consoles if necessary at the same time however management has decided that in order to mitigate the risks only one production line would be open console zbox can be produced at the rate of unitshr on line unitshr on line and unitshr on line the ybox can be produced at the rate of unitshr unitshr and unitshr respectively line has hours production capacity line has hours capacity and line has hours capacity write in the space below the algebraic formulation for the above mixed binary integer programming problem do not solve solution decision variables let xij the number of game console i produced at on production line j where i zbox ybox and j yi if game console i is produced where i zbox ybox yi if game console i is not produced pj if game console zbox and ybox are produced on production line j pj if game console zbox and ybox are not produced on production line j where j max x x x x x x y y subject to x x less than equal to p x x less than equal to p x x less than equal to p p p p x x x lt y or x x x lt y x x x lt y or x x x lt y xij gt and integer yi and pj or for all i and j   \n",
              "267                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         hey all i am hoping some of you can help me with a potentially sensitive question i am in the late stages of interviews at a firm for an analytics manager position i know it is not true data science but it is close it would involve a small number of direct reports it is a large fortune based in the se us i am not natively an american but i tend to pass for one i have noticed that all and i mean literally all of the folks i have met in my interviews up down and lateral in the analyticsdata teams are all eastern asian or indian i do not care about working with different cultures but it seemed a flag to me that there are no americans there should that concern me that working conditions are poor ie americans would leave under those conditions or is that typical in expanding analyticsdata science teams at this point   \n",
              "268                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              drug discovery includes looking for biomedical connections between chemical compounds drugs chemicals and protein targets drugs interact with biological systems on a fundamental level by binding to protein targets and influencing their downstream action predicting drugtarget interactions dtis is crucial for identifying therapeutic targets or drug target characteristics understanding and forecasting higherlevel information such as side effects therapeutic mechanisms and even innovative insights for drug repositioning or repurposing can all be aided by dti knowledge sildenafil for example was originally created to treat pulmonary hypertension but after its adverse effects were discovered it was repurposed to treat erectile dysfunction polypharmacy has also become a viable method among pharmacists because most human diseases are complex biological processes that are resistant to the activity of anyone drug drugdrug interaction ddi prediction and validation can sometimes identify possible synergy in drug combinations allowing individual drugs to be more effective continue reading paper github   \n",
              "491   hi all i am looking for feedback on our soon to launch partner program for gravityai we are a marketplace for algorithms targeted at larger enterprise organizations and government we hope to help data scientists monetize their creations while simultaneously helping enterprise companies leverage cool stuff you can check out a short explainer here and click on the play button below is the partner program specifics i guess what i am looking for is does it make sense is the structure of the pay and incentive appropriate would anyone be interested in learning more or participating in our beta the partner launch program at gravity ai we understand how difficult it can be for data scientists with valuable ip to package and sell their technology to big companies we simplify this process by containerizing your algorithm then adding a security layer thats often required by enterprise it and finally making your algorithm available to enterprise through a simple web interface as we prepare for public launch we are inviting data scientists like you to work with us in a few ways the marketplace is ready to begin seeding algorithms and we are actively building a select group of first sellers who have algorithms they own and would like to sell we are also adding curators who can help us find and assess opensource algorithms to package for the enterprise lastly we are expanding our team with data scientists who are willing to work parttime first sellersgravity curatorparttime what is it opportunity for data scientists who have developed and own algorithms they want to sell to enterprise clients on our platform were searching for algorithms that might be valuable to our clients in finance insurance healthcare and travel if you know these industries and know where to find relevant algorithms become a curator we need help vetting algorithms working with our engineers to upload algorithms to our platform and potentially training algorithms how does it work send us your algorithm as a zip file along with a detailed description and documentation we will assess your program to ensure it functions as described and is relevant to our clients after review we will work with you to get the algorithm listed for purchase in our marketplace review our list of high priority algorithms search online data science communities message boards github and other places to find relevant algorithms send us the list of algorithms youve identified we will work with you to define a statement of work that aligns with your skillset and available time what is in it for me our team will review your algorithm and you will be compensated in the following ways if your algorithm is on our high priorities list of programs you will be compensated after review and acceptance if your algorithm is pretrained on a high value vertical financial data for example then you will be compensated an additional after review and acceptance once your algorithm is listed on our platform you will be paid a percentage of the monthly fee our clients pay to use your algorithm in perpetuity our team will review the algorithms you find and you will be compensated in the following ways if the algorithm is listed on our marketplace you will be compensated a onetime fee of if the algorithm listed on our marketplace is pretrained on a high valued vertical you will be compensated an additional onetime fee of you will be compensated hourly with an opportunity to interview for fulltime roles ifwhen they become available   \n",
              "108                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         my job reimburses up to kyr for anything that would advance my knowledge or help my career i have an ms so getting another one part time doesnt sound like it would be worth it so im trying to think of ideas individual courses that interest me in statsmath conferences well virtual this year books i guess a lot of them lol advanced boot camp for engineering or deep learning i am reasonable at both but would like to get to the next level maybe a primarily research based masters specifically in deep learning my goal is to just become a better ds and it seems like adding skills in eng or dl might be the most interesting to me interested in what ppl here would do or have done   \n",
              "661                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hi there ampxb i have recently started testing google optimize for ab testing and am very impressed with everything until i started running an experiment live ampxb i only have experiment setup and all it does is updates the hero image by replacing it with another i am trying to do a comparison of goal conversion using hero a vs hero b ampxb my issue is that when the site loads the image update is quite visible i have installed the anti flicker script which is recommended by google optimize additionally my gtm script has top priority within the document ltheadgt tag ampxb any recommendations on what the issue could be ampxb thank you   \n",
              "951                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i would like to take my career in a new direction with machine learning and am exploring the different pathways available one way is to go to school and get a masters degree the program i have been exploring is the masters of data science at berkeley the curriculum has what i want and with the distance learning i can be anywhere in the world and still get an education however the tuition for the program is there is also the masters program in machine learning at cmu and the machine learning masters program at university college london but these would require relocating since they are not available online the other path is to take classes online there are several available that i can take from places like dataquest linuxacademy sciencealert udemy etc i can pick and choose which ones i want and complete them at my own pace plus the total cost would be less than of the tuition at berkeley and since i am making a huge leap from being simply a troubleshooter to an ai architect i will need to show potential employers what i can do the plan is to post projects on github showing what i have worked on both in class and on my own i intend to do this regardless of which path i take i am hoping this can show the progression of my knowledge and be the bridge between what is listed on my cv and what i can do so now i am wonderingif the cost is not an issue which of these paths would work best in terms of impressing an employer will it be the degree or the drive that would pique someone is interest to hire me please let me know what you think   \n",
              "977                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  a question for the more experienced professional data scientists and engineers i recently got a data scienceish job and updated my linkedin profile to reflect this part of the update involved including some fancy words in my description like deep learning artificial intelligence data visualization etc not because they are buzzwords but because they actually reflect what i really do at work however because they are buzzwords almost overnight recruiters started sending me messages many of them also try to add me to their network as contacts rather than simply sending a oneoff message and disappearing into the night i just got this job and am not about to leave it however one day i will and i wonder if these recruiters will be a useful resource when that time comes so i am wondering if there is any benefit to actually accepting all these requests to connect even if i ignore their initial messages or do these recruiters actually offer very little in the long run such that adding them to my network would just be a waste of my energy edit i should clarify that while i would also like to hear about people is experiences responding to these unsolicited messages what i really want to know about is the value of actually adding these recruiters as contact to my network like if i do that what practical benefit will that bring to me   \n",
              "966                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                okay so i was dealing with a problem that a peer posed to me he gave me a dataset and an xgboost model which was trained on the same dataset the dataset contains features and label the dataset is about the marketing campaigns of an agency through channels and the label is the transactions processed by the agency now the question is given the dataset predict how much contribution each channel makes to increase the transactions and given a budget find the optimum budget allocation to different channels so that the number of transactions is maximized i have identified the most important channels and their order as well using correlation but my question is how do i quantify it i am not very fluent in data science i am mostly learning by myself a little help will be appreciated   \n",
              "759                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         so i have been looking into shorthand writing systems which are what reporters and stenographers use to transcribe conversations it is basically creating a reduced writing system and including use of symbols to write faster and it will generally require some expertise to decode experts in shorthand can apparently write over words per minute naturally from here i started thinking about what the digital equivalent to shorthand would be and i have thought of some random ideas that may have a place in a similar system text expansion if you went crazy with this then there would likely be a huge learning curve using a typed shorthand system like keyscript then decode it with some ml system although i would imagine that this would have a lot of challenges predictive text   \n",
              "315                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   greetings i would like to ask for advice from this community i am entering the world of ai and while i am not completely new to probability programming or automation i have a lot to work on luckily there is alot of online content to help with studying but time is limited so i have to focus my efforts obviously i should learn ml algorithms and libraries for python only right now but i believe there is more to it than that what i would like to ask i do not come from a cs background the most i have done is programming some microcontrollersvectorial calculations with matlab is it beneficial to invest time in some software engineering course to make it easier to develop scripts or is it overkill as a ml engineer it would be a significant time investment is it possible to start a career in ml without data manipulation tools something like sql spark i intend to get to them when feasible after starting to work but is it a necessary precondition for the job i have not been able to find a conclusive answer by just looking at job ads or kaggle is python used in the industry or are other languages preferred i only really know c but i am not even going to try with it i want to thank everyone who takes the time to read this and even more those who answer   \n",
              "963                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i am currently reading a paper on the mathematics lying behind of the ann how they inspired from biological neurons how they work etc ampxb the paper says that when the synapses the input weight from a neuron to the another neuron and thresholds the minimum required input value which is necessary for the neuron to fire is getting determined namely ann gets trained also the initial binary values firing or not firing true or false of these neurons gets determined so that when the weighted input not exceeds the threshold of the neuron but exceptionally equal to it we can use this initial value as our most optimal output ampxb but then how is it getting calculated understanding the calculation of the synapses and threshold is very intuitive but this make me confused ampxb the article i am reading a begginers guide to mathematics of neural networks ampxb   \n",
              "955                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     i am trying to create a segment in analytics of potential customers who have added a product to their cart i have enhanced ecommerce enabled but cannot get it to work this is what i tried under admingtviewgtpersonal tools amp assets i clicked segmentsgtnew segment from here i clicked enhanced ecommerce i clicked the top middle added to cart button then in the product field i typed in the name of my product i then named this segment test and saved it when trying to create an audience from this by clicking new audience i click import segment and select the test segment from above however when looking at the users over past days it shows whereas this number should be according to my observations i have tried this with several different products and even entire product brands with the same result this leads me to believe that my enhanced ecomerce tracking is not set up properly what could be the problem is there another way to segment add to cart clicks in a more manual way ie not using enhanced ecommerce thanks in advance   \n",
              "422                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hi everyone thanks for so many comments and signups on my previous post here is this weeks post we have selected two articles for this weeks post these articles are from shopify and yelp engineering blogs tips for shipping data products fast moderating promotional spam and inappropriate content in photos at scale at yelp we hope youll find it useful whether youre trying to excel at a job interview or just trying to open your mind to new ideas from different implementations what are your favorite engineering blogs for data science let us know in the comments and we will include it in the monitoring list if you like these articles and want to be informed about future posts please sign up for the newsletter   \n",
              "1085                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i started a new data analyst job a couple months ago i was under the impression based off the job description and interviews that i would get to use sql even my first week i was told they were going to get me sql access fast forward a couple weeks and they finally ask the it vp he says no and my management team has not really been pushing it because of the fight it requires so essentially i am stuck asking for reports from another coworker who does have access i was asked to create a report by a higherup and told them i was going to have to ask someone else because i did not have access they looked pretty disappointed i am no expert in sql yet i have used it a little bit in previous jobs learned it in my current program and have taken a couple classes i have been looking at senior data analyst roles to understand what i need to know for my future career path and a lot of it centers around work experience with sql would you quit your job if they refused to give you access to sql   \n",
              "554                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             i have been thinking about this for a while now but i cannot convince myself that my reasoning is right it is about propagation of uncertainty in labels i have a dataset with continuous labels that by themselves already have an error after training my model i get the model error for each prediction which i define as the absolute difference between expected and predicted value is this error correlated with the labels error in particular i suspect that i cannot achieve an error that is lower than the labels error so it is kind of a lower bound then this is the total error that includes also the labels uncertainty is my reasoning correct   \n",
              "1247                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          what are your favorite papers involving ml and temporal data or time series i came across some papers about the use of lstm networks to improve image and speech classification and am curious about other examples out there either within or outside of the cv space what researchworkpapers with ml and time series have excited you recentlythanks ampxb the papers im referring semisupervised spatiotemporal cnn for recognition of surgical workflow chen y sun ql amp zhong k j image video proc spatiotemporal pain recognition in cnnbased superresolved facial images bellantonio m haque m a rodriguez p nasrollahi k telve t guerrero s e anbarjafari g in international conference on pattern recognition icpr workshop on face and facial expression recognition capture learning and synthesis of d speaking styles daniel cudeiro timo bolkart cassidy laidlaw anurag ranjan michael j black may preprint to appear in cvpr  edited   \n",
              "1076                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hi all i am currently interning as a data scientist so far the work has involved very little machine learning or much of any work tbh are most data science jobs like this should i be looking at other industries that do more machine learning it does not even have to be deep learning albeit that is neat too but it would be nice if it could be something other than just oh we have literally any data set and we need to solve literally any problem i will only accept linear model do not worry about the choosing features we can do that later on one hand as an intern it is not my responsibility to select models or whatever i am also only getting paid quite crappily hourly with no overtime so it is not exactly in my best interest to spend all my time on this on the other hand if this is how data science i am really concerned how can i get involved with some more technical where would i even find those jobs what should i search for them or is this feeling just because i am an intern for reference i am a math phd decent coder and familiar with the usual machine learning things esl andrew ng is deep learning series slowly working through the deep learning booketc and diving deeper into the reinforcement learning literature following this and his sequel so it is not like i am some random lol i took one udemy class and now i know everything person   \n",
              "912                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 hello everyone i am taking a course on udacity about reinforcement learning in a video they say that since the following equation holds bk q_ bk q_ leq gammak q_q__infty it can be useful to run the value update more than once they apply k times the bellman operator to both qltsubgtltsubgt and qltsubgtltsubgt now i have a question do they mean that is useful to update multiple time the qvalue for each reward this kind of make sense to me because it could be that this makes something similar to what happens with a higher learning rate but being more stable i do not know whether it is true or not and i did not try to prove it is my reasoning correct   \n",
              "348                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hi ranalytics i am the maintainer of miceranger an r package which performs multiple imputation by chained equations mice with random forests i have developed a package miceforest which does the same thing in python github pypi i am a huge fan of documentation so i have included a very comprehensive readme on the github which explains the mice algorithm and the details of the package i have recently gotten the package into a pretty stable state complete with docs mypy checks ci testing etc so i thought i would share the news what is mice multiple imputation by chained equations mice is an iterative method that allows you to fill in missing data using all of the available information in the dataset over a series of iterations every column in the data set gets modeled by the other columns and the missing values are inferred by the model stef van buuren wrote the book on missing data which details the algorithm here random forests are a good chaining equation to use because they do not need much hyperparameter tuning easily handle nonlinear relationships in the data can return oob performance inexpensively are trivially parallelizable can return feature importance for diagnostics what is it used for i do a lot of funnel modeling at my current position and mice has proven invaluable it allows us to eliminate bias in the funnel caused by missing data being less missing the further up the funnel you go which allows us to use all available information no matter the funnel stage create confidence intervals on our predictions more data filled out less imputed variance a more confident prediction this allows us to create more robust confidence intervals for our forecasts motivation i originally developed this package for r because all of the available packages were lacking in either speed or features as i start using python more i noticed that the available mice implementations do not provide the functionality i find myself using most often custom imputation schemas built in diagnostic plotting imputing new data   \n",
              "877                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         hi all i am a new student of neural networks and am looking for some pointers in terms of learning resources and technical direction for a new project that i am starting i am looking to build a solution to optimize route planning i have a relational database of destinations each with an address based on these addresses or nodes the goal is to create a solution perhaps involving a neural network that is able to create optimized routes based on the number of available trucks and their capacity my background consists of years of software development experience save for reading about neural nets i have not yet built anything as this is my first foray into the field i am very excited to begin learning and building but i am have a lot of questions i have not yet found a community or forum where i can ask these questions so any pointers would be greatly appreciated thanks everyone   \n",
              "325                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hi trying to do a little project of predicting the time of the sunrise given a month and a day my process thusfar has been scrape years of sunrise data feature engineer the data so i have month day and sunrise time which i have converted to seconds from midnight split the data for traintest in chronological order important for time series analysis used xgboost algorithm trained model tested model i am getting about accuracy and am not really sure how to iterate in order to try to get better results should i try another algorithm do i need more features my margin of error is pretty small and when my model is incorrect it is not off by much i feel stuck but want to improve the model as it is something which should be extremely predictable any advice is much appreciated   \n",
              "647                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         hello i am a computer engineer and for one of my projects is ai detection for crime scene evidence analysis and for me to do that i need a photo or video datasets of crime scenes i tried searching everywhere i cannot find any database of crime scene photos does anybody know of anywhere i can find some photos or it forensic competitions that have such datasets i need it urgently please help a professor suggested using kaggle however i could not find anything plus i am not sure how i can use it the dataset does not even have to be real i just need anything to start working on my project thanks   \n",
              "\n",
              "                                                                                                                      ref_title  \\\n",
              "408                                                                             what does a good scikitlearn workflow look like   \n",
              "711                                                                              dataset request ranking best films of all time   \n",
              "1114                                                                                          ds masters subsequent phd studies   \n",
              "699                                                                                               career change to data science   \n",
              "236                                                                                                          how should i start   \n",
              "119                                                   google did not help solve my doubts regarding a modelling problem can you   \n",
              "262                                                          building an api query language for rich data like images and video   \n",
              "107                                                                                          university business analytics help   \n",
              "267                                                                                        joining firm company culture concern   \n",
              "268   researchers from nankai and stanford propose deepdrug a python based deep learning framework for drug relation prediction   \n",
              "491                                                                                              data scientist partner program   \n",
              "108                                                                 if your job reimbursed education expenses what would you do   \n",
              "661                                                                          issues with google optimize visible content update   \n",
              "951                                                                                         is a pricey masters degree worth it   \n",
              "977                                              are recruiters useful specifically the ones that send you unsolicited messages   \n",
              "966                                                      finding the proper method to maximize the predictions of a given class   \n",
              "759                                                    discussion nlp what programmatic ways are there to increase typing speed   \n",
              "315                                                                                            seeking advice for learning path   \n",
              "963                        how the initial default binaryvalues of the neurons in the ann gets determined when we training them   \n",
              "955                                                                                  cannot create segment to track add to cart   \n",
              "422                                                                                               data science in practice post   \n",
              "1085                                                                 would you quit your job if you were not allowed to use sql   \n",
              "554                                                                                     error lower bound and label uncertainty   \n",
              "1247                                                          what are some mp and temporal data or time series papers you like   \n",
              "1076                                                                                                machine learning heavy jobs   \n",
              "912                                                         does updating value in qlearning more than once per step make sense   \n",
              "348                                                                 new library multiple imputation by random forests in python   \n",
              "877                                                                    looking for direction for a new route automation project   \n",
              "325                                                                                                      predicting the sunrise   \n",
              "647                                                                                 crime scene datasetphoto and video database   \n",
              "\n",
              "                                                                                                       candidate_title  \n",
              "408                                                        what is the best way to organize your data science workflow  \n",
              "711                                             looking for a dataset of the best movies of all time using flickmatrix  \n",
              "1114                                                                                      ms in data science vs python  \n",
              "699                                                               what are the job prospects for a phd in data science  \n",
              "236                                                                                     how do i become a data analyst  \n",
              "119           why is the distribution of the predicted variables so different from the one that i have been working on  \n",
              "262                                                                                   how do you approach this problem  \n",
              "107                                                               how do i set up a value function for my game console  \n",
              "267                                  what are some of the things i can do to stay competitive in analyticsdata science  \n",
              "268                                                                                             dti for drug discovery  \n",
              "491                                                                   looking for feedback on our data science program  \n",
              "108                                                                        what is the best way to learn deep learning  \n",
              "661                                                                                                       gtm vs keras  \n",
              "951                                                                  what is the best way to get a job in data science  \n",
              "977                                                                      what is the benefit of a data science network  \n",
              "966                                                   how do i measure the difference between a channel and an xgboost  \n",
              "759                                                                            what is a good shorthand writing system  \n",
              "315                                                         is it possible to get a job in ml with python from scratch  \n",
              "963                                                   what is the proper way of calculating a neural network is output  \n",
              "955                                   i am trying to create a segment in my ecommerce app but unable to get it to work  \n",
              "422                                                                            best engineering blogs for data science  \n",
              "1085  i am a new data analyst and ive been told to use sql for my current job but if you have access to it what is the  \n",
              "554                                                             how do i train a model error when the loss is too high  \n",
              "1247                                                      what are your favorite papers on lstm for speech recognition  \n",
              "1076                                                               what is the best way to get into a data science job  \n",
              "912                                                                              question about qvalue update in keras  \n",
              "348                                                                                        pytorch vs tensorflow keras  \n",
              "877                                   looking for recommendations for a neural network architecture for route planning  \n",
              "325                                                                            predicting the time series with xgboost  \n",
              "647                                                                         looking for datasets of crime scene images  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-ba4ab046-2860-4e36-80aa-5729f6318172\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Index_ID</th>\n",
              "      <th>ref_post</th>\n",
              "      <th>ref_title</th>\n",
              "      <th>candidate_title</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>408</th>\n",
              "      <td>408</td>\n",
              "      <td>suppose you are on a data science team and are given a dataset and problem statement after preliminary steps you know you need to train for example a classifier what does this process look like if you are trying to follow a principled data science workflow and organize yourself according to something like cookiecutter data science the goal is to have a reproducible workflow that is transparent so that anyone on your team could see how you arrived at your results and do it themselves this process naturally involves a lot of experimentation with pipeline steps and model selection as well as hyperparameter tuning one approach i could think of would be to do all of the experimentation with interleaved commentsdiscussion in a notebook say experimentsipynb and then once i pin down the best pipeline configuration for my problem reproduce the entire pipeline in a script modelpy which trains a model from the raw data and saves it are there better ways to do this it is hard to find examples of professionallevel implementations of tools like sklearn amidst the masses of beginnerlevel tutorials out there links to example projects would be appreciated</td>\n",
              "      <td>what does a good scikitlearn workflow look like</td>\n",
              "      <td>what is the best way to organize your data science workflow</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>711</th>\n",
              "      <td>711</td>\n",
              "      <td>i would like to request a datasite that ranks the best films of all time using the average of the films performances with academy awards box office and critic amp audience rating flickmetrixcom has a similar system but it only ranks the data using aggregate critic and audience scores thats why i believe adding in the other data will give us a more accurate idea of what the best movies are in the method im suggesting i was able to figure out gone with the wind is likely the best movie of all time its in weighted box office sales won oscars including of the main categories and has an on flickmatrix which has already compiled the other scores for me im just unable to create a system or dataset like flickmatrix that uses my system and i had to manually figure out the data for box office and academy awards and add it to flickmatrix data</td>\n",
              "      <td>dataset request ranking best films of all time</td>\n",
              "      <td>looking for a dataset of the best movies of all time using flickmatrix</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1114</th>\n",
              "      <td>1114</td>\n",
              "      <td>i have been considering a midcareer switch from a nontechnical field to a more quantitative one i have some math and cs backgroundhopefully enough to get into a ms in data science program but probably not enough to get into a quantitative phd program an ideal path for me would be to do an ms in data science work for a few years in the field and evaluate whether i should do a phd eg in stats or computer science so that i can advance further in a subdiscipline like machine learning my question is assuming my background in math think singlevariable calc and linear algebra and cs think introlevel college is not enough for a phd program now will the ms in data science put me in a position to be a phd candidate in the future or do data science masters programs teach mostly professional skills and so would not be a good preparation for phd studies thank you</td>\n",
              "      <td>ds masters subsequent phd studies</td>\n",
              "      <td>ms in data science vs python</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>699</th>\n",
              "      <td>699</td>\n",
              "      <td>hi everyone i am a practicing attorney considering making the leap to data science my ultimate goal would be to work in financial servicesfinancial industrylegal analytics as that is where my experience is and i feel very comfortable in the corporatebankingfinancial world i have a few questions i was hoping some of you may be able to help me with has anyone else made the leap to data science from a nontechnical career if so how was the experience and are you glad you did it i would be especially interested in hearing experiences from former lawyers or current lawyers who have folded data science into their work what math would you recommend that i learn to prepare for a masters in data science my last math class was over years ago and i think it is fair to say that i am probably at the calc i level on a good day someone recommended that i learn python does anyone have any good recommendations books online class etc for selfteaching specific recommendations would be highly appreciated what are the job prospects for an older studententrylevel job seeker assume earlymid s when finishing the degree i am not worried about the school side so much since i have always been a good student passed two bar exams etc but am concerned that employers may view me as damaged goods because of a previous career thank you so much for your time</td>\n",
              "      <td>career change to data science</td>\n",
              "      <td>what are the job prospects for a phd in data science</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>236</th>\n",
              "      <td>236</td>\n",
              "      <td>hey everyone i want to become a data analyst and then down the road transition into a data science career i have an applied economics bachelor is and a supply chain management master is i have learned r and python during school and also javascript on my own i have javascript frontend apps projects is my bachelor is and master is combination a good combination for this path field i started learning sql power bi tableau python on my own at freecodecamp is there a roadmap or anything for becoming a data analyst also my previous javascript knowledge and projects would help me in any way getting my first data analyst job a last question a company reached out to me with a supply chain analyst job should i accept it or just focus on the general data analyst path sorry if i am asking stupid questions</td>\n",
              "      <td>how should i start</td>\n",
              "      <td>how do i become a data analyst</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>119</th>\n",
              "      <td>119</td>\n",
              "      <td>so i am working on a modelling problem and trying different techniques to build a model my target variable is not following a normal distribution it is more of a uniform distribution with higher frequency bars gradually increasing towards right irrespective of the modelling techniquei have tried various linear models and their families tree based regressors and ensemble models like xgboost or iterations of the same with transformed variables i notice that the distribution of my predicted variable is always normally distributed why is this happening the distribution of the actual and the predicted variables should be similar in order to effectively call that the model gives out decent results please let me know if anyone has answers as to why would this happen and what are the work arounds google was of not much help</td>\n",
              "      <td>google did not help solve my doubts regarding a modelling problem can you</td>\n",
              "      <td>why is the distribution of the predicted variables so different from the one that i have been working on</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>262</th>\n",
              "      <td>262</td>\n",
              "      <td>hey everyone i am one of the creators of sieve and i am looking for general thoughts on this problem part of what we are trying to do is build easy ways for software engineers and data scientists to interact with rich data imagine making queries and aggregations on videos in the same way you might with numbers and text right now the way we are thinking about it is to turn videos into something that works with the structure of a database like mongodb everything in an image or a video is an object even the frame itself is an object with a large bounding box and each of these objects has some attributes and can be tracked over time with some form of object tracking given that the objects are tracked they can each basically be returned as a timeseries of each of the attributes associated with that object a separate part of our api is a system that automatically allows one to define entities like people dog car cell dirty kitchen or any other object by making api calls in which they are basically providing labeling data that automatically trains a fewshot classifier on these objects our longterm goal is to build a general index over visual data and we think building a great query language great ways to define entities within the query language are important this can be the simple abstraction such that anyone can process and understand visual data such that they do not even need to know computer vision or deep learning for that matter ampxb find all intervals where a person is walking slow get all parts of the video where motorcycles are entering the intersection with speed greater than find all intervals of video with a clean kitchen</td>\n",
              "      <td>building an api query language for rich data like images and video</td>\n",
              "      <td>how do you approach this problem</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>107</th>\n",
              "      <td>107</td>\n",
              "      <td>i am studying for my final exam in business analytics at university of ottawa i am confused about the question below what confuses me the most is the following x x x lt y or x x x lt y x x x lt y or x x x lt y why do we set y y to could i have gotten the marks correctly had i chosen another large number say also what is the purpose to setting a large number to y in integer binary programming what does it actually do i am overall pretty confused with the steps in this question and how we got to the solution and why we set the variables in the way we have set them for example x x x lt y or x x x lt y also these constraints confuse me why do we set the variables to fractions x x less than equal to p x x less than equal to p x x less than equal to p your help is greatly appreciated the research and development department of dwr ltd has developed new game consoles zbox and ybox production of these consoles requires setting up computerized and fully automated production lines that would cost for zbox and for ybox once the initial costs are covered each console generates hefty profits unit for zbox and unit for ybox in its current production facilities in kanata dwr ltd has space for creating three production lines capable of manufacturing the consoles and each line can be used to manufacture both consoles if necessary at the same time however management has decided that in order to mitigate the risks only one production line would be open console zbox can be produced at the rate of unitshr on line unitshr on line and unitshr on line the ybox can be produced at the rate of unitshr unitshr and unitshr respectively line has hours production capacity line has hours capacity and line has hours capacity write in the space below the algebraic formulation for the above mixed binary integer programming problem do not solve solution decision variables let xij the number of game console i produced at on production line j where i zbox ybox and j yi if game console i is produced where i zbox ybox yi if game console i is not produced pj if game console zbox and ybox are produced on production line j pj if game console zbox and ybox are not produced on production line j where j max x x x x x x y y subject to x x less than equal to p x x less than equal to p x x less than equal to p p p p x x x lt y or x x x lt y x x x lt y or x x x lt y xij gt and integer yi and pj or for all i and j</td>\n",
              "      <td>university business analytics help</td>\n",
              "      <td>how do i set up a value function for my game console</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>267</th>\n",
              "      <td>267</td>\n",
              "      <td>hey all i am hoping some of you can help me with a potentially sensitive question i am in the late stages of interviews at a firm for an analytics manager position i know it is not true data science but it is close it would involve a small number of direct reports it is a large fortune based in the se us i am not natively an american but i tend to pass for one i have noticed that all and i mean literally all of the folks i have met in my interviews up down and lateral in the analyticsdata teams are all eastern asian or indian i do not care about working with different cultures but it seemed a flag to me that there are no americans there should that concern me that working conditions are poor ie americans would leave under those conditions or is that typical in expanding analyticsdata science teams at this point</td>\n",
              "      <td>joining firm company culture concern</td>\n",
              "      <td>what are some of the things i can do to stay competitive in analyticsdata science</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>268</th>\n",
              "      <td>268</td>\n",
              "      <td>drug discovery includes looking for biomedical connections between chemical compounds drugs chemicals and protein targets drugs interact with biological systems on a fundamental level by binding to protein targets and influencing their downstream action predicting drugtarget interactions dtis is crucial for identifying therapeutic targets or drug target characteristics understanding and forecasting higherlevel information such as side effects therapeutic mechanisms and even innovative insights for drug repositioning or repurposing can all be aided by dti knowledge sildenafil for example was originally created to treat pulmonary hypertension but after its adverse effects were discovered it was repurposed to treat erectile dysfunction polypharmacy has also become a viable method among pharmacists because most human diseases are complex biological processes that are resistant to the activity of anyone drug drugdrug interaction ddi prediction and validation can sometimes identify possible synergy in drug combinations allowing individual drugs to be more effective continue reading paper github</td>\n",
              "      <td>researchers from nankai and stanford propose deepdrug a python based deep learning framework for drug relation prediction</td>\n",
              "      <td>dti for drug discovery</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>491</th>\n",
              "      <td>491</td>\n",
              "      <td>hi all i am looking for feedback on our soon to launch partner program for gravityai we are a marketplace for algorithms targeted at larger enterprise organizations and government we hope to help data scientists monetize their creations while simultaneously helping enterprise companies leverage cool stuff you can check out a short explainer here and click on the play button below is the partner program specifics i guess what i am looking for is does it make sense is the structure of the pay and incentive appropriate would anyone be interested in learning more or participating in our beta the partner launch program at gravity ai we understand how difficult it can be for data scientists with valuable ip to package and sell their technology to big companies we simplify this process by containerizing your algorithm then adding a security layer thats often required by enterprise it and finally making your algorithm available to enterprise through a simple web interface as we prepare for public launch we are inviting data scientists like you to work with us in a few ways the marketplace is ready to begin seeding algorithms and we are actively building a select group of first sellers who have algorithms they own and would like to sell we are also adding curators who can help us find and assess opensource algorithms to package for the enterprise lastly we are expanding our team with data scientists who are willing to work parttime first sellersgravity curatorparttime what is it opportunity for data scientists who have developed and own algorithms they want to sell to enterprise clients on our platform were searching for algorithms that might be valuable to our clients in finance insurance healthcare and travel if you know these industries and know where to find relevant algorithms become a curator we need help vetting algorithms working with our engineers to upload algorithms to our platform and potentially training algorithms how does it work send us your algorithm as a zip file along with a detailed description and documentation we will assess your program to ensure it functions as described and is relevant to our clients after review we will work with you to get the algorithm listed for purchase in our marketplace review our list of high priority algorithms search online data science communities message boards github and other places to find relevant algorithms send us the list of algorithms youve identified we will work with you to define a statement of work that aligns with your skillset and available time what is in it for me our team will review your algorithm and you will be compensated in the following ways if your algorithm is on our high priorities list of programs you will be compensated after review and acceptance if your algorithm is pretrained on a high value vertical financial data for example then you will be compensated an additional after review and acceptance once your algorithm is listed on our platform you will be paid a percentage of the monthly fee our clients pay to use your algorithm in perpetuity our team will review the algorithms you find and you will be compensated in the following ways if the algorithm is listed on our marketplace you will be compensated a onetime fee of if the algorithm listed on our marketplace is pretrained on a high valued vertical you will be compensated an additional onetime fee of you will be compensated hourly with an opportunity to interview for fulltime roles ifwhen they become available</td>\n",
              "      <td>data scientist partner program</td>\n",
              "      <td>looking for feedback on our data science program</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>108</th>\n",
              "      <td>108</td>\n",
              "      <td>my job reimburses up to kyr for anything that would advance my knowledge or help my career i have an ms so getting another one part time doesnt sound like it would be worth it so im trying to think of ideas individual courses that interest me in statsmath conferences well virtual this year books i guess a lot of them lol advanced boot camp for engineering or deep learning i am reasonable at both but would like to get to the next level maybe a primarily research based masters specifically in deep learning my goal is to just become a better ds and it seems like adding skills in eng or dl might be the most interesting to me interested in what ppl here would do or have done</td>\n",
              "      <td>if your job reimbursed education expenses what would you do</td>\n",
              "      <td>what is the best way to learn deep learning</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>661</th>\n",
              "      <td>661</td>\n",
              "      <td>hi there ampxb i have recently started testing google optimize for ab testing and am very impressed with everything until i started running an experiment live ampxb i only have experiment setup and all it does is updates the hero image by replacing it with another i am trying to do a comparison of goal conversion using hero a vs hero b ampxb my issue is that when the site loads the image update is quite visible i have installed the anti flicker script which is recommended by google optimize additionally my gtm script has top priority within the document ltheadgt tag ampxb any recommendations on what the issue could be ampxb thank you</td>\n",
              "      <td>issues with google optimize visible content update</td>\n",
              "      <td>gtm vs keras</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>951</th>\n",
              "      <td>951</td>\n",
              "      <td>i would like to take my career in a new direction with machine learning and am exploring the different pathways available one way is to go to school and get a masters degree the program i have been exploring is the masters of data science at berkeley the curriculum has what i want and with the distance learning i can be anywhere in the world and still get an education however the tuition for the program is there is also the masters program in machine learning at cmu and the machine learning masters program at university college london but these would require relocating since they are not available online the other path is to take classes online there are several available that i can take from places like dataquest linuxacademy sciencealert udemy etc i can pick and choose which ones i want and complete them at my own pace plus the total cost would be less than of the tuition at berkeley and since i am making a huge leap from being simply a troubleshooter to an ai architect i will need to show potential employers what i can do the plan is to post projects on github showing what i have worked on both in class and on my own i intend to do this regardless of which path i take i am hoping this can show the progression of my knowledge and be the bridge between what is listed on my cv and what i can do so now i am wonderingif the cost is not an issue which of these paths would work best in terms of impressing an employer will it be the degree or the drive that would pique someone is interest to hire me please let me know what you think</td>\n",
              "      <td>is a pricey masters degree worth it</td>\n",
              "      <td>what is the best way to get a job in data science</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>977</th>\n",
              "      <td>977</td>\n",
              "      <td>a question for the more experienced professional data scientists and engineers i recently got a data scienceish job and updated my linkedin profile to reflect this part of the update involved including some fancy words in my description like deep learning artificial intelligence data visualization etc not because they are buzzwords but because they actually reflect what i really do at work however because they are buzzwords almost overnight recruiters started sending me messages many of them also try to add me to their network as contacts rather than simply sending a oneoff message and disappearing into the night i just got this job and am not about to leave it however one day i will and i wonder if these recruiters will be a useful resource when that time comes so i am wondering if there is any benefit to actually accepting all these requests to connect even if i ignore their initial messages or do these recruiters actually offer very little in the long run such that adding them to my network would just be a waste of my energy edit i should clarify that while i would also like to hear about people is experiences responding to these unsolicited messages what i really want to know about is the value of actually adding these recruiters as contact to my network like if i do that what practical benefit will that bring to me</td>\n",
              "      <td>are recruiters useful specifically the ones that send you unsolicited messages</td>\n",
              "      <td>what is the benefit of a data science network</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>966</th>\n",
              "      <td>966</td>\n",
              "      <td>okay so i was dealing with a problem that a peer posed to me he gave me a dataset and an xgboost model which was trained on the same dataset the dataset contains features and label the dataset is about the marketing campaigns of an agency through channels and the label is the transactions processed by the agency now the question is given the dataset predict how much contribution each channel makes to increase the transactions and given a budget find the optimum budget allocation to different channels so that the number of transactions is maximized i have identified the most important channels and their order as well using correlation but my question is how do i quantify it i am not very fluent in data science i am mostly learning by myself a little help will be appreciated</td>\n",
              "      <td>finding the proper method to maximize the predictions of a given class</td>\n",
              "      <td>how do i measure the difference between a channel and an xgboost</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>759</th>\n",
              "      <td>759</td>\n",
              "      <td>so i have been looking into shorthand writing systems which are what reporters and stenographers use to transcribe conversations it is basically creating a reduced writing system and including use of symbols to write faster and it will generally require some expertise to decode experts in shorthand can apparently write over words per minute naturally from here i started thinking about what the digital equivalent to shorthand would be and i have thought of some random ideas that may have a place in a similar system text expansion if you went crazy with this then there would likely be a huge learning curve using a typed shorthand system like keyscript then decode it with some ml system although i would imagine that this would have a lot of challenges predictive text</td>\n",
              "      <td>discussion nlp what programmatic ways are there to increase typing speed</td>\n",
              "      <td>what is a good shorthand writing system</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>315</th>\n",
              "      <td>315</td>\n",
              "      <td>greetings i would like to ask for advice from this community i am entering the world of ai and while i am not completely new to probability programming or automation i have a lot to work on luckily there is alot of online content to help with studying but time is limited so i have to focus my efforts obviously i should learn ml algorithms and libraries for python only right now but i believe there is more to it than that what i would like to ask i do not come from a cs background the most i have done is programming some microcontrollersvectorial calculations with matlab is it beneficial to invest time in some software engineering course to make it easier to develop scripts or is it overkill as a ml engineer it would be a significant time investment is it possible to start a career in ml without data manipulation tools something like sql spark i intend to get to them when feasible after starting to work but is it a necessary precondition for the job i have not been able to find a conclusive answer by just looking at job ads or kaggle is python used in the industry or are other languages preferred i only really know c but i am not even going to try with it i want to thank everyone who takes the time to read this and even more those who answer</td>\n",
              "      <td>seeking advice for learning path</td>\n",
              "      <td>is it possible to get a job in ml with python from scratch</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>963</th>\n",
              "      <td>963</td>\n",
              "      <td>i am currently reading a paper on the mathematics lying behind of the ann how they inspired from biological neurons how they work etc ampxb the paper says that when the synapses the input weight from a neuron to the another neuron and thresholds the minimum required input value which is necessary for the neuron to fire is getting determined namely ann gets trained also the initial binary values firing or not firing true or false of these neurons gets determined so that when the weighted input not exceeds the threshold of the neuron but exceptionally equal to it we can use this initial value as our most optimal output ampxb but then how is it getting calculated understanding the calculation of the synapses and threshold is very intuitive but this make me confused ampxb the article i am reading a begginers guide to mathematics of neural networks ampxb</td>\n",
              "      <td>how the initial default binaryvalues of the neurons in the ann gets determined when we training them</td>\n",
              "      <td>what is the proper way of calculating a neural network is output</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>955</th>\n",
              "      <td>955</td>\n",
              "      <td>i am trying to create a segment in analytics of potential customers who have added a product to their cart i have enhanced ecommerce enabled but cannot get it to work this is what i tried under admingtviewgtpersonal tools amp assets i clicked segmentsgtnew segment from here i clicked enhanced ecommerce i clicked the top middle added to cart button then in the product field i typed in the name of my product i then named this segment test and saved it when trying to create an audience from this by clicking new audience i click import segment and select the test segment from above however when looking at the users over past days it shows whereas this number should be according to my observations i have tried this with several different products and even entire product brands with the same result this leads me to believe that my enhanced ecomerce tracking is not set up properly what could be the problem is there another way to segment add to cart clicks in a more manual way ie not using enhanced ecommerce thanks in advance</td>\n",
              "      <td>cannot create segment to track add to cart</td>\n",
              "      <td>i am trying to create a segment in my ecommerce app but unable to get it to work</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>422</th>\n",
              "      <td>422</td>\n",
              "      <td>hi everyone thanks for so many comments and signups on my previous post here is this weeks post we have selected two articles for this weeks post these articles are from shopify and yelp engineering blogs tips for shipping data products fast moderating promotional spam and inappropriate content in photos at scale at yelp we hope youll find it useful whether youre trying to excel at a job interview or just trying to open your mind to new ideas from different implementations what are your favorite engineering blogs for data science let us know in the comments and we will include it in the monitoring list if you like these articles and want to be informed about future posts please sign up for the newsletter</td>\n",
              "      <td>data science in practice post</td>\n",
              "      <td>best engineering blogs for data science</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1085</th>\n",
              "      <td>1085</td>\n",
              "      <td>i started a new data analyst job a couple months ago i was under the impression based off the job description and interviews that i would get to use sql even my first week i was told they were going to get me sql access fast forward a couple weeks and they finally ask the it vp he says no and my management team has not really been pushing it because of the fight it requires so essentially i am stuck asking for reports from another coworker who does have access i was asked to create a report by a higherup and told them i was going to have to ask someone else because i did not have access they looked pretty disappointed i am no expert in sql yet i have used it a little bit in previous jobs learned it in my current program and have taken a couple classes i have been looking at senior data analyst roles to understand what i need to know for my future career path and a lot of it centers around work experience with sql would you quit your job if they refused to give you access to sql</td>\n",
              "      <td>would you quit your job if you were not allowed to use sql</td>\n",
              "      <td>i am a new data analyst and ive been told to use sql for my current job but if you have access to it what is the</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>554</th>\n",
              "      <td>554</td>\n",
              "      <td>i have been thinking about this for a while now but i cannot convince myself that my reasoning is right it is about propagation of uncertainty in labels i have a dataset with continuous labels that by themselves already have an error after training my model i get the model error for each prediction which i define as the absolute difference between expected and predicted value is this error correlated with the labels error in particular i suspect that i cannot achieve an error that is lower than the labels error so it is kind of a lower bound then this is the total error that includes also the labels uncertainty is my reasoning correct</td>\n",
              "      <td>error lower bound and label uncertainty</td>\n",
              "      <td>how do i train a model error when the loss is too high</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1247</th>\n",
              "      <td>1247</td>\n",
              "      <td>what are your favorite papers involving ml and temporal data or time series i came across some papers about the use of lstm networks to improve image and speech classification and am curious about other examples out there either within or outside of the cv space what researchworkpapers with ml and time series have excited you recentlythanks ampxb the papers im referring semisupervised spatiotemporal cnn for recognition of surgical workflow chen y sun ql amp zhong k j image video proc spatiotemporal pain recognition in cnnbased superresolved facial images bellantonio m haque m a rodriguez p nasrollahi k telve t guerrero s e anbarjafari g in international conference on pattern recognition icpr workshop on face and facial expression recognition capture learning and synthesis of d speaking styles daniel cudeiro timo bolkart cassidy laidlaw anurag ranjan michael j black may preprint to appear in cvpr  edited</td>\n",
              "      <td>what are some mp and temporal data or time series papers you like</td>\n",
              "      <td>what are your favorite papers on lstm for speech recognition</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1076</th>\n",
              "      <td>1076</td>\n",
              "      <td>hi all i am currently interning as a data scientist so far the work has involved very little machine learning or much of any work tbh are most data science jobs like this should i be looking at other industries that do more machine learning it does not even have to be deep learning albeit that is neat too but it would be nice if it could be something other than just oh we have literally any data set and we need to solve literally any problem i will only accept linear model do not worry about the choosing features we can do that later on one hand as an intern it is not my responsibility to select models or whatever i am also only getting paid quite crappily hourly with no overtime so it is not exactly in my best interest to spend all my time on this on the other hand if this is how data science i am really concerned how can i get involved with some more technical where would i even find those jobs what should i search for them or is this feeling just because i am an intern for reference i am a math phd decent coder and familiar with the usual machine learning things esl andrew ng is deep learning series slowly working through the deep learning booketc and diving deeper into the reinforcement learning literature following this and his sequel so it is not like i am some random lol i took one udemy class and now i know everything person</td>\n",
              "      <td>machine learning heavy jobs</td>\n",
              "      <td>what is the best way to get into a data science job</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>912</th>\n",
              "      <td>912</td>\n",
              "      <td>hello everyone i am taking a course on udacity about reinforcement learning in a video they say that since the following equation holds bk q_ bk q_ leq gammak q_q__infty it can be useful to run the value update more than once they apply k times the bellman operator to both qltsubgtltsubgt and qltsubgtltsubgt now i have a question do they mean that is useful to update multiple time the qvalue for each reward this kind of make sense to me because it could be that this makes something similar to what happens with a higher learning rate but being more stable i do not know whether it is true or not and i did not try to prove it is my reasoning correct</td>\n",
              "      <td>does updating value in qlearning more than once per step make sense</td>\n",
              "      <td>question about qvalue update in keras</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>348</th>\n",
              "      <td>348</td>\n",
              "      <td>hi ranalytics i am the maintainer of miceranger an r package which performs multiple imputation by chained equations mice with random forests i have developed a package miceforest which does the same thing in python github pypi i am a huge fan of documentation so i have included a very comprehensive readme on the github which explains the mice algorithm and the details of the package i have recently gotten the package into a pretty stable state complete with docs mypy checks ci testing etc so i thought i would share the news what is mice multiple imputation by chained equations mice is an iterative method that allows you to fill in missing data using all of the available information in the dataset over a series of iterations every column in the data set gets modeled by the other columns and the missing values are inferred by the model stef van buuren wrote the book on missing data which details the algorithm here random forests are a good chaining equation to use because they do not need much hyperparameter tuning easily handle nonlinear relationships in the data can return oob performance inexpensively are trivially parallelizable can return feature importance for diagnostics what is it used for i do a lot of funnel modeling at my current position and mice has proven invaluable it allows us to eliminate bias in the funnel caused by missing data being less missing the further up the funnel you go which allows us to use all available information no matter the funnel stage create confidence intervals on our predictions more data filled out less imputed variance a more confident prediction this allows us to create more robust confidence intervals for our forecasts motivation i originally developed this package for r because all of the available packages were lacking in either speed or features as i start using python more i noticed that the available mice implementations do not provide the functionality i find myself using most often custom imputation schemas built in diagnostic plotting imputing new data</td>\n",
              "      <td>new library multiple imputation by random forests in python</td>\n",
              "      <td>pytorch vs tensorflow keras</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>877</th>\n",
              "      <td>877</td>\n",
              "      <td>hi all i am a new student of neural networks and am looking for some pointers in terms of learning resources and technical direction for a new project that i am starting i am looking to build a solution to optimize route planning i have a relational database of destinations each with an address based on these addresses or nodes the goal is to create a solution perhaps involving a neural network that is able to create optimized routes based on the number of available trucks and their capacity my background consists of years of software development experience save for reading about neural nets i have not yet built anything as this is my first foray into the field i am very excited to begin learning and building but i am have a lot of questions i have not yet found a community or forum where i can ask these questions so any pointers would be greatly appreciated thanks everyone</td>\n",
              "      <td>looking for direction for a new route automation project</td>\n",
              "      <td>looking for recommendations for a neural network architecture for route planning</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>325</th>\n",
              "      <td>325</td>\n",
              "      <td>hi trying to do a little project of predicting the time of the sunrise given a month and a day my process thusfar has been scrape years of sunrise data feature engineer the data so i have month day and sunrise time which i have converted to seconds from midnight split the data for traintest in chronological order important for time series analysis used xgboost algorithm trained model tested model i am getting about accuracy and am not really sure how to iterate in order to try to get better results should i try another algorithm do i need more features my margin of error is pretty small and when my model is incorrect it is not off by much i feel stuck but want to improve the model as it is something which should be extremely predictable any advice is much appreciated</td>\n",
              "      <td>predicting the sunrise</td>\n",
              "      <td>predicting the time series with xgboost</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>647</th>\n",
              "      <td>647</td>\n",
              "      <td>hello i am a computer engineer and for one of my projects is ai detection for crime scene evidence analysis and for me to do that i need a photo or video datasets of crime scenes i tried searching everywhere i cannot find any database of crime scene photos does anybody know of anywhere i can find some photos or it forensic competitions that have such datasets i need it urgently please help a professor suggested using kaggle however i could not find anything plus i am not sure how i can use it the dataset does not even have to be real i just need anything to start working on my project thanks</td>\n",
              "      <td>crime scene datasetphoto and video database</td>\n",
              "      <td>looking for datasets of crime scene images</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-ba4ab046-2860-4e36-80aa-5729f6318172')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-ba4ab046-2860-4e36-80aa-5729f6318172 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-ba4ab046-2860-4e36-80aa-5729f6318172');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-5de1bc19-bab8-4ed3-aed2-c8307c940f8f\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-5de1bc19-bab8-4ed3-aed2-c8307c940f8f')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-5de1bc19-bab8-4ed3-aed2-c8307c940f8f button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "  <div id=\"id_abd58be9-b811-40e3-85cc-bf13016e0772\">\n",
              "    <style>\n",
              "      .colab-df-generate {\n",
              "        background-color: #E8F0FE;\n",
              "        border: none;\n",
              "        border-radius: 50%;\n",
              "        cursor: pointer;\n",
              "        display: none;\n",
              "        fill: #1967D2;\n",
              "        height: 32px;\n",
              "        padding: 0 0 0 0;\n",
              "        width: 32px;\n",
              "      }\n",
              "\n",
              "      .colab-df-generate:hover {\n",
              "        background-color: #E2EBFA;\n",
              "        box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "        fill: #174EA6;\n",
              "      }\n",
              "\n",
              "      [theme=dark] .colab-df-generate {\n",
              "        background-color: #3B4455;\n",
              "        fill: #D2E3FC;\n",
              "      }\n",
              "\n",
              "      [theme=dark] .colab-df-generate:hover {\n",
              "        background-color: #434B5C;\n",
              "        box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "        filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "        fill: #FFFFFF;\n",
              "      }\n",
              "    </style>\n",
              "    <button class=\"colab-df-generate\" onclick=\"generateWithVariable('sample_t5')\"\n",
              "            title=\"Generate code using this dataframe.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M7,19H8.4L18.45,9,17,7.55,7,17.6ZM5,21V16.75L18.45,3.32a2,2,0,0,1,2.83,0l1.4,1.43a1.91,1.91,0,0,1,.58,1.4,1.91,1.91,0,0,1-.58,1.4L9.25,21ZM18.45,9,17,7.55Zm-12,3A5.31,5.31,0,0,0,4.9,8.1,5.31,5.31,0,0,0,1,6.5,5.31,5.31,0,0,0,4.9,4.9,5.31,5.31,0,0,0,6.5,1,5.31,5.31,0,0,0,8.1,4.9,5.31,5.31,0,0,0,12,6.5,5.46,5.46,0,0,0,6.5,12Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "    <script>\n",
              "      (() => {\n",
              "      const buttonEl =\n",
              "        document.querySelector('#id_abd58be9-b811-40e3-85cc-bf13016e0772 button.colab-df-generate');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      buttonEl.onclick = () => {\n",
              "        google.colab.notebook.generateWithVariable('sample_t5');\n",
              "      }\n",
              "      })();\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "variable_name": "sample_t5",
              "summary": "{\n  \"name\": \"sample_t5\",\n  \"rows\": 30,\n  \"fields\": [\n    {\n      \"column\": \"Index_ID\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 347,\n        \"min\": 107,\n        \"max\": 1247,\n        \"num_unique_values\": 30,\n        \"samples\": [\n          877,\n          966,\n          1247\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"ref_post\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 30,\n        \"samples\": [\n          \"hi all i am a new student of neural networks and am looking for some pointers in terms of learning resources and technical direction for a new project that i am starting i am looking to build a solution to optimize route planning i have a relational database of destinations each with an address based on these addresses or nodes the goal is to create a solution perhaps involving a neural network that is able to create optimized routes based on the number of available trucks and their capacity my background consists of years of software development experience save for reading about neural nets i have not yet built anything as this is my first foray into the field i am very excited to begin learning and building but i am have a lot of questions i have not yet found a community or forum where i can ask these questions so any pointers would be greatly appreciated thanks everyone\",\n          \"okay so i was dealing with a problem that a peer posed to me he gave me a dataset and an xgboost model which was trained on the same dataset the dataset contains features and label the dataset is about the marketing campaigns of an agency through channels and the label is the transactions processed by the agency now the question is given the dataset predict how much contribution each channel makes to increase the transactions and given a budget find the optimum budget allocation to different channels so that the number of transactions is maximized i have identified the most important channels and their order as well using correlation but my question is how do i quantify it i am not very fluent in data science i am mostly learning by myself a little help will be appreciated\",\n          \"what are your favorite papers involving ml and temporal data or time series i came across some papers about the use of lstm networks to improve image and speech classification and am curious about other examples out there either within or outside of the cv space what researchworkpapers with ml and time series have excited you recentlythanks ampxb the papers im referring semisupervised spatiotemporal cnn for recognition of surgical workflow chen y sun ql amp zhong k j image video proc spatiotemporal pain recognition in cnnbased superresolved facial images bellantonio m haque m a rodriguez p nasrollahi k telve t guerrero s e anbarjafari g in international conference on pattern recognition icpr workshop on face and facial expression recognition capture learning and synthesis of d speaking styles daniel cudeiro timo bolkart cassidy laidlaw anurag ranjan michael j black may preprint to appear in cvpr \\u00a0edited\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"ref_title\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 30,\n        \"samples\": [\n          \"looking for direction for a new route automation project\",\n          \"finding the proper method to maximize the predictions of a given class\",\n          \"what are some mp and temporal data or time series papers you like\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"candidate_title\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 30,\n        \"samples\": [\n          \"looking for recommendations for a neural network architecture for route planning\",\n          \"how do i measure the difference between a channel and an xgboost\",\n          \"what are your favorite papers on lstm for speech recognition\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### ROUGE + BLEU Evaluation\n",
        "\n",
        "For ROUGE, we evaluate based on F1 which is the average of the reported Precision and Recall.\n",
        "\n",
        "\n",
        "For BLEU, we apply the smoothing [method 4](https://www.nltk.org/api/nltk.translate.bleu_score.html) which ratios the number of n-gram overlaps to the total number of n-grams in the candidate selection."
      ],
      "metadata": {
        "id": "cSRCAfongP77"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load rouge\n",
        "rouge = evaluate.load('rouge')\n",
        "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
        "\n",
        "# Load BlEU\n",
        "bleu = evaluate.load('bleu')"
      ],
      "metadata": {
        "id": "hVSoGBoEiFEZ"
      },
      "execution_count": 139,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "First we'll evaluate Rouge and BLEU for the Candidate (Generated) Title vs the Original Title to determine how closely the the generated title mimics the original title."
      ],
      "metadata": {
        "id": "PyV5kScCgVfu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Summary\n",
        "print(\" T5 Sample - ROUGE Summary: \".center(50, \"*\"))\n",
        "rouge_results = rouge.compute(predictions=candidate_title_list, references=ref_title_list, use_stemmer=True)\n",
        "print(rouge_results,\"\\n\")\n",
        "\n",
        "# Individual ROUGE Scores\n",
        "cand_title_ref_title_rouge1_f1_scores = []\n",
        "cand_title_ref_title_rouge2_f1_scores = []\n",
        "cand_title_ref_title_rougeL_f1_scores = []\n",
        "\n",
        "# Individual BLEU Scores\n",
        "cand_title_ref_title_bleu_scores = []\n",
        "\n",
        "# Extract the F1-scores for rouge1, rouge2, and rougeL\n",
        "for candidate, reference in zip(candidate_title_list, ref_title_list):\n",
        "    # ROUGE\n",
        "    scores = scorer.score(candidate, reference)\n",
        "    rouge1_f1 = scores['rouge1'].fmeasure\n",
        "    rouge2_f1 = scores['rouge2'].fmeasure\n",
        "    rougeL_f1 = scores['rougeL'].fmeasure\n",
        "\n",
        "    cand_title_ref_title_rouge1_f1_scores.append(rouge1_f1)\n",
        "    cand_title_ref_title_rouge2_f1_scores.append(rouge2_f1)\n",
        "    cand_title_ref_title_rougeL_f1_scores.append(rougeL_f1)\n",
        "\n",
        "    # BLEU\n",
        "    candidate_tokens = nltk.word_tokenize(candidate)\n",
        "    reference_tokens = [nltk.word_tokenize(reference)]\n",
        "\n",
        "    smoothing = SmoothingFunction().method4\n",
        "    score = sentence_bleu(reference_tokens, candidate_tokens, smoothing_function=smoothing)\n",
        "    cand_title_ref_title_bleu_scores.append(score)\n",
        "\n",
        "\n",
        "print(\" T5 Sample - Individual Results: \".center(50, \"*\"))\n",
        "print(\"rouge1_f1_scores: \",cand_title_ref_title_rouge1_f1_scores,\"\\n\")\n",
        "print(\"rouge2_f1_scores: \",cand_title_ref_title_rouge2_f1_scores,\"\\n\")\n",
        "print(\"rougeL_f1_scores: \",cand_title_ref_title_rougeL_f1_scores,\"\\n\")\n",
        "print(\"BLEU_scores: \",cand_title_ref_title_bleu_scores,\"\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JAKW3HzLgSor",
        "outputId": "75986e94-e810-43e8-ac41-f44130712b54"
      },
      "execution_count": 140,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "*********** T5 Sample - ROUGE Summary: ***********\n",
            "{'rouge1': 0.1859852684395018, 'rouge2': 0.05290372395635554, 'rougeL': 0.18454822728554282, 'rougeLsum': 0.18240439913988007} \n",
            "\n",
            "******** T5 Sample - Individual Results: *********\n",
            "rouge1_f1_scores:  [0.2105263157894737, 0.4761904761904762, 0.0, 0.25000000000000006, 0.36363636363636365, 0.0, 0.0, 0.0, 0.0, 0.19047619047619047, 0.3333333333333333, 0.10526315789473685, 0.0, 0.2105263157894737, 0.09999999999999999, 0.16666666666666666, 0.1111111111111111, 0.0, 0.13793103448275862, 0.30769230769230765, 0.3636363636363636, 0.3, 0.10526315789473684, 0.2608695652173913, 0.125, 0.2222222222222222, 0.0, 0.5, 0.4444444444444444, 0.30769230769230765] \n",
            "\n",
            "rouge2_f1_scores:  [0.0, 0.2105263157894737, 0.0, 0.14285714285714288, 0.0, 0.0, 0.0, 0.0, 0.0, 0.10526315789473684, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.22222222222222224, 0.15789473684210525, 0.0, 0.09523809523809525, 0.0, 0.0, 0.0, 0.22222222222222224, 0.28571428571428575, 0.1818181818181818] \n",
            "\n",
            "rougeL_f1_scores:  [0.2105263157894737, 0.4761904761904762, 0.0, 0.25000000000000006, 0.36363636363636365, 0.0, 0.0, 0.0, 0.0, 0.19047619047619047, 0.3333333333333333, 0.10526315789473685, 0.0, 0.2105263157894737, 0.09999999999999999, 0.16666666666666666, 0.1111111111111111, 0.0, 0.13793103448275862, 0.30769230769230765, 0.3636363636363636, 0.2, 0.10526315789473684, 0.2608695652173913, 0.125, 0.2222222222222222, 0.0, 0.5, 0.4444444444444444, 0.30769230769230765] \n",
            "\n",
            "BLEU_scores:  [0.02568481047180467, 0.11057078116370667, 0, 0.05190794196013298, 0.03848196746087264, 0, 0, 0, 0, 0.006522556529829675, 0.03401086821506398, 0.02302676613984314, 0, 0.02383765064930276, 0.0206052556810215, 0.02383765064930276, 0.018273910508530698, 0, 0.015714747836544366, 0.020136065387563098, 0.09717716588732002, 0.06126147687778762, 0.018724372764461875, 0.04669116179644531, 0, 0.013829840691272653, 0, 0.07762047774578669, 0.09717716588732002, 0.081939171811711] \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next we'll evaluate the Rouge and Bleu for the Generated Title vs the Original Post to determine how closely the the generated title (candidate) captures the salient points of the original post."
      ],
      "metadata": {
        "id": "FzDQQtNTgyPi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Summary\n",
        "print(\" T5 Sample - ROUGE Summary: \".center(50, \"*\"))\n",
        "rouge_results = rouge.compute(predictions=candidate_title_list, references=ref_post_list, use_stemmer=True)\n",
        "print(rouge_results,\"\\n\")\n",
        "\n",
        "# Individual Rouge Scores (\"F1\")\n",
        "cand_title_ref_post_rouge1_f1_scores = []\n",
        "cand_title_ref_post_rouge2_f1_scores = []\n",
        "cand_title_ref_post_rougeL_f1_scores = []\n",
        "\n",
        "# Individual BLEU\n",
        "cand_title_ref_post_bleu_scores = []\n",
        "\n",
        "# Extract the F1-scores for rouge1, rouge2, and rougeL\n",
        "for candidate, reference in zip(candidate_title_list, ref_post_list):\n",
        "    # ROUGE\n",
        "    scores = scorer.score(candidate, reference)\n",
        "    rouge1_f1 = scores['rouge1'].fmeasure\n",
        "    rouge2_f1 = scores['rouge2'].fmeasure\n",
        "    rougeL_f1 = scores['rougeL'].fmeasure\n",
        "\n",
        "    cand_title_ref_post_rouge1_f1_scores.append(rouge1_f1)\n",
        "    cand_title_ref_post_rouge2_f1_scores.append(rouge2_f1)\n",
        "    cand_title_ref_post_rougeL_f1_scores.append(rougeL_f1)\n",
        "\n",
        "    # BLEU\n",
        "    candidate_tokens = nltk.word_tokenize(candidate)\n",
        "    reference_tokens = [nltk.word_tokenize(reference)]\n",
        "\n",
        "    smoothing = SmoothingFunction().method4\n",
        "    score = sentence_bleu(reference_tokens, candidate_tokens, smoothing_function=smoothing)\n",
        "    cand_title_ref_post_bleu_scores.append(score)\n",
        "\n",
        "print(\" T5 Sample - Individual Results: \".center(50, \"*\"))\n",
        "print(\"rouge1_f1_scores: \",cand_title_ref_post_rouge1_f1_scores,\"\\n\")\n",
        "print(\"rouge2_f1_scores: \",cand_title_ref_post_rouge2_f1_scores,\"\\n\")\n",
        "print(\"rougeL_f1_scores: \",cand_title_ref_post_rougeL_f1_scores,\"\\n\")\n",
        "print(\"BLEU_scores: \",cand_title_ref_post_bleu_scores,\"\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3DwKVNNehd2R",
        "outputId": "ec58d361-f4cf-4bad-d5f7-9ffb7630f8c4"
      },
      "execution_count": 141,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "*********** T5 Sample - ROUGE Summary: ***********\n",
            "{'rouge1': 0.09065511256983938, 'rouge2': 0.03819845340654408, 'rougeL': 0.06732442206251328, 'rougeLsum': 0.06847147693262426} \n",
            "\n",
            "******** T5 Sample - Individual Results: *********\n",
            "rouge1_f1_scores:  [0.10784313725490197, 0.1411764705882353, 0.04790419161676646, 0.07936507936507936, 0.06493506493506493, 0.2064516129032258, 0.0264026402640264, 0.0396039603960396, 0.1264367816091954, 0.05194805194805195, 0.026845637583892617, 0.10071942446043165, 0.03418803418803419, 0.07119741100323625, 0.0653061224489796, 0.13245033112582782, 0.08695652173913045, 0.09448818897637794, 0.11180124223602485, 0.15763546798029557, 0.07633587786259541, 0.21333333333333335, 0.109375, 0.12903225806451613, 0.08088235294117647, 0.07575757575757576, 0.0, 0.10526315789473685, 0.06711409395973154, 0.08264462809917354] \n",
            "\n",
            "rouge2_f1_scores:  [0.039603960396039604, 0.08333333333333334, 0.03636363636363636, 0.064, 0.039473684210526314, 0.0915032679738562, 0.006644518272425249, 0.015904572564612328, 0.034883720930232565, 0.026315789473684213, 0.016835016835016835, 0.0145985401459854, 0.0, 0.02605863192182411, 0.016460905349794237, 0.06711409395973154, 0.029411764705882356, 0.03968253968253969, 0.012578616352201259, 0.09950248756218906, 0.06201550387596899, 0.08968609865470852, 0.015873015873015872, 0.05228758169934641, 0.022222222222222223, 0.0, 0.0, 0.0591715976331361, 0.04081632653061224, 0.050420168067226885] \n",
            "\n",
            "rougeL_f1_scores:  [0.0588235294117647, 0.11764705882352941, 0.04790419161676646, 0.05555555555555555, 0.06493506493506493, 0.12903225806451613, 0.019801980198019806, 0.02772277227722772, 0.10344827586206896, 0.03896103896103896, 0.026845637583892617, 0.05755395683453238, 0.017094017094017096, 0.045307443365695796, 0.04081632653061225, 0.06622516556291391, 0.08695652173913045, 0.07086614173228346, 0.08695652173913043, 0.13793103448275865, 0.07633587786259541, 0.1511111111111111, 0.09374999999999999, 0.1032258064516129, 0.05147058823529412, 0.030303030303030304, 0.0, 0.08187134502923978, 0.06711409395973154, 0.08264462809917354] \n",
            "\n",
            "BLEU_scores:  [1.132288148114643e-08, 5.180092896002226e-06, 3.066924390756207e-12, 5.180971612129119e-10, 8.960264999590676e-10, 0.0005189151645030973, 9.989398893554941e-23, 3.672850581535407e-19, 5.2800294147489444e-06, 3.3468891319749196e-17, 2.0062061250952075e-32, 1.205657790153928e-07, 7.356727989684737e-18, 5.0125954318504445e-12, 1.182203774752417e-12, 4.990835627920614e-06, 2.599039297543893e-09, 6.987292491371519e-09, 3.5899229439348267e-07, 5.028540745830715e-05, 1.8501735239957485e-09, 0.00036114309427350336, 1.953594999531785e-05, 6.40427055161562e-07, 8.985280437343561e-11, 1.6170719715976343e-10, 0, 2.5168841277231433e-07, 3.563497402214967e-11, 5.753707140958508e-08] \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finally, we'll evaluate the Rouge and Bleu for the Original Title vs the Original Post to be used as a baseline for understandling how the original titles correspond to the original post."
      ],
      "metadata": {
        "id": "otr3QoBchNlP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## Summary\n",
        "print(\" T5 Sample - ROUGE Summary: \".center(50, \"*\"))\n",
        "rouge_results = rouge.compute(predictions=ref_title_list, references=ref_post_list, use_stemmer=True)\n",
        "print(rouge_results,\"\\n\")\n",
        "\n",
        "# Individual Rouge Scores (\"F1\")\n",
        "ref_title_ref_post_rouge1_f1_scores = []\n",
        "ref_title_ref_post_rouge2_f1_scores = []\n",
        "ref_title_ref_post_rougeL_f1_scores = []\n",
        "\n",
        "# Individual BLEU\n",
        "ref_title_ref_post_bleu_scores = []\n",
        "\n",
        "# Extract the F1-scores for rouge1, rouge2, and rougeL\n",
        "for candidate, reference in zip(ref_title_list, ref_post_list):\n",
        "    scores = scorer.score(candidate, reference)\n",
        "\n",
        "    # ROUGE\n",
        "    rouge1_f1 = scores['rouge1'].fmeasure\n",
        "    rouge2_f1 = scores['rouge2'].fmeasure\n",
        "    rougeL_f1 = scores['rougeL'].fmeasure\n",
        "\n",
        "    ref_title_ref_post_rouge1_f1_scores.append(rouge1_f1)\n",
        "    ref_title_ref_post_rouge2_f1_scores.append(rouge2_f1)\n",
        "    ref_title_ref_post_rougeL_f1_scores.append(rougeL_f1)\n",
        "\n",
        "    # BLEU\n",
        "    candidate_tokens = nltk.word_tokenize(candidate)\n",
        "    reference_tokens = [nltk.word_tokenize(reference)]\n",
        "\n",
        "    # Compute BLEU score\n",
        "    smoothing = SmoothingFunction().method4\n",
        "    score = sentence_bleu(reference_tokens, candidate_tokens, smoothing_function=smoothing)\n",
        "    ref_title_ref_post_bleu_scores.append(score)\n",
        "\n",
        "print(\" T5 Sample - Individual Results: \".center(50, \"*\"))\n",
        "print(\"rouge1_f1_scores: \",ref_title_ref_post_rouge1_f1_scores,\"\\n\")\n",
        "print(\"rouge2_f1_scores: \",ref_title_ref_post_rouge2_f1_scores,\"\\n\")\n",
        "print(\"rougeL_f1_scores: \",ref_title_ref_post_rougeL_f1_scores,\"\\n\")\n",
        "print(\"BLEU_scores: \",ref_title_ref_post_bleu_scores,\"\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UY0yiligheW0",
        "outputId": "5c18f3dd-285c-4b1a-cfaa-985f5bac0e18"
      },
      "execution_count": 142,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "*********** T5 Sample - ROUGE Summary: ***********\n",
            "{'rouge1': 0.0703487048743832, 'rouge2': 0.023235513641625932, 'rougeL': 0.056936304184073236, 'rougeLsum': 0.05693733025281984} \n",
            "\n",
            "******** T5 Sample - Individual Results: *********\n",
            "rouge1_f1_scores:  [0.05970149253731343, 0.09696969696969697, 0.03614457831325301, 0.03252032520325203, 0.03973509933774834, 0.09395973154362415, 0.07766990291262137, 0.016096579476861165, 0.036585365853658534, 0.059880239520958084, 0.013513513513513513, 0.07142857142857144, 0.09917355371900825, 0.03289473684210526, 0.0728744939271255, 0.11920529801324503, 0.07042253521126761, 0.024390243902439025, 0.1566265060240964, 0.08290155440414508, 0.061538461538461535, 0.1137440758293839, 0.09917355371900827, 0.13924050632911392, 0.02272727272727273, 0.11594202898550725, 0.045584045584045586, 0.09467455621301775, 0.0410958904109589, 0.08333333333333333] \n",
            "\n",
            "rouge2_f1_scores:  [0.020100502512562814, 0.04907975460122699, 0.012195121951219514, 0.01639344262295082, 0.02684563758389262, 0.0272108843537415, 0.013029315960912054, 0.00404040404040404, 0.0, 0.01212121212121212, 0.006779661016949153, 0.014492753623188404, 0.016806722689075633, 0.006622516556291392, 0.00816326530612245, 0.013422818791946308, 0.0, 0.0, 0.07317073170731707, 0.020942408376963352, 0.015625, 0.06698564593301437, 0.03361344537815126, 0.07692307692307693, 0.0076335877862595426, 0.044117647058823525, 0.022922636103151862, 0.04790419161676647, 0.02777777777777778, 0.016949152542372878] \n",
            "\n",
            "rougeL_f1_scores:  [0.04975124378109452, 0.08484848484848484, 0.03614457831325301, 0.03252032520325203, 0.02649006622516556, 0.04026845637583894, 0.0517799352750809, 0.012072434607645875, 0.036585365853658534, 0.059880239520958084, 0.013513513513513513, 0.07142857142857144, 0.04958677685950413, 0.03289473684210526, 0.05668016194331984, 0.0794701986754967, 0.04225352112676057, 0.016260162601626015, 0.12048192771084336, 0.08290155440414508, 0.061538461538461535, 0.08530805687203794, 0.08264462809917356, 0.12658227848101267, 0.02272727272727273, 0.08695652173913042, 0.03988603988603988, 0.08284023668639053, 0.0410958904109589, 0.08333333333333333] \n",
            "\n",
            "BLEU_scores:  [1.009540987458411e-11, 4.5842181315543305e-09, 3.780739734370426e-15, 1.0208130097443284e-21, 5.010109177642322e-17, 9.355746430441447e-06, 4.215073529760184e-12, 1.616709551650512e-54, 2.2825763787448568e-15, 1.7326543738905463e-05, 7.292952329775228e-65, 2.038275342089793e-07, 2.3685099090140507e-08, 1.0490027040135035e-19, 9.288692816643719e-11, 7.948048299123593e-07, 5.586964089647923e-07, 1.7218519843400103e-22, 3.4202195491427166e-05, 5.878292128193148e-10, 5.441664163746379e-12, 3.436519125328527e-07, 1.128759233435874e-09, 1.8042329911392778e-05, 2.9857324683040134e-29, 1.2801565087674307e-05, 1.8737637358273617e-17, 1.9719833297866137e-08, 1.5069155180421673e-21, 1.5753104111137536e-09] \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Angular Sim + Fréchet's Distance"
      ],
      "metadata": {
        "id": "ZpkBY6Opf4vm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Encode T5\n",
        "ref_post, ref_title, candidate_title = subset_columns(sample_t5)\n",
        "\n",
        "# Embed data\n",
        "# original post\n",
        "ref_post_embeddings = embed(ref_post[:].values.flatten())\n",
        "\n",
        "# original title (ground truth)\n",
        "ref_title_embeddings = embed(ref_title[:].values.flatten())\n",
        "\n",
        "# generated title\n",
        "candidate_title_embeddings = embed(candidate_title[:].values.flatten())"
      ],
      "metadata": {
        "id": "u3rTU8G6aB_T"
      },
      "execution_count": 143,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Angular Similarity Calculation\n",
        "ang_sim_gen_title_ref_post = []\n",
        "ang_sim_ref_title_ref_post = []\n",
        "\n",
        "# Fréchet's Distance Calculation\n",
        "fd_gen_title_ref_post = []\n",
        "fd_ref_title_ref_post = []\n",
        "\n",
        "for i in range(len(candidate_title_embeddings)):\n",
        "\n",
        "  gen_title = np.expand_dims(candidate_title_embeddings[i], axis=0)\n",
        "  ref_title = np.expand_dims(ref_title_embeddings[i], axis=0)\n",
        "  ref_post = np.expand_dims(ref_post_embeddings[i], axis=0)\n",
        "\n",
        "  # compare Angular Sim - generated title vs original post\n",
        "  ang_sim_gen_title_ref_post.append(float(angular_similarity(gen_title, ref_post)[0]))\n",
        "\n",
        "  # compare Angular Sim - original title (ground truth) vs original post\n",
        "  ang_sim_ref_title_ref_post.append(float(angular_similarity(ref_title, ref_post)[0]))\n",
        "\n",
        "  # compare Fréchet's Distance - generated title vs original post\n",
        "  fd_gen_title_ref_post.append(float(frechet_distance(gen_title, ref_post)))\n",
        "\n",
        "  # compare Fréchet's Distance -  original title (ground truth) vs original post\n",
        "  fd_ref_title_ref_post.append(float(frechet_distance(ref_title, ref_post)))\n",
        "\n",
        "print(\" T5 Sample - Summary Results \".center(50, \"*\"))\n",
        "print(\"Shape :\",candidate_title_embeddings.shape)\n",
        "\n",
        "# Angular Similarity\n",
        "summary_ang_sim_gen_title_ref_post = np.mean(ang_sim_gen_title_ref_post)\n",
        "print(\"Angular Sim - Candidate Title vs Ref Post :\\t\\t\",summary_ang_sim_gen_title_ref_post)\n",
        "summary_ang_sim_ref_title_ref_post = np.mean(ang_sim_ref_title_ref_post)\n",
        "print(\"Angular Sim - Ref Title vs Ref Post :\\t\\t\\t\",summary_ang_sim_ref_title_ref_post,\"\\n\")\n",
        "\n",
        "# Fréchet's Distance\n",
        "summary_fd_gen_title_ref_post = np.mean(fd_gen_title_ref_post)\n",
        "print(\"Fréchet's Distance - Candidate Title vs Ref Post :\\t\",summary_fd_gen_title_ref_post)\n",
        "\n",
        "summary_fd_ref_title_ref_post = np.mean(fd_ref_title_ref_post)\n",
        "print(\"Fréchet's Distance - Ref Title vs Ref Post :\\t\\t\",summary_fd_ref_title_ref_post,\"\\n\")\n",
        "\n",
        "\n",
        "print(\" T5 Sample - Individual Results \".center(50, \"*\"))\n",
        "print(\"Angular Sim - Candidate Title vs Ref Post: \\t\\t\", ang_sim_gen_title_ref_post)\n",
        "print(\"Angular Sim - Ref Title vs Ref Post: \\t\\t\\t\", ang_sim_ref_title_ref_post)\n",
        "print(\"Fréchet's Distance - Candidate Title vs Ref Post: \\t\", fd_gen_title_ref_post)\n",
        "print(\"Fréchet's Distance - Ref Title vs Ref Post: \\t\\t\", fd_ref_title_ref_post)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zll414pRaU6c",
        "outputId": "b6a9f4e6-29e3-44f3-dd70-81a78155df74"
      },
      "execution_count": 144,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "********** T5 Sample - Summary Results ***********\n",
            "Shape : (30, 512)\n",
            "Angular Sim - Candidate Title vs Ref Post :\t\t 0.6550734182198842\n",
            "Angular Sim - Ref Title vs Ref Post :\t\t\t 0.6261562466621399 \n",
            "\n",
            "Fréchet's Distance - Candidate Title vs Ref Post :\t 1.0282037695248922\n",
            "Fréchet's Distance - Ref Title vs Ref Post :\t\t 1.1053951958815256 \n",
            "\n",
            "********* T5 Sample - Individual Results *********\n",
            "Angular Sim - Candidate Title vs Ref Post: \t\t [0.6980219483375549, 0.6605457067489624, 0.6975061893463135, 0.6889651417732239, 0.7034493684768677, 0.7107468843460083, 0.5203438997268677, 0.6007131338119507, 0.578548789024353, 0.611819863319397, 0.6268244981765747, 0.6517469882965088, 0.5860241651535034, 0.6425938606262207, 0.6371446251869202, 0.6122987270355225, 0.6956092119216919, 0.6986135244369507, 0.6694737672805786, 0.692130446434021, 0.6209489107131958, 0.746872067451477, 0.6393342018127441, 0.6681184768676758, 0.6878771185874939, 0.6541029214859009, 0.613335132598877, 0.6983274817466736, 0.6152242422103882, 0.7249412536621094]\n",
            "Angular Sim - Ref Title vs Ref Post: \t\t\t [0.6362200975418091, 0.6836125254631042, 0.6310856342315674, 0.6739853024482727, 0.5501909255981445, 0.6131094694137573, 0.6966399550437927, 0.5327757596969604, 0.5514169931411743, 0.6010401248931885, 0.5916522145271301, 0.57875657081604, 0.6738057732582092, 0.6072380542755127, 0.668770968914032, 0.5958526134490967, 0.6489464640617371, 0.5760617852210999, 0.6728686690330505, 0.6528366804122925, 0.5779619812965393, 0.6630846858024597, 0.682702898979187, 0.6213711500167847, 0.6743146181106567, 0.6512249708175659, 0.6325392723083496, 0.6135685443878174, 0.5797130465507507, 0.6513396501541138]\n",
            "Fréchet's Distance - Candidate Title vs Ref Post: \t [0.9135135412216187, 1.0166069269180298, 0.9149548411369324, 0.9387317299842834, 0.8983123302459717, 0.8777709007263184, 1.3683065176010132, 1.1737571954727173, 1.2294132709503174, 1.1453282833099365, 1.106370210647583, 1.0403136014938354, 1.2108054161071777, 1.0647642612457275, 1.0792168378829956, 1.1440945863723755, 0.9202499389648438, 0.9118600487709045, 0.9923529624938965, 0.9299393892288208, 1.1216999292373657, 0.7744364738464355, 1.0734189748764038, 0.9960475564002991, 0.9417484402656555, 1.0339853763580322, 1.1414225101470947, 0.9126596450805664, 1.1365442276000977, 0.8374871611595154]\n",
            "Fréchet's Distance - Ref Title vs Ref Post: \t\t [1.0816609859466553, 0.9535466432571411, 1.09519362449646, 0.980022668838501, 1.2984399795532227, 1.1420046091079712, 0.9173737168312073, 1.3395625352859497, 1.2955079078674316, 1.172925591468811, 1.196685552597046, 1.2288984060287476, 0.9805142283439636, 1.157098650932312, 0.9942694306373596, 1.1860865354537964, 1.0478178262710571, 1.23556649684906, 0.9830790758132935, 1.0373883247375488, 1.2308669090270996, 1.0097297430038452, 0.9560577273368835, 1.1206015348434448, 0.9791204333305359, 1.041714072227478, 1.0913695096969604, 1.1408203840255737, 1.2265262603759766, 1.041406512260437]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Include the following columns the the sample dataframe\n",
        "\n",
        "# Angular Sim\n",
        "sample_t5['ang_sim_gen_title_ref_post'] = ang_sim_gen_title_ref_post\n",
        "sample_t5['ang_sim_ref_title_ref_post'] = ang_sim_ref_title_ref_post\n",
        "\n",
        "# Fréchet's Distance\n",
        "sample_t5['fd_gen_title_ref_post'] = fd_gen_title_ref_post\n",
        "sample_t5['fd_ref_title_ref_post'] = fd_ref_title_ref_post\n",
        "\n",
        "# ROUGE\n",
        "sample_t5['ROUGE1_cand_title_ref_title'] = cand_title_ref_title_rouge1_f1_scores\n",
        "sample_t5['ROUGE2_cand_title_ref_title'] = cand_title_ref_title_rouge2_f1_scores\n",
        "sample_t5['ROUGEL_cand_title_ref_title'] = cand_title_ref_title_rougeL_f1_scores\n",
        "\n",
        "sample_t5['ROUGE1_cand_title_ref_post'] = cand_title_ref_post_rouge1_f1_scores\n",
        "sample_t5['ROUGE2_cand_title_ref_post'] = cand_title_ref_post_rouge2_f1_scores\n",
        "sample_t5['ROUGEL_cand_title_ref_post'] = cand_title_ref_post_rougeL_f1_scores\n",
        "\n",
        "sample_t5['ROUGE1_ref_title_ref_post'] = ref_title_ref_post_rouge1_f1_scores\n",
        "sample_t5['ROUGE2_ref_title_ref_post'] = ref_title_ref_post_rouge2_f1_scores\n",
        "sample_t5['ROUGEL_ref_title_ref_post'] = ref_title_ref_post_rougeL_f1_scores\n",
        "\n",
        "# BLEU\n",
        "sample_t5['BLEU_cand_title_ref_title'] = cand_title_ref_title_bleu_scores\n",
        "sample_t5['BLEU_cand_title_ref_post'] = cand_title_ref_post_bleu_scores\n",
        "sample_t5['BLEU_ref_title_ref_post'] = ref_title_ref_post_bleu_scores\n"
      ],
      "metadata": {
        "id": "qzJ9PhBPdRTv"
      },
      "execution_count": 145,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sample_t5.columns"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pmuOgoAz6EA2",
        "outputId": "9b4b810a-b489-42f7-b7f2-b152b13b0f00"
      },
      "execution_count": 146,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['Index_ID', 'ref_post', 'ref_title', 'candidate_title',\n",
              "       'ang_sim_gen_title_ref_post', 'ang_sim_ref_title_ref_post',\n",
              "       'fd_gen_title_ref_post', 'fd_ref_title_ref_post',\n",
              "       'ROUGE1_cand_title_ref_title', 'ROUGE2_cand_title_ref_title',\n",
              "       'ROUGEL_cand_title_ref_title', 'ROUGE1_cand_title_ref_post',\n",
              "       'ROUGE2_cand_title_ref_post', 'ROUGEL_cand_title_ref_post',\n",
              "       'ROUGE1_ref_title_ref_post', 'ROUGE2_ref_title_ref_post',\n",
              "       'ROUGEL_ref_title_ref_post', 'BLEU_cand_title_ref_title',\n",
              "       'BLEU_cand_title_ref_post', 'BLEU_ref_title_ref_post'],\n",
              "      dtype='object')"
            ]
          },
          "metadata": {},
          "execution_count": 146
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sample_t5 = sample_t5.reset_index(drop=True)"
      ],
      "metadata": {
        "id": "G4at9_BR7G1S"
      },
      "execution_count": 147,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Export Results to CSV for human evaluation"
      ],
      "metadata": {
        "id": "a3YaMvPp6oAl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sample_t5.to_csv('drive/My Drive/W266/sample_t5_eval.csv', index=False)"
      ],
      "metadata": {
        "id": "bceU4BOpdjw2"
      },
      "execution_count": 148,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "machine_shape": "hm",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.5"
    },
    "vscode": {
      "interpreter": {
        "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}