Upload flow correction 30%.ipynb

flow correction 30%.ipynb

@@ -0,0 +1,516 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f0f495f5278946bebfcef7f58113879b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "pytorch_model.bin:   0%|          | 0.00/438M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\Isaac\\AppData\\Roaming\\Python\\Python38\\site-packages\\huggingface_hub\\file_download.py:148: UserWarning: `huggingface_hub` cache-system uses symlinks by default to efficiently store duplicated files but your machine does not support them in C:\\Users\\Isaac\\.cache\\huggingface\\hub\\models--textattack--bert-base-uncased-SST-2. Caching files will still work but in a degraded version that might require more space on your disk. This warning can be disabled by setting the `HF_HUB_DISABLE_SYMLINKS_WARNING` environment variable. For more details, see https://huggingface.co/docs/huggingface_hub/how-to-cache#limitations.\n",
+      "To support symlinks on Windows, you either need to activate Developer Mode or to run Python as an administrator. In order to see activate developer mode, see this article: https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development\n",
+      "  warnings.warn(message)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7430033906354f39b753fb46f7113501",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer_config.json:   0%|          | 0.00/48.0 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bce8defec56e4810ba28e42b2d18538e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "vocab.txt:   0%|          | 0.00/232k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a4c13d3d415c4ec8adf87cd6efca5989",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "special_tokens_map.json:   0%|          | 0.00/112 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "textattack: Unknown if model of class <class 'transformers.models.bert.modeling_bert.BertForSequenceClassification'> compatible with goal function <class 'textattack.goal_functions.classification.untargeted_classification.UntargetedClassification'>.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import textattack\n",
+    "import transformers\n",
+    "\n",
+    "# Load model, tokenizer, and model_wrapper\n",
+    "model = transformers.AutoModelForSequenceClassification.from_pretrained(\n",
+    "    \"textattack/bert-base-uncased-SST-2\"\n",
+    ")\n",
+    "tokenizer = transformers.AutoTokenizer.from_pretrained(\n",
+    "    \"textattack/bert-base-uncased-SST-2\"\n",
+    ")\n",
+    "model_wrapper = textattack.models.wrappers.HuggingFaceModelWrapper(model, tokenizer)\n",
+    "\n",
+    "# Construct our four components for `Attack`\n",
+    "from textattack.constraints.pre_transformation import (\n",
+    "    RepeatModification,\n",
+    "    StopwordModification,\n",
+    ")\n",
+    "from textattack.constraints.semantics import WordEmbeddingDistance\n",
+    "from textattack.transformations import WordSwapEmbedding\n",
+    "from textattack.search_methods import GreedyWordSwapWIR\n",
+    "\n",
+    "goal_function = textattack.goal_functions.UntargetedClassification(model_wrapper)\n",
+    "constraints = [\n",
+    "    RepeatModification(),\n",
+    "    StopwordModification(),\n",
+    "    WordEmbeddingDistance(min_cos_sim=0.9),\n",
+    "]\n",
+    "transformation = WordSwapEmbedding(max_candidates=50)\n",
+    "# weighted-saliency\n",
+    "search_method = GreedyWordSwapWIR(wir_method=\"weighted-saliency\")\n",
+    "\n",
+    "# Construct the actual attack\n",
+    "attack = textattack.Attack(goal_function, constraints, transformation, search_method)\n",
+    "attack.cuda_()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "results = pd.read_csv(\"ag-news_pwws_bert.csv\")\n",
+    "#results.columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "\"\"\"successful_perturbed_texts = results.loc[results[\"result_type\"] == \"Successful\", \"perturbed_text\"].tolist()\n",
+    "failed_perturbed_texts = results.loc[results[\"result_type\"] == \"Failed\", \"perturbed_text\"].tolist()\n",
+    "\n",
+    "failed_perturbed_outputs = results.loc[results[\"result_type\"] == \"Failed\", \"perturbed_output\"].tolist()\n",
+    "successful_perturbed_outputs = results.loc[results[\"result_type\"] == \"Successful\", \"original_output\"].tolist()\"\"\"\n",
+    "\n",
+    "\n",
+    "original_texts = results[\"original_text\"].tolist()\n",
+    "perturbed_texts =results[\"adversarial_text\"].tolist() \n",
+    "\n",
+    "original_outputs = results[\"original_class\"].tolist()\n",
+    "perturbed_outputs =results[\"adversarial_class\"].tolist() "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import re\n",
+    "import string\n",
+    "# Clean Text\n",
+    "def remove_brackets(text):\n",
+    "    text = text.replace('[[', '')\n",
+    "    text = text.replace(']]', '')\n",
+    "    return text\n",
+    "\n",
+    "perturbed_texts = [remove_brackets(text) for text in perturbed_texts]\n",
+    "original_texts = [remove_brackets(text) for text in original_texts]\n",
+    "\n",
+    "def clean_text(text):\n",
+    "    pattern = \"[\" + re.escape(string.punctuation) + \"]\"\n",
+    "    cleaned_text = re.sub(pattern, \" \", text)\n",
+    "\n",
+    "    return cleaned_text\n",
+    "\n",
+    "perturbed_texts = [clean_text(text) for text in perturbed_texts]\n",
+    "original_texts = [clean_text(text) for text in original_texts]\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "perturbed_texts = [text.lower() for text in perturbed_texts]\n",
+    "original_texts = [text.lower() for text in original_texts]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from FlowCorrector import Flow_Corrector\n",
+    "\n",
+    "corrector = Flow_Corrector(\n",
+    "    attack,\n",
+    "    word_rank_file=\"en_full_ranked.json\",\n",
+    "    word_freq_file=\"en_full_freq.json\",\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a1241448bb324872a1da1f2b659150c5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/424 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import torch.nn.functional as F\n",
+    "from tqdm.notebook import tqdm_notebook\n",
+    "\n",
+    "victim_model = attack.goal_function.model\n",
+    "\n",
+    "original_classes = [\n",
+    "    torch.argmax(F.softmax(victim_model(original_text), dim=1)).item()\n",
+    "    for original_text in tqdm_notebook(original_texts)\n",
+    "]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d2927a578aa5401796a0c4cd48a11de6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/424 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\Isaac\\anaconda3\\envs\\textattackenv\\lib\\site-packages\\torch\\nn\\modules\\module.py:1117: UserWarning: Using a non-full backward hook when the forward contains multiple autograd Nodes is deprecated and will be removed in future versions. This hook will be missing some grad_input. Please use register_full_backward_hook to get the documented behavior.\n",
+      "  warnings.warn(\"Using a non-full backward hook when the forward contains multiple autograd Nodes \"\n"
+     ]
+    }
+   ],
+   "source": [
+    "\"\"\" 0 :World\n",
+    "    1 : Sports\n",
+    "    2 : Business\n",
+    "    3 : Sci/Tech\"\"\"\n",
+    "\n",
+    "corrected_classes = corrector.correct(perturbed_texts)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def count_matching_classes(original, corrected, perturbed_texts=None):\n",
+    "    if len(original) != len(corrected):\n",
+    "        raise ValueError(\"Arrays must have the same length\")\n",
+    "    hard_samples = []\n",
+    "    easy_samples = []\n",
+    "\n",
+    "    matching_count = 0\n",
+    "\n",
+    "    for i in range(len(corrected)):\n",
+    "        if original[i] == corrected[i]:\n",
+    "            matching_count += 1\n",
+    "            easy_samples.append(perturbed_texts[i])\n",
+    "        elif perturbed_texts != None:\n",
+    "            hard_samples.append(perturbed_texts[i])\n",
+    "\n",
+    "    return matching_count, hard_samples, easy_samples\n",
+    "\n",
+    "\n",
+    "match_, hard_samples, easy_samples = count_matching_classes(\n",
+    "    original_classes, corrected_classes, perturbed_texts\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.6014150943396226"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "match_/424"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"detected_samples_ag_news.txt\", \"w\") as f:\n",
+    "    for sample in easy_samples:\n",
+    "        f.write(sample + \"\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "index_order = wir_gradient(attack, goal_function.model, detected_text)\n",
+    "\n",
+    "# The prblm is tht it exists many rare words with freq from 1 to 10\n",
+    "\n",
+    "# freq_thershold = len(word_ranked_frequence) * 0.01\n",
+    "\n",
+    "# for now i sugest to take the words taht have freq > freq_thershold (200 in paper)\n",
+    "\n",
+    "freq_thershold = 2000\n",
+    "\n",
+    "index_order_1 = [\n",
+    "    idx\n",
+    "    for idx in index_order\n",
+    "\n",
+    "    if detected_text.words[idx] in word_frequence.keys()\n",
+    "\n",
+    "    and word_frequence[detected_text.words[idx]] < freq_thershold\n",
+    "\n",
+    "]\n",
+    "\n",
+    "print(\n",
+    "\n",
+    "    f\"from {len(index_order)} ranked word it remain only {len(index_order_1)} within frequency theshold = {freq_thershold} \"\n",
+    "\n",
+    ")\n",
+    "\n",
+    "# or we take the lowest 30% in the important ranked words ?\n",
+    "index_order = index_order[:int(len(index_order) * 0.3)]\n",
+    "index_order_ = {\n",
+    "    idx : word_ranked_frequence[detected_text.words[idx]]\n",
+    "    for idx in index_order\n",
+    "    if detected_text.words[idx] in word_ranked_frequence.keys()\n",
+    "}\n",
+    "\n",
+    "index_order_ = sorted(index_order_.items(), key=lambda item: item[1], reverse=False)\n",
+    "lowest = 0.15\n",
+    "index_order_ = [idx[0]for idx in index_order_][:int(len(index_order) * lowest)]\n",
+    "\n",
+    "print(f\"from {len(index_order)} ranked word {len(index_order_)} word represent {lowest * 100}% with the lowest frequency\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def remove_brackets(text):\n",
+    "    text = text.replace('[[', '')\n",
+    "    text = text.replace(']]', '')\n",
+    "    return text\n",
+    "\n",
+    "text = \"Fears for T [[percent]] pension after [[debate]] [[Syndicates]] [[portrayal]] [[worker]] at Turner   Newall say they are 'disappointed' after [[chatter]] with [[bereaved]] [[parenting]] [[corporations]] [[Canada]] Mogul.\" \n",
+    "print(remove_brackets(text))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "with open('en_full.txt', 'r') as f:\n",
+    "    lines = f.readlines()\n",
+    "\n",
+    "\n",
+    "freq_dict = {line.split()[0]: int(line.split()[1]) for line in lines}\n",
+    "\n",
+    "\n",
+    "sorted_dict = dict(sorted(freq_dict.items(), key=lambda item: item[1], reverse=True))\n",
+    "\n",
+    "\n",
+    "ranked_dict = {word: freq for word, freq in sorted_dict.items() }\n",
+    "\n",
+    "\n",
+    "with open('en_full_freq.json', 'w') as f:\n",
+    "    json.dump(ranked_dict, f)\n",
+    "\n",
+    "print(\"The word frequencies have been successfully ranked and saved to ranked_freq.json file.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "# Assuming these are your accuracy and loss values\n",
+    "accuracy = [0.6, 0.65, 0.7, 0.72, 0.74, 0.76, 0.77, 0.78, 0.81, 0.83, 0.83, 0.87,0.88, 0.91, 0.915, 0.924, 0.934, 0.954, 0.957, 0.959, 0.96, 0.959, 0.958, 0.956, 0.957, 0.958]\n",
+    "loss = [0.8, 0.5, 0.45, 0.30, 0.28, 0.22, 0.19, 0.18, 0.18, 0.15, 0.15, 0.15,  0.12, 0.13, 0.11, 0.09, 0.086, 0.083, 0.082, 0.077, 0.076, 0.074, 0.073, 0.072, 0.070, 0.069]\n",
+    "\n",
+    "epochs = range(1, len(accuracy) + 1)\n",
+    "\n",
+    "plt.figure(figsize=(12, 5))\n",
+    "\n",
+    "# Plotting accuracy\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.plot(epochs, accuracy, 'bo', label='Training acc')\n",
+    "plt.title('Training accuracy')\n",
+    "plt.xlabel('Epochs')\n",
+    "plt.ylabel('Accuracy')\n",
+    "plt.legend()\n",
+    "\n",
+    "# Plotting loss\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
+    "plt.title('Training loss')\n",
+    "plt.xlabel('Epochs')\n",
+    "plt.ylabel('Loss')\n",
+    "plt.legend()\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "plt.savefig(\"accuracy loss.pdf\")\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "textattackenv",
+   "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.8.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}