classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Normal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from transformers import AutoTokenizer, XLMRobertaForSequenceClassification\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained('uitnlp/visobert')\n",
    "model = XLMRobertaForSequenceClassification.from_pretrained('/home4/bachpt/text_classification/Visobert/saved_checkpoints/checkpoint-50170')\n",
    "model.eval()\n",
    "model.to('cuda')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import torch\n",
    "# from transformers import AutoTokenizer, RobertaForSequenceClassification\n",
    "\n",
    "# tokenizer = AutoTokenizer.from_pretrained('vinai/phobert-base-v2')\n",
    "# model = RobertaForSequenceClassification.from_pretrained('/home4/bachpt/text_classification/phobert/saved_checkpoints/checkpoint-50170')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "data = pd.read_csv('toxic_test.csv')\n",
    "data['result'] = ''\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "logits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.config.id2label = {0: 'normal', 1: 'negative'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.config.id2label[predicted_class_id]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[5.1965e-06, 9.9999e-01]], device='cuda:0')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Nope'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test individual sentences\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# inputs = tokenizer(\"những người nào xây dựng nên chatbot này\", return_tensors=\"pt\", truncation=True, max_length=256).to('cuda')\n",
    "inputs = tokenizer(\"cái đám mất_dạy bắc kì thì hay quá gọi họ là cái gì hả bạn?\",\n",
    "                    return_tensors=\"pt\", truncation=True, max_length=512).to('cuda')\n",
    "\n",
    "with torch.no_grad():\n",
    "    logits = model(**inputs).logits\n",
    "\n",
    "predicted_class_id = logits.argmax().item()\n",
    "softmax_values = F.softmax(logits, dim=1)\n",
    "print(softmax_values)\n",
    "\n",
    "# if predicted_class_id == 1:        \n",
    "        # if softmax_values[0][1] < 0.7:\n",
    "            # predicted_class_id = 0\n",
    "\n",
    "# print(logits)\n",
    "model.config.id2label = {0: 'Yeah', 1: 'Nope'}\n",
    "model.config.id2label[predicted_class_id]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Viso save the result for test set\n",
    "# frozen = 0.04906 (CPU), 0.0084 (GPU)\n",
    "# unfrozen = 0.0507 (CPU), 0.00805 (GPU)\n",
    "\n",
    "import torch\n",
    "# import time\n",
    "from transformers import AutoTokenizer, XLMRobertaForSequenceClassification\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained('uitnlp/visobert')\n",
    "model = XLMRobertaForSequenceClassification.from_pretrained('/home4/bachpt/text_classification/Visobert/saved_checkpoints/checkpoint-50170')\n",
    "\n",
    "model.cuda()\n",
    "model.eval()\n",
    "\n",
    "import pandas as pd\n",
    "data = pd.read_csv('/home4/bachpt/text_classification/mixed_test_lowered_shuffled.csv')\n",
    "data['predicted label'] = ''\n",
    "data['softmax'] = ''\n",
    "\n",
    "import torch.nn.functional as F\n",
    "\n",
    "data_text = data['text']\n",
    "# total_time = 0\n",
    "predictions = []\n",
    "confidences = []\n",
    "for datum in data_text:\n",
    "    inputs = tokenizer(datum, return_tensors=\"pt\", truncation=True, max_length=512).to('cuda')\n",
    "    with torch.no_grad():\n",
    "        # start_time = time.time()\n",
    "        logits = model(**inputs).logits\n",
    "        # end_time = time.time()\n",
    "\n",
    "    predicted_class_id = logits.argmax().item()\n",
    "    # softmax_value = F.softmax(logits, dim=1)\n",
    "    \n",
    "    # if predicted_class_id == 1:\n",
    "        # if softmax_values[0][1] < 0.7:\n",
    "            # predicted_class_id = 0\n",
    "\n",
    "    # Save the predicted_class_id to the column result\n",
    "    predictions.append(predicted_class_id)\n",
    "    # confidences.append(softmax_value)\n",
    "    # inference_time = end_time - start_time\n",
    "    # total_time += inference_time\n",
    "\n",
    "data['predicted label'] = predictions\n",
    "# data['softmax'] = confidences\n",
    "# average_time = total_time / len(data_text)\n",
    "# print(\"Average Inference Time per Sample:\", average_time)\n",
    "data.to_csv('Viso_mixed_test_result_lowered_shuffled.csv', index = False)\n",
    "\n",
    "# To get GPU usage\n",
    "# Uncomment the following lines if you are using GPU\n",
    "# import torch.cuda as cuda\n",
    "# gpu_usage = cuda.max_memory_allocated()\n",
    "# print(\"GPU Memory Usage:\", gpu_usage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Inference Time per Sample: 0.007972929934917142\n"
     ]
    }
   ],
   "source": [
    "# Pho save the result for test set\n",
    "# no segment = 0.0496 (CPU), 0.0084 (GPU)\n",
    "# segment = 0.0433(CPU), 0.0082 (GPU)\n",
    "\n",
    "import torch\n",
    "from transformers import AutoTokenizer, RobertaForSequenceClassification\n",
    "import time\n",
    "# import torch.nn.functional as F\n",
    "import pandas as pd\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained('vinai/phobert-base-v2')\n",
    "model = RobertaForSequenceClassification.from_pretrained('/home4/bachpt/text_classification/Phobert_segment/saved_checkpoints/checkpoint-50170')\n",
    "\n",
    "model.cuda()\n",
    "model.eval()\n",
    "\n",
    "data = pd.read_csv('/home4/bachpt/text_classification/mixed_test_lowered_shuffled_segmented.csv')\n",
    "\n",
    "data_text = data['text']\n",
    "total_time = 0\n",
    "predictions = []\n",
    "for datum in data_text:\n",
    "    inputs = tokenizer(datum, return_tensors=\"pt\", truncation=True, max_length=256).to('cuda')\n",
    "    with torch.no_grad():\n",
    "        start_time = time.time()\n",
    "        logits = model(**inputs).logits\n",
    "        end_time = time.time()\n",
    "\n",
    "    predicted_class_id = logits.argmax().item()\n",
    "    # softmax_values = F.softmax(logits, dim=1)\n",
    "    \n",
    "    # if predicted_class_id == 1:\n",
    "        # if softmax_values[0][1] < 0.7:\n",
    "            # predicted_class_id = 0\n",
    "\n",
    "    # Save the predicted_class_id to the column result\n",
    "    predictions.append(predicted_class_id)\n",
    "    inference_time = end_time - start_time\n",
    "    total_time += inference_time\n",
    "data['predicted label'] = predictions\n",
    "average_time = total_time / len(data_text)\n",
    "print(\"Average Inference Time per Sample:\", average_time)\n",
    "data.to_csv('Frozen_Pho_mixed_segmented_test_result_lowered_shuffled.csv', index = False)\n",
    "\n",
    "# To get GPU usage\n",
    "# Uncomment the following lines if you are using GPU\n",
    "# import torch.cuda as cuda\n",
    "# gpu_usage = cuda.max_memory_allocated()\n",
    "# print(\"GPU Memory Usage:\", gpu_usage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RobertaForSequenceClassification(\n",
       "  (roberta): RobertaModel(\n",
       "    (embeddings): RobertaEmbeddings(\n",
       "      (word_embeddings): Embedding(64001, 768, padding_idx=1)\n",
       "      (position_embeddings): Embedding(258, 768, padding_idx=1)\n",
       "      (token_type_embeddings): Embedding(1, 768)\n",
       "      (LayerNorm): LayerNorm((768,), eps=1e-05, elementwise_affine=True)\n",
       "      (dropout): Dropout(p=0.1, inplace=False)\n",
       "    )\n",
       "    (encoder): RobertaEncoder(\n",
       "      (layer): ModuleList(\n",
       "        (0-11): 12 x RobertaLayer(\n",
       "          (attention): RobertaAttention(\n",
       "            (self): RobertaSelfAttention(\n",
       "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "            (output): RobertaSelfOutput(\n",
       "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (LayerNorm): LayerNorm((768,), eps=1e-05, elementwise_affine=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (intermediate): RobertaIntermediate(\n",
       "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
       "            (intermediate_act_fn): GELUActivation()\n",
       "          )\n",
       "          (output): RobertaOutput(\n",
       "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (LayerNorm): LayerNorm((768,), eps=1e-05, elementwise_affine=True)\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "          )\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (classifier): RobertaClassificationHead(\n",
       "    (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "    (dropout): Dropout(p=0.1, inplace=False)\n",
       "    (out_proj): Linear(in_features=768, out_features=2, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "from transformers import AutoTokenizer, RobertaForSequenceClassification\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained('vinai/phobert-base-v2')\n",
    "model = RobertaForSequenceClassification.from_pretrained('/home4/bachpt/text_classification/Phobert_segment/saved_checkpoints/checkpoint-50170')\n",
    "model.cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ONNX"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test single sentence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert to ONNX format\n",
    "# !optimum-cli export onnx --model /home4/bachpt/text_classification/Visobert/saved_checkpoints/checkpoint-50170 --monolith --task text-classification model.onnx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import onnx\n",
    "onnx_model = onnx.load('/home4/bachpt/text_classification/ONNX_Viso/model.onnx/model.onnx')\n",
    "onnx.checker.check_model(onnx_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from optimum.pipelines import pipeline\n",
    "classifier = pipeline(task = 'text-classification', model = model, tokenizer = tokenizer, accelerator = 'ort')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier('nơi nào có thể xem biểu mẫu học tập')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import AutoTokenizer\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained('uitnlp/visobert')\n",
    "tokenizer.save_pretrained('/home4/bachpt/text_classification/ONNX_Viso/model.onnx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# onnxruntime\n",
    "# numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import AutoTokenizer\n",
    "from optimum.onnxruntime import ORTModelForSequenceClassification\n",
    "from optimum.pipelines import pipeline\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained('/home4/bachpt/text_classification/ONNX_Viso/model')\n",
    "\n",
    "# Loading directly an ONNX model from a model repo.\n",
    "model = ORTModelForSequenceClassification.from_pretrained(\"/home4/bachpt/text_classification/ONNX_Viso/model.onnx\")\n",
    "\n",
    "onnx_cl = pipeline(\"text-classification\", model=model, tokenizer=tokenizer, accelerator=\"ort\")\n",
    "\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "data = pd.read_csv('/home4/bachpt/text_classification/mixed_test_lowered_shuffled.csv')\n",
    "data['predicted label'] = ''\n",
    "data_text = data['text']\n",
    "predictions = []\n",
    "\n",
    "for datum in tqdm(data_text):\n",
    "    pred = onnx_cl(datum)\n",
    "    predictions.append(pred)\n",
    "\n",
    "data['predicted label'] = predictions\n",
    "data.to_csv('Viso_ONNX_mixed_test_result_lowered_shuffled.csv', index = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model.cuda()\n",
    "# model.eval()\n",
    "import time\n",
    "\n",
    "import pandas as pd\n",
    "data = pd.read_csv('/home4/bachpt/text_classification/mixed_test_lowered_shuffled.csv')\n",
    "data['predicted label'] = ''\n",
    "\n",
    "# import torch.nn.functional as F\n",
    "\n",
    "data_text = data['text']\n",
    "total_time = 0\n",
    "predictions = []\n",
    "for datum in data_text:\n",
    "    inputs = tokenizer(datum, return_tensors=\"pt\", truncation=True, max_length=512)#.to('cuda')\n",
    "    with torch.no_grad():\n",
    "        start_time = time.time()\n",
    "        logits = model(**inputs).logits\n",
    "        end_time = time.time()\n",
    "\n",
    "    predicted_class_id = logits.argmax().item()\n",
    "    # softmax_values = F.softmax(logits, dim=1)\n",
    "    \n",
    "    # if predicted_class_id == 1:\n",
    "        # if softmax_values[0][1] < 0.7:\n",
    "            # predicted_class_id = 0\n",
    "\n",
    "    # Save the predicted_class_id to the column result\n",
    "    predictions.append(predicted_class_id)\n",
    "    inference_time = end_time - start_time\n",
    "    total_time += inference_time\n",
    "data['predicted label'] = predictions\n",
    "average_time = total_time / len(data_text)\n",
    "print(\"Average Inference Time per Sample:\", average_time)\n",
    "data.to_csv('Viso_ONNX_mixed_test_result_lowered_shuffled.csv', index = False)\n",
    "\n",
    "# To get GPU usage\n",
    "# Uncomment the following lines if you are using GPU\n",
    "# import torch.cuda as cuda\n",
    "# gpu_usage = cuda.max_memory_allocated()\n",
    "# print(\"GPU Memory Usage:\", gpu_usage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "llm",
   "language": "python",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}