04_classification_comparison.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VHClECUkHcPp",
        "outputId": "5b33ed1c-c8b3-42a8-a450-9111823f7708"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Collecting fasttext==0.9.2\n",
            "  Downloading fasttext-0.9.2.tar.gz (68 kB)\n",
            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/68.8 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━\u001b[0m \u001b[32m61.4/68.8 kB\u001b[0m \u001b[31m2.0 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m68.8/68.8 kB\u001b[0m \u001b[31m1.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Collecting pybind11>=2.2 (from fasttext==0.9.2)\n",
            "  Using cached pybind11-2.11.1-py3-none-any.whl (227 kB)\n",
            "Requirement already satisfied: setuptools>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from fasttext==0.9.2) (67.7.2)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from fasttext==0.9.2) (1.23.5)\n",
            "Building wheels for collected packages: fasttext\n",
            "  Building wheel for fasttext (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for fasttext: filename=fasttext-0.9.2-cp310-cp310-linux_x86_64.whl size=4199774 sha256=a2abeb1f730b352409085af8f4b7dc464bdeddaa985c73b40a9bdbad5d9a8a67\n",
            "  Stored in directory: /root/.cache/pip/wheels/a5/13/75/f811c84a8ab36eedbaef977a6a58a98990e8e0f1967f98f394\n",
            "Successfully built fasttext\n",
            "Installing collected packages: pybind11, fasttext\n",
            "Successfully installed fasttext-0.9.2 pybind11-2.11.1\n",
            "Requirement already satisfied: gensim==4.3.2 in /usr/local/lib/python3.10/dist-packages (4.3.2)\n",
            "Requirement already satisfied: numpy>=1.18.5 in /usr/local/lib/python3.10/dist-packages (from gensim==4.3.2) (1.23.5)\n",
            "Requirement already satisfied: scipy>=1.7.0 in /usr/local/lib/python3.10/dist-packages (from gensim==4.3.2) (1.11.4)\n",
            "Requirement already satisfied: smart-open>=1.8.1 in /usr/local/lib/python3.10/dist-packages (from gensim==4.3.2) (6.4.0)\n"
          ]
        }
      ],
      "source": [
        "%pip install fasttext==0.9.2\n",
        "%pip install gensim==4.3.2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wXQ8qh_3HcPq"
      },
      "source": [
        "### Fasttext效果测试"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9LRcwrCvHcPr",
        "outputId": "df76731d-ff58-43c9-86f0-34b1834045f8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "--2023-12-31 04:59:44--  https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.en.300.bin.gz\n",
            "Resolving dl.fbaipublicfiles.com (dl.fbaipublicfiles.com)... 13.35.7.128, 13.35.7.50, 13.35.7.38, ...\n",
            "Connecting to dl.fbaipublicfiles.com (dl.fbaipublicfiles.com)|13.35.7.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 4503593528 (4.2G) [application/octet-stream]\n",
            "Saving to: ‘cc.en.300.bin.gz’\n",
            "\n",
            "cc.en.300.bin.gz    100%[===================>]   4.19G   155MB/s    in 28s     \n",
            "\n",
            "2023-12-31 05:00:12 (151 MB/s) - ‘cc.en.300.bin.gz’ saved [4503593528/4503593528]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "!wget https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.en.300.bin.gz"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "6SiTtR8QHcPr"
      },
      "outputs": [],
      "source": [
        "!gunzip ./cc.en.300.bin.gz"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "5ykoNmB7HcPr"
      },
      "outputs": [],
      "source": [
        "import gensim\n",
        "import numpy as np\n",
        "# Load the FastText pre-trained model\n",
        "model = gensim.models.fasttext.load_facebook_model('cc.en.300.bin')\n",
        "\n",
        "def get_fasttext_vector(line):\n",
        "    vec = np.zeros(300) # Initialize an empty 300-dimensional vector\n",
        "    for word in line.split():\n",
        "        vec += model.wv[word]\n",
        "    vec /= len(line.split()) # Take the average over all words in the line\n",
        "    return vec"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ANbdHEF9HcPr",
        "outputId": "56a3313c-7558-4c66-ee91-b0e706dbe04b"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:gensim.models.fasttext:could not extract any ngrams from '#2', returning origin vector\n"
          ]
        }
      ],
      "source": [
        "positive_text = \"\"\"Wanted to save some to bring to my Chicago family but my North Carolina family ate all 4 boxes before I could pack. These are excellent...could serve to anyone\"\"\"\n",
        "negative_text = \"\"\"First, these should be called Mac - Coconut bars, as Coconut is the #2 ingredient and Mango is #3.  Second, lots of people don't like coconut.  I happen to be allergic to it.  Word to Amazon that if you want happy customers to make things like this more prominent.  Thanks.\"\"\"\n",
        "\n",
        "positive_example_in_fasttext = get_fasttext_vector(positive_text)\n",
        "negative_example_in_fasttext = get_fasttext_vector(negative_text)\n",
        "\n",
        "positive_review_in_fasttext = get_fasttext_vector(\"An Amazon review with a positive sentiment.\")\n",
        "negative_review_in_fasttext = get_fasttext_vector('An Amazon review with a negative sentiment.')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HsW-HHcPHcPs",
        "outputId": "283313cf-5c5e-4eb0-f63f-f99de1d2aede"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Fasttext好评例子的评分 : -0.000544\n",
            "Fasttext差评例子的评分 : 0.000369\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "\n",
        "def cosine_similarity(vector_a, vector_b):\n",
        "  dot_product = np.dot(vector_a, vector_b)\n",
        "  norm_a = np.linalg.norm(vector_a)\n",
        "  norm_b = np.linalg.norm(vector_b)\n",
        "  epsilon = 1e-10\n",
        "  cosine_similarity = dot_product / (norm_a * norm_b + epsilon)\n",
        "  return cosine_similarity\n",
        "\n",
        "def get_fasttext_score(sample_embedding):\n",
        "  return cosine_similarity(sample_embedding, positive_review_in_fasttext) - cosine_similarity(sample_embedding, negative_review_in_fasttext)\n",
        "\n",
        "positive_score = get_fasttext_score(positive_example_in_fasttext)\n",
        "negative_score = get_fasttext_score(negative_example_in_fasttext)\n",
        "\n",
        "print(\"Fasttext好评例子的评分 : %f\" % (positive_score))\n",
        "print(\"Fasttext差评例子的评分 : %f\" % (negative_score))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mQfzw023HcPs"
      },
      "source": [
        "### T5效果测试"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wPD6fbeSHcPs",
        "outputId": "2f98b7bd-e3c8-494a-9715-f03d51af8492"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: transformers in /usr/local/lib/python3.10/dist-packages (4.35.2)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from transformers) (3.13.1)\n",
            "Requirement already satisfied: huggingface-hub<1.0,>=0.16.4 in /usr/local/lib/python3.10/dist-packages (from transformers) (0.19.4)\n",
            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from transformers) (1.23.5)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from transformers) (23.2)\n",
            "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from transformers) (6.0.1)\n",
            "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.10/dist-packages (from transformers) (2023.6.3)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from transformers) (2.31.0)\n",
            "Requirement already satisfied: tokenizers<0.19,>=0.14 in /usr/local/lib/python3.10/dist-packages (from transformers) (0.15.0)\n",
            "Requirement already satisfied: safetensors>=0.3.1 in /usr/local/lib/python3.10/dist-packages (from transformers) (0.4.1)\n",
            "Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.10/dist-packages (from transformers) (4.66.1)\n",
            "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.16.4->transformers) (2023.6.0)\n",
            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.16.4->transformers) (4.5.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (3.6)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (2.0.7)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (2023.11.17)\n",
            "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (2.1.0+cu121)\n",
            "Requirement already satisfied: torchvision in /usr/local/lib/python3.10/dist-packages (0.16.0+cu121)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch) (3.13.1)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch) (4.5.0)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch) (1.12)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch) (3.2.1)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch) (3.1.2)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch) (2023.6.0)\n",
            "Requirement already satisfied: triton==2.1.0 in /usr/local/lib/python3.10/dist-packages (from torch) (2.1.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from torchvision) (1.23.5)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from torchvision) (2.31.0)\n",
            "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.10/dist-packages (from torchvision) (9.4.0)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch) (2.1.3)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision) (3.6)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision) (2.0.7)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision) (2023.11.17)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch) (1.3.0)\n",
            "Collecting sentencepiece\n",
            "  Downloading sentencepiece-0.1.99-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.3 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m8.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: sentencepiece\n",
            "Successfully installed sentencepiece-0.1.99\n"
          ]
        }
      ],
      "source": [
        "# install transformers if required\n",
        "%pip install transformers\n",
        "%pip install torch torchvision\n",
        "%pip install sentencepiece==0.1.99"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "_G0uqiyBHcPs"
      },
      "outputs": [],
      "source": [
        "from transformers import AutoTokenizer, AutoModel\n",
        "import torch\n",
        "\n",
        "# load the T5 tokenizer and model\n",
        "tokenizer = AutoTokenizer.from_pretrained('t5-small', model_max_length=512)\n",
        "model = AutoModel.from_pretrained('t5-small')\n",
        "\n",
        "# set the model to evaluation mode\n",
        "model.eval()\n",
        "\n",
        "# encode the input sentence\n",
        "def get_t5_vector(line):\n",
        "    input_ids = tokenizer.encode(line, return_tensors='pt', max_length=512, truncation=True)\n",
        "    # generate the vector representation\n",
        "    with torch.no_grad():\n",
        "        outputs = model.encoder(input_ids=input_ids)\n",
        "        vector = outputs.last_hidden_state.mean(dim=1)\n",
        "    return vector[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T59zGw5OHcPs",
        "outputId": "27d80c12-c0fe-4c78-f9f8-c5c2e4f91869"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "T5好评例子的评分 : -0.010294\n",
            "T5差评例子的评分 : -0.008990\n"
          ]
        }
      ],
      "source": [
        "positive_review_in_t5 = get_t5_vector(\"An Amazon review with a positive sentiment.\")\n",
        "negative_review_in_t5 = get_t5_vector('An Amazon review with a negative sentiment.')\n",
        "\n",
        "def test_t5():\n",
        "  positive_example_in_t5 = get_t5_vector(positive_text)\n",
        "  negative_example_in_t5 = get_t5_vector(negative_text)\n",
        "\n",
        "  def get_t5_score(sample_embedding):\n",
        "    return cosine_similarity(sample_embedding, positive_review_in_t5) - cosine_similarity(sample_embedding, negative_review_in_t5)\n",
        "\n",
        "  positive_score = get_t5_score(positive_example_in_t5)\n",
        "  negative_score = get_t5_score(negative_example_in_t5)\n",
        "\n",
        "  print(\"T5好评例子的评分 : %f\" % (positive_score))\n",
        "  print(\"T5差评例子的评分 : %f\" % (negative_score))\n",
        "\n",
        "test_t5()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gxOy84BAHcPs",
        "outputId": "6d2aafab-7da5-41b7-9969-38f87d97504a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "T5好评例子的评分 : 0.010347\n",
            "T5差评例子的评分 : -0.023935\n"
          ]
        }
      ],
      "source": [
        "tokenizer = AutoTokenizer.from_pretrained('t5-base', model_max_length=512)\n",
        "model = AutoModel.from_pretrained('t5-base')\n",
        "\n",
        "# set the model to evaluation mode\n",
        "model.eval()\n",
        "\n",
        "# encode the input sentence\n",
        "def get_t5_vector(line):\n",
        "    input_ids = tokenizer.encode(line, return_tensors='pt', max_length=512, truncation=True)\n",
        "    # generate the vector representation\n",
        "    with torch.no_grad():\n",
        "        outputs = model.encoder(input_ids=input_ids)\n",
        "        vector = outputs.last_hidden_state.mean(dim=1)\n",
        "    return vector[0]\n",
        "\n",
        "positive_review_in_t5 = get_t5_vector(\"An Amazon review with a positive sentiment.\")\n",
        "negative_review_in_t5 = get_t5_vector('An Amazon review with a negative sentiment.')\n",
        "\n",
        "test_t5()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ITMekdfcHcPs",
        "outputId": "321fb40f-672d-4425-9f2b-f0ce4016bb20"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "<ipython-input-21-1d22d9d69b5b>:12: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  df[\"sentiment\"] = df.Score.replace({1: \"negative\", 2: \"negative\", 4: \"positive\", 5: \"positive\"})\n"
          ]
        }
      ],
      "source": [
        "import pandas as pd\n",
        "from sklearn.metrics import classification_report\n",
        "\n",
        "datafile_path = \"data/fine_food_reviews_with_embeddings_1k.csv\"\n",
        "\n",
        "df = pd.read_csv(datafile_path)\n",
        "\n",
        "\n",
        "df[\"t5_embedding\"] = df.Text.apply(get_t5_vector)\n",
        "# convert 5-star rating to binary sentiment\n",
        "df = df[df.Score != 3]\n",
        "df[\"sentiment\"] = df.Score.replace({1: \"negative\", 2: \"negative\", 4: \"positive\", 5: \"positive\"})"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 628
        },
        "id": "YDubfmifHcPs",
        "outputId": "fadf2451-e52d-4da0-ac3b-e508927d050e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "    negative       0.60      0.90      0.72       136\n",
            "    positive       0.98      0.90      0.94       789\n",
            "\n",
            "    accuracy                           0.90       925\n",
            "   macro avg       0.79      0.90      0.83       925\n",
            "weighted avg       0.93      0.90      0.91       925\n",
            "\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from sklearn.metrics import PrecisionRecallDisplay\n",
        "\n",
        "def evaluate_embeddings_approach():\n",
        "    def label_score(review_embedding):\n",
        "        return cosine_similarity(review_embedding, positive_review_in_t5) - cosine_similarity(review_embedding, negative_review_in_t5)\n",
        "\n",
        "    probas = df[\"t5_embedding\"].apply(lambda x: label_score(x))\n",
        "    preds = probas.apply(lambda x: 'positive' if x>0 else 'negative')\n",
        "\n",
        "    report = classification_report(df.sentiment, preds)\n",
        "    print(report)\n",
        "\n",
        "    display = PrecisionRecallDisplay.from_predictions(df.sentiment, probas, pos_label='positive')\n",
        "    _ = display.ax_.set_title(\"2-class Precision-Recall curve\")\n",
        "\n",
        "evaluate_embeddings_approach()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rimAixIhTAWt"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "V100",
      "machine_shape": "hm",
      "provenance": []
    },
    "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.10.13"
    },
    "vscode": {
      "interpreter": {
        "hash": "8114e84f04cf14e493992e1b725447accf84073d5ec18e7063d492738bf032cb"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}