train.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Detect news duplicates\n",
    "## Prepare training data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import time\n",
    "import nltk.data\n",
    "import nltk\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to\n",
      "[nltk_data]     C:\\Users\\vslay\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n"
     ]
    }
   ],
   "source": [
    "nltk.download('punkt')\n",
    "sent_detector = nltk.data.load('tokenizers/punkt/english.pickle')    \n",
    "\n",
    "def truncate_text(text:str, size=512) -> str:\n",
    "    sentences = sent_detector.tokenize(text.strip())\n",
    "    for i in range(len(sentences)+1):\n",
    "        if len(' '.join(sentences[:i])) > size:\n",
    "            return ' '.join(sentences[:max(i-1, 1)])\n",
    "    return text\n",
    "\n",
    "text = '''\n",
    "Punkt knows that the periods in Mr. Smith and Johann S. Bach\n",
    "do not mark sentence boundaries.  And sometimes sentences\n",
    "can start with non-capitalized words.  i is a good variable\n",
    "name.\n",
    "'''\n",
    "\n",
    "assert 'Punkt knows that the periods in Mr. Smith and Johann S. ' \\\n",
    "       'Bach\\ndo not mark sentence boundaries. And sometimes sentences\\ncan ' \\\n",
    "       'start with non-capitalized words.' == truncate_text(text, 155)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Load and clean training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\vslay\\Anaconda3\\lib\\site-packages\\IPython\\core\\interactiveshell.py:3146: DtypeWarning: Columns (8) have mixed types.Specify dtype option on import or set low_memory=False.\n",
      "  has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n",
      "<ipython-input-8-f972659f867f>: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_news['topics'] = df_news['topics'].fillna('').apply(lambda v: set(v.split(',')))\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "def clean_data(df_news):\n",
    "    df_news.index = df_news.index.rename('datetime')\n",
    "    df_news = df_news.rename(columns={'related': 'topics'})\n",
    "    df_news = df_news[df_news['lang'] == 'en'][['headline', 'summary', 'source', 'topics']].drop_duplicates()\n",
    "\n",
    "    bad_headline = df_news.groupby('headline').count().query('source > 3').index\n",
    "    bad_summary = df_news.groupby('summary').count().query('source > 3').index\n",
    "    df_news = df_news[~df_news['summary'].isin(bad_summary) & ~df_news['headline'].isin(bad_headline)]\n",
    "\n",
    "    df_news['topics'] = df_news['topics'].fillna('').apply(lambda v: set(v.split(',')))\n",
    "    df_news = df_news[~df_news['summary'].str.startswith('http')]\n",
    "    return df_news\n",
    "\n",
    "df_news = pd.read_csv('data/news.csv.tgz', compression='gzip', index_col='news.csv', parse_dates=True)\n",
    "df_news = clean_data(df_news)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "Generating negative samples:   0%|          | 0/1000 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated 1000 positive samples\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated 994 negative samples\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    },
    {
     "data": {
      "text/html": [
       "<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>headline</th>\n",
       "      <th>summary</th>\n",
       "      <th>topics</th>\n",
       "      <th>labels</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Lehman, WorldCom And Now PG&amp;E: The \"Failing An...</td>\n",
       "      <td>One week ago when we wrote that with PG&amp;E faci...</td>\n",
       "      <td>{BAC}</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Google Moved $23 Billion To Bermuda Tax Haven ...</td>\n",
       "      <td>Qualcomm’s revenue is expected to decline for ...</td>\n",
       "      <td>{AAPL}</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Russia launched administrative action against ...</td>\n",
       "      <td>Watch Live: Yellow Vests Rage For 11th Straigh...</td>\n",
       "      <td>{FB}</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Facebook posted record profit in the fourth qu...</td>\n",
       "      <td>Facebook Reports Record Profit</td>\n",
       "      <td>{FB}</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Analysts Growing Bearish Ahead Of Earnings Fro...</td>\n",
       "      <td>Big banks Bank of America and Goldman Sachs re...</td>\n",
       "      <td>{BAC}</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1989</th>\n",
       "      <td>Zimbabwe is once again at the brink of economi...</td>\n",
       "      <td>Protests Erupt As Zimbabwe Now Has The Most Ex...</td>\n",
       "      <td>{FB}</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1990</th>\n",
       "      <td>The investment manager Parnassus Investments i...</td>\n",
       "      <td>Why a Big Investment Manager Bought Up Microso...</td>\n",
       "      <td>{MSF, MSFT}</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1991</th>\n",
       "      <td>Macron Arrests \"Yellow Vest\" Organizer In Esca...</td>\n",
       "      <td>While this year's now-concluded World Economic...</td>\n",
       "      <td>{FB}</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992</th>\n",
       "      <td>Why Momentum Traded Amazon and Apple for Coca-...</td>\n",
       "      <td>The iShares Edge MSCI USA Momentum Factor ETF ...</td>\n",
       "      <td>{KO}</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1993</th>\n",
       "      <td>House Democrats To Grill Mnuchin Over Russian ...</td>\n",
       "      <td>House Democrats have called on Treasury Secret...</td>\n",
       "      <td>{V}</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1994 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               headline  \\\n",
       "0     Lehman, WorldCom And Now PG&E: The \"Failing An...   \n",
       "1     Google Moved $23 Billion To Bermuda Tax Haven ...   \n",
       "2     Russia launched administrative action against ...   \n",
       "3     Facebook posted record profit in the fourth qu...   \n",
       "4     Analysts Growing Bearish Ahead Of Earnings Fro...   \n",
       "...                                                 ...   \n",
       "1989  Zimbabwe is once again at the brink of economi...   \n",
       "1990  The investment manager Parnassus Investments i...   \n",
       "1991  Macron Arrests \"Yellow Vest\" Organizer In Esca...   \n",
       "1992  Why Momentum Traded Amazon and Apple for Coca-...   \n",
       "1993  House Democrats To Grill Mnuchin Over Russian ...   \n",
       "\n",
       "                                                summary       topics  labels  \n",
       "0     One week ago when we wrote that with PG&E faci...        {BAC}       1  \n",
       "1     Qualcomm’s revenue is expected to decline for ...       {AAPL}       0  \n",
       "2     Watch Live: Yellow Vests Rage For 11th Straigh...         {FB}       0  \n",
       "3                        Facebook Reports Record Profit         {FB}       1  \n",
       "4     Big banks Bank of America and Goldman Sachs re...        {BAC}       1  \n",
       "...                                                 ...          ...     ...  \n",
       "1989  Protests Erupt As Zimbabwe Now Has The Most Ex...         {FB}       1  \n",
       "1990  Why a Big Investment Manager Bought Up Microso...  {MSF, MSFT}       1  \n",
       "1991  While this year's now-concluded World Economic...         {FB}       0  \n",
       "1992  The iShares Edge MSCI USA Momentum Factor ETF ...         {KO}       1  \n",
       "1993  House Democrats have called on Treasury Secret...          {V}       1  \n",
       "\n",
       "[1994 rows x 4 columns]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def gen_news_duplicates_data(\n",
    "        df: pd.DataFrame,\n",
    "        truncate: int=512,\n",
    "        negative_sample_min_time_difference: int=1 * 24 * 3600,\n",
    "        negative_sample_max_time_difference: int=30 * 24 * 3600,\n",
    ") -> pd.DataFrame:\n",
    "    df = df[['headline', 'summary', 'topics']].copy()\n",
    "    df['headline'] = df['headline'].apply(lambda s: truncate_text(s, truncate))\n",
    "    df['summary'] = df['summary'].apply(lambda s: truncate_text(s, truncate))\n",
    "    # positive samples\n",
    "    df_positive = df.sample(frac=1.0).copy()\n",
    "    df_positive['labels'] = 1\n",
    "    df_positive = pd.concat([\n",
    "        df_positive.head(len(df_positive) // 2),\n",
    "        df_positive.tail(len(df_positive) // 2).rename(columns={\n",
    "            'headline': 'summary',\n",
    "            'summary': 'headline'\n",
    "        })\n",
    "    ])\n",
    "    print(f'Generated {len(df_positive)} positive samples')\n",
    "    # negative samples\n",
    "    with tqdm(leave=False, mininterval=1, desc='Generating negative samples', total=len(df_positive)) as progress:\n",
    "        df_negative = []\n",
    "        for _, i1 in df.iterrows():\n",
    "            df_sample = df[\n",
    "                (\n",
    "                    (df.index < i1.name - pd.Timedelta(seconds=negative_sample_min_time_difference)) &\n",
    "                    (df.index > i1.name - pd.Timedelta(seconds=negative_sample_max_time_difference))\n",
    "                ) | (\n",
    "                    (df.index > i1.name + pd.Timedelta(seconds=negative_sample_min_time_difference)) &\n",
    "                    (df.index < i1.name + pd.Timedelta(seconds=negative_sample_max_time_difference))\n",
    "                )\n",
    "            ]\n",
    "            df_sample = df_sample[df_sample.apply(lambda v: len(v['topics'] & i1['topics']) > 0, axis=1)]\n",
    "            if len(df_sample) == 0:\n",
    "                continue\n",
    "            i2 = df_sample.sample().iloc[0]\n",
    "            time_diff = abs((i1.name - i2.name).total_seconds())\n",
    "\n",
    "            if negative_sample_min_time_difference < time_diff < negative_sample_max_time_difference:\n",
    "                df_negative.append({\n",
    "                    'headline': i1['headline'],\n",
    "                    'summary': i2['summary'],\n",
    "                    'topics': i1['topics'] & i2['topics'],\n",
    "                    'labels': 0\n",
    "                })\n",
    "                progress.update(1)\n",
    "    df_negative = pd.DataFrame(df_negative)\n",
    "    df_negative = pd.concat([\n",
    "        df_negative.head(len(df_negative) // 2),\n",
    "        df_negative.tail(len(df_negative) // 2).rename(columns={\n",
    "            'headline': 'summary',\n",
    "            'summary': 'headline'\n",
    "        })])\n",
    "    print(f'Generated {len(df_negative)} negative samples')\n",
    "\n",
    "    df_duplicates = pd.concat([df_positive, df_negative]).sample(frac=1.0).reset_index(drop=True)\n",
    "    return df_duplicates\n",
    "\n",
    "\n",
    "\n",
    "gen_news_duplicates_data(df_news.head(1000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Generate training/test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "if os.path.exists('data/news.train.csv.tgz'):\n",
    "    df_duplicates_train = pd.read_csv('data/news.train.csv.tgz', compression='gzip')\n",
    "else:\n",
    "    print('Generating training data')\n",
    "    df_duplicates_train = gen_news_duplicates_data(\n",
    "        df_news[(df_news.index >= '2019-01-01') & (df_news.index < '2020-11-01')]\n",
    "    )\n",
    "    print('Training data', len(df_duplicates_train), 'samples')\n",
    "    df_duplicates_train.to_csv('data/news.train.csv.tgz', compression='gzip', index=False)\n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "if os.path.exists('data/news.test.csv.tgz'):\n",
    "    df_duplicates_test = pd.read_csv('data/news.test.csv.tgz', compression='gzip')\n",
    "else:\n",
    "    print('Generating test data')\n",
    "    df_duplicates_test = gen_news_duplicates_data(\n",
    "        df_news[(df_news.index >= '2020-11-01') & (df_news.index < '2021-01-01')]\n",
    "    )\n",
    "    print('Test data', len(df_duplicates_test), 'samples')\n",
    "    df_duplicates_test.to_csv('data/news.test.csv.tgz', compression='gzip', index=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train duplicates detection model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at roberta-base were not used when initializing RobertaForSequenceClassification: ['lm_head.bias', 'lm_head.dense.weight', 'lm_head.dense.bias', 'lm_head.layer_norm.weight', 'lm_head.layer_norm.bias', 'lm_head.decoder.weight']\n",
      "- This IS expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.weight', 'classifier.dense.bias', 'classifier.out_proj.weight', 'classifier.out_proj.bias']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
     ]
    }
   ],
   "source": [
    "from simpletransformers.classification import ClassificationModel, ClassificationArgs\n",
    "import torch \n",
    "model_news_dup = ClassificationModel(\n",
    "    'roberta',\n",
    "    'roberta-base',\n",
    "    num_labels=2,\n",
    "    use_cuda=True, \n",
    "    cuda_device=0,\n",
    "    args=ClassificationArgs(\n",
    "        fp16=True, \n",
    "        dataloader_num_workers=1,        \n",
    "        use_multiprocessing=False,\n",
    "        use_multiprocessing_for_evaluation=False,\n",
    "        \n",
    "        # \"RoBERTa: A Robustly Optimized BERT Pretraining Approach\". Optimal batch size is 32, optimal LR=1e-5\n",
    "        eval_batch_size=32,\n",
    "        train_batch_size=32,\n",
    "        overwrite_output_dir=True,\n",
    "        num_train_epochs=1,\n",
    "        reprocess_input_data=False,\n",
    "        best_model_dir='model/roberta_news_duplicates',\n",
    "        \n",
    "        # disabling all LR improvements\n",
    "        adafactor_relative_step=False,\n",
    "        adafactor_scale_parameter=False,\n",
    "        adafactor_warmup_init=False,\n",
    "        polynomial_decay_schedule_lr_end=1e-5,\n",
    "        learning_rate=1e-5,\n",
    "        warmup_ratio=0.,\n",
    "        \n",
    "        use_early_stopping=False, \n",
    "        early_stopping_consider_epochs=True,\n",
    "        early_stopping_patience=2,\n",
    "        \n",
    "        evaluate_during_training=True, \n",
    "        evaluate_during_training_verbose=True,\n",
    "        evaluate_during_training_steps=2500,\n",
    "        use_cached_eval_features=True,\n",
    "        save_model_every_epoch=True,\n",
    "        \n",
    "        save_eval_checkpoints=False, \n",
    "        save_steps=100000000,\n",
    "    )    \n",
    ") \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_news_dup.train_model(\n",
    "    df_duplicates_train.rename(columns={'headline': 'text_a', 'summary': 'text_b'}),\n",
    "    eval_df=df_duplicates_test.rename(columns={'headline': 'text_a', 'summary': 'text_b'}),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from simpletransformers.classification import ClassificationModel, ClassificationArgs\n",
    "import torch \n",
    "model_news_dup = ClassificationModel(\n",
    "    'roberta',\n",
    "    'model/roberta_news_duplicates',\n",
    "    use_cuda=torch.cuda.is_available(), \n",
    "    args=ClassificationArgs(\n",
    "        fp16=True, \n",
    "        dataloader_num_workers=1,        \n",
    "        use_multiprocessing_for_evaluation=False,\n",
    "        eval_batch_size=32,\n",
    "    )    \n",
    ") \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9b8e4173a6ae4d74a64e905a174895ff",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Running Evaluation'), FloatProgress(value=0.0, max=955.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "({'mcc': 0.9071855999740813,\n",
       "  'tp': 14653,\n",
       "  'tn': 14461,\n",
       "  'fp': 805,\n",
       "  'fn': 613,\n",
       "  'auroc': 0.9912327531775954,\n",
       "  'auprc': 0.9915184749678183,\n",
       "  'eval_loss': 0.14305145395493027},\n",
       " array([[-3.21679688,  3.45898438],\n",
       "        [-3.16992188,  3.35742188],\n",
       "        [-2.99609375,  3.08007812],\n",
       "        ...,\n",
       "        [-3.171875  ,  3.36132812],\n",
       "        [-2.4140625 ,  2.28710938],\n",
       "        [-3.22265625,  3.4609375 ]]),\n",
       " [])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_news_dup.eval_model(\n",
    "    df_duplicates_test.rename(columns={'headline': 'text_a', 'summary': 'text_b'})[['text_a', 'text_b','labels']]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "673521db5cdb4bcf9933d27df89b1a0f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=955.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "pred1 = model_news_dup.predict(\n",
    "    df_duplicates_test.rename(columns={'headline': 'text_a', 'summary': 'text_b'})[['text_a', 'text_b']].values.tolist()\n",
    ")\n",
    "\n",
    "pred2 = model_news_dup.predict(\n",
    "    df_duplicates_test.rename(columns={'headline': 'text_b', 'summary': 'text_a'})[['text_a', 'text_b']].values.tolist()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Single test accuracy: 0.953556923883139 0.9534259137953622\n"
     ]
    }
   ],
   "source": [
    "print('Single test accuracy:', (pred1[0] == df_duplicates_test['labels']).mean(), (pred2[0] == df_duplicates_test['labels']).mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Double test accuracy 0.9556858378095113\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "print('Double test accuracy', np.mean(((pred1[0] == 1) & (pred2[0] == 1)) == df_duplicates_test['labels']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1440 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "from scipy.special import softmax\n",
    "from matplotlib import pyplot\n",
    "\n",
    "\n",
    "\n",
    "pyplot.figure(figsize=(20, 20))\n",
    "\n",
    "fpr, tpr, _ = roc_curve(df_duplicates_test['labels'], softmax(pred1[1], axis=1)[:, 1])\n",
    "pyplot.plot(fpr, tpr, linestyle='--', label='Comparing title(article1) to body(article2)')\n",
    "\n",
    "\n",
    "fpr, tpr, _ = roc_curve(df_duplicates_test['labels'],  (softmax(pred1[1], axis=1)[:, 1] + softmax(pred2[1], axis=1)[:, 1]) / 2)\n",
    "pyplot.plot(fpr, tpr, linestyle='-', label='Comparing title(article1) to body(article2) and body(article1) to title(article2)')\n",
    "pyplot.title('ROC curve')\n",
    "pyplot.legend()\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Predict\n",
    "\n",
    "Load the model from huggingface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0854013964274328b455daa5c1be449c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Downloading'), FloatProgress(value=0.0, max=662.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dfbad3fd0eeb49d68df76c2bab7e83f9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Downloading'), FloatProgress(value=0.0, max=501042063.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c94f10bfa8494e0fadc46d77e8117b05",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Downloading'), FloatProgress(value=0.0, max=798293.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "52fe7da00b4f43f288a997691ff4472d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Downloading'), FloatProgress(value=0.0, max=456356.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8f32dfbfead94055a099c299dbe24905",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Downloading'), FloatProgress(value=0.0, max=239.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d0f275b685e24210bf572320ba50a497",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Downloading'), FloatProgress(value=0.0, max=279.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "from simpletransformers.classification import ClassificationModel, ClassificationArgs\n",
    "import torch \n",
    "model_news_dup = ClassificationModel(\n",
    "    'roberta',\n",
    "    'vslaykovsky/roberta-news-duplicates',\n",
    "    use_cuda=torch.cuda.is_available(), \n",
    "    args=ClassificationArgs(\n",
    "        fp16=True, \n",
    "        dataloader_num_workers=1,        \n",
    "        use_multiprocessing_for_evaluation=False,\n",
    "        eval_batch_size=32,\n",
    "    )    \n",
    ") \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fe4ec09463c34246ae4a911672c93c0c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0], dtype=int64)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Negative example\n",
    "model_news_dup.predict([\n",
    "    [\n",
    "        'Coronavirus: Third wave will \"wash up on our shores\", warns Johnson', \n",
    "        'Some 18,000 people have been evacuated from severe floods across New South Wales (NSW) in Australia, with more heavy rainfall predicted.'\n",
    "    ]\n",
    "])[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "79fae56333e243d8b60d80c9e327edcc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1], dtype=int64)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Positive example\n",
    "model_news_dup.predict([\n",
    "    [\n",
    "        'Coronavirus: Third wave will \"wash up on our shores\", warns Johnson', \n",
    "        'Boris Johnson has warned the effects of a third wave of coronavirus will \"wash up on our shores\" from Europe. The PM said the UK should be \"under no illusion\" we will \"feel effects\" of growing cases on the continent'\n",
    "    ]\n",
    "])[0]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "670px",
    "left": "385px",
    "top": "270px",
    "width": "307.188px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}