mark1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "ae070720",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "0b74440e",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_df = pd.read_csv('Doceree-HCP_Test.csv', encoding='latin1')\n",
    "train_df = pd.read_csv('Doceree-HCP_Train.csv', encoding='latin1')\n",
    "#SAMPLE_df = pd.read_csv('Doceree_HCP_Sample_Submission_1.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "6259db1b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "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>ID</th>\n",
       "      <th>DEVICETYPE</th>\n",
       "      <th>PLATFORM_ID</th>\n",
       "      <th>BIDREQUESTIP</th>\n",
       "      <th>USERPLATFORMUID</th>\n",
       "      <th>USERCITY</th>\n",
       "      <th>USERZIPCODE</th>\n",
       "      <th>USERAGENT</th>\n",
       "      <th>PLATFORMTYPE</th>\n",
       "      <th>CHANNELTYPE</th>\n",
       "      <th>URL</th>\n",
       "      <th>KEYWORDS</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>115501</td>\n",
       "      <td>Desktop</td>\n",
       "      <td>2</td>\n",
       "      <td>75.189.231.103</td>\n",
       "      <td>0d5041ff-f0b6-4d1a-9ad7-0a29f7d485b4</td>\n",
       "      <td>Fayetteville</td>\n",
       "      <td>28305.0</td>\n",
       "      <td>Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.clinicaladvisor.com/home/features/...</td>\n",
       "      <td>Family Practice|Drainage|Clinical|Dermatology|...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>115502</td>\n",
       "      <td>Mobile</td>\n",
       "      <td>2</td>\n",
       "      <td>24.101.33.158</td>\n",
       "      <td>c8396dd0-969f-4d99-a40b-b7bb1f516154</td>\n",
       "      <td>Conneaut Lake</td>\n",
       "      <td>16316.0</td>\n",
       "      <td>Mozilla/5.0 (iPhone; CPU iPhone OS 15_6_1 like...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.ophthalmologyadvisor.com/topics/ca...</td>\n",
       "      <td>General|Clinical|Operative|Medicine|Cardiology...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>115503</td>\n",
       "      <td>Desktop</td>\n",
       "      <td>2</td>\n",
       "      <td>172.118.216.142</td>\n",
       "      <td>3c97a081-6518-43f8-9f26-369759cfb471</td>\n",
       "      <td>Covina</td>\n",
       "      <td>91724.0</td>\n",
       "      <td>Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.psychiatryadvisor.com/author/tori-...</td>\n",
       "      <td>Abortion|Anxiety Disorders|Apnea|False|Trauma|...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>115504</td>\n",
       "      <td>Desktop</td>\n",
       "      <td>7</td>\n",
       "      <td>71.105.120.171</td>\n",
       "      <td>3e2578c8-f794-41af-a38c-c5cfb3c0f014</td>\n",
       "      <td>Brooklyn</td>\n",
       "      <td>11226.0</td>\n",
       "      <td>Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.cureus.com/articles/105482-diverti...</td>\n",
       "      <td>Health|Male|Neurological Surgery|Otolaryngolog...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>115505</td>\n",
       "      <td>Desktop</td>\n",
       "      <td>2</td>\n",
       "      <td>73.82.211.73</td>\n",
       "      <td>ec2ae7ce-6a8c-4156-98a7-07203e60f483</td>\n",
       "      <td>Marietta</td>\n",
       "      <td>30062.0</td>\n",
       "      <td>Mozilla/5.0 (Windows NT 10.0; Win64; x64) Appl...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.renalandurologynews.com/home/confe...</td>\n",
       "      <td>chronic kidney disease|pain|nephrology|disease...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>115506</td>\n",
       "      <td>Desktop</td>\n",
       "      <td>2</td>\n",
       "      <td>169.147.254.129</td>\n",
       "      <td>0313febc-12e6-4289-8d74-5f0c1aecc385</td>\n",
       "      <td>Kansas City</td>\n",
       "      <td>64113.0</td>\n",
       "      <td>Mozilla/5.0 (Windows NT 10.0; Win64; x64) Appl...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.renalandurologynews.com/home/decis...</td>\n",
       "      <td>Abscess|Liver Transplantation|Transplantation|...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>115507</td>\n",
       "      <td>Desktop</td>\n",
       "      <td>9</td>\n",
       "      <td>66.249.66.2</td>\n",
       "      <td>ce1f2f66-056e-4684-8c24-6d70e632a269</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Bu...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.2minutemedicine.com/studygraphics-...</td>\n",
       "      <td>the|medicine|oncology|</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>115508</td>\n",
       "      <td>Desktop</td>\n",
       "      <td>2</td>\n",
       "      <td>50.236.245.242</td>\n",
       "      <td>8fc0a64c-0c71-4888-aff4-833823802bba</td>\n",
       "      <td>Seattle</td>\n",
       "      <td>98188.0</td>\n",
       "      <td>Mozilla/5.0 (Windows NT 10.0; Win64; x64) Appl...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/canc...</td>\n",
       "      <td>General|Endocrine|False|Medicine|Surgery|Urolo...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>115509</td>\n",
       "      <td>Desktop</td>\n",
       "      <td>2</td>\n",
       "      <td>204.99.118.10</td>\n",
       "      <td>12ec92c0-a55b-45a2-8c4e-4237dcfc8eef</td>\n",
       "      <td>Scottsdale</td>\n",
       "      <td>85260.0</td>\n",
       "      <td>Mozilla/5.0 (Windows NT 10.0; Win64; x64) Appl...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.empr.com/drug/evrysdi/</td>\n",
       "      <td>Medicine|Metabolic|Dermatology|Child|False|Mal...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>115510</td>\n",
       "      <td>Mobile</td>\n",
       "      <td>2</td>\n",
       "      <td>71.228.67.64</td>\n",
       "      <td>d0a2d8ab-6ea1-440e-a2f1-03acd6a1db99</td>\n",
       "      <td>Sarasota</td>\n",
       "      <td>34232.0</td>\n",
       "      <td>Mozilla/5.0 (iPhone; CPU iPhone OS 16_3_1 like...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.clinicaladvisor.com/home/dermatolo...</td>\n",
       "      <td>Hemoptysis|Oral|Rheumatology|Cardiovascular|Sm...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       ID DEVICETYPE  PLATFORM_ID     BIDREQUESTIP  \\\n",
       "0  115501    Desktop            2   75.189.231.103   \n",
       "1  115502     Mobile            2    24.101.33.158   \n",
       "2  115503    Desktop            2  172.118.216.142   \n",
       "3  115504    Desktop            7   71.105.120.171   \n",
       "4  115505    Desktop            2     73.82.211.73   \n",
       "5  115506    Desktop            2  169.147.254.129   \n",
       "6  115507    Desktop            9      66.249.66.2   \n",
       "7  115508    Desktop            2   50.236.245.242   \n",
       "8  115509    Desktop            2    204.99.118.10   \n",
       "9  115510     Mobile            2     71.228.67.64   \n",
       "\n",
       "                        USERPLATFORMUID       USERCITY  USERZIPCODE  \\\n",
       "0  0d5041ff-f0b6-4d1a-9ad7-0a29f7d485b4   Fayetteville      28305.0   \n",
       "1  c8396dd0-969f-4d99-a40b-b7bb1f516154  Conneaut Lake      16316.0   \n",
       "2  3c97a081-6518-43f8-9f26-369759cfb471         Covina      91724.0   \n",
       "3  3e2578c8-f794-41af-a38c-c5cfb3c0f014       Brooklyn      11226.0   \n",
       "4  ec2ae7ce-6a8c-4156-98a7-07203e60f483       Marietta      30062.0   \n",
       "5  0313febc-12e6-4289-8d74-5f0c1aecc385    Kansas City      64113.0   \n",
       "6  ce1f2f66-056e-4684-8c24-6d70e632a269            NaN          NaN   \n",
       "7  8fc0a64c-0c71-4888-aff4-833823802bba        Seattle      98188.0   \n",
       "8  12ec92c0-a55b-45a2-8c4e-4237dcfc8eef     Scottsdale      85260.0   \n",
       "9  d0a2d8ab-6ea1-440e-a2f1-03acd6a1db99       Sarasota      34232.0   \n",
       "\n",
       "                                           USERAGENT            PLATFORMTYPE  \\\n",
       "0  Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6...  Online Medical Journal   \n",
       "1  Mozilla/5.0 (iPhone; CPU iPhone OS 15_6_1 like...  Online Medical Journal   \n",
       "2  Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7...  Online Medical Journal   \n",
       "3  Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7...  Online Medical Journal   \n",
       "4  Mozilla/5.0 (Windows NT 10.0; Win64; x64) Appl...  Online Medical Journal   \n",
       "5  Mozilla/5.0 (Windows NT 10.0; Win64; x64) Appl...  Online Medical Journal   \n",
       "6  Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Bu...  Online Medical Journal   \n",
       "7  Mozilla/5.0 (Windows NT 10.0; Win64; x64) Appl...  Online Medical Journal   \n",
       "8  Mozilla/5.0 (Windows NT 10.0; Win64; x64) Appl...  Online Medical Journal   \n",
       "9  Mozilla/5.0 (iPhone; CPU iPhone OS 16_3_1 like...  Online Medical Journal   \n",
       "\n",
       "  CHANNELTYPE                                                URL  \\\n",
       "0     Website  https://www.clinicaladvisor.com/home/features/...   \n",
       "1     Website  https://www.ophthalmologyadvisor.com/topics/ca...   \n",
       "2     Website  https://www.psychiatryadvisor.com/author/tori-...   \n",
       "3     Website  https://www.cureus.com/articles/105482-diverti...   \n",
       "4     Website  https://www.renalandurologynews.com/home/confe...   \n",
       "5     Website  https://www.renalandurologynews.com/home/decis...   \n",
       "6     Website  https://www.2minutemedicine.com/studygraphics-...   \n",
       "7     Website  https://www.cancertherapyadvisor.com/home/canc...   \n",
       "8     Website                 https://www.empr.com/drug/evrysdi/   \n",
       "9     Website  https://www.clinicaladvisor.com/home/dermatolo...   \n",
       "\n",
       "                                            KEYWORDS  \n",
       "0  Family Practice|Drainage|Clinical|Dermatology|...  \n",
       "1  General|Clinical|Operative|Medicine|Cardiology...  \n",
       "2  Abortion|Anxiety Disorders|Apnea|False|Trauma|...  \n",
       "3  Health|Male|Neurological Surgery|Otolaryngolog...  \n",
       "4  chronic kidney disease|pain|nephrology|disease...  \n",
       "5  Abscess|Liver Transplantation|Transplantation|...  \n",
       "6                             the|medicine|oncology|  \n",
       "7  General|Endocrine|False|Medicine|Surgery|Urolo...  \n",
       "8  Medicine|Metabolic|Dermatology|Child|False|Mal...  \n",
       "9  Hemoptysis|Oral|Rheumatology|Cardiovascular|Sm...  "
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_df.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "b6860c67",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "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>ID</th>\n",
       "      <th>DEVICETYPE</th>\n",
       "      <th>PLATFORM_ID</th>\n",
       "      <th>BIDREQUESTIP</th>\n",
       "      <th>USERPLATFORMUID</th>\n",
       "      <th>USERCITY</th>\n",
       "      <th>USERZIPCODE</th>\n",
       "      <th>USERAGENT</th>\n",
       "      <th>PLATFORMTYPE</th>\n",
       "      <th>CHANNELTYPE</th>\n",
       "      <th>URL</th>\n",
       "      <th>KEYWORDS</th>\n",
       "      <th>TAXONOMY</th>\n",
       "      <th>IS_HCP</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1001</td>\n",
       "      <td>Desktop</td>\n",
       "      <td>2</td>\n",
       "      <td>170.173.0.22</td>\n",
       "      <td>6974dcaa-f932-480e-9fb5-c52e20e1393a</td>\n",
       "      <td>Portland</td>\n",
       "      <td>97206.0</td>\n",
       "      <td>Mozilla/5.0 (Windows NT 10.0; Win64; x64) Appl...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/canc...</td>\n",
       "      <td>General|Endocrine|False|Medicine|Surgery|Urolo...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1002</td>\n",
       "      <td>Desktop</td>\n",
       "      <td>2</td>\n",
       "      <td>65.216.253.25</td>\n",
       "      <td>c12f3f8f-8fcf-484a-90e1-1ac04db8cdcf</td>\n",
       "      <td>Arlington</td>\n",
       "      <td>22202.0</td>\n",
       "      <td>Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/deci...</td>\n",
       "      <td>Bone Marrow|Radiography|Chronic|Oncology|Psych...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1003</td>\n",
       "      <td>Desktop</td>\n",
       "      <td>2</td>\n",
       "      <td>66.232.79.22</td>\n",
       "      <td>a698de4b-e200-46dd-b5fb-40402175ae18</td>\n",
       "      <td>New Meadows</td>\n",
       "      <td>83654.0</td>\n",
       "      <td>Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/canc...</td>\n",
       "      <td>General|Endocrine|False|Medicine|Surgery|Urolo...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1004</td>\n",
       "      <td>Desktop</td>\n",
       "      <td>3</td>\n",
       "      <td>137.54.125.246</td>\n",
       "      <td>45967533-75c8-4fbd-a00c-e6ff20447aaa</td>\n",
       "      <td>NaN</td>\n",
       "      <td>229114624.0</td>\n",
       "      <td>Mozilla/5.0 (Windows NT 10.0; Win64; x64) Appl...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://globalrph.com/medcalcs/warfarin-mainte...</td>\n",
       "      <td>Dental|Total|Clinical|Pharmacology|Physicians|...</td>\n",
       "      <td>2084P0800X</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1005</td>\n",
       "      <td>Mobile</td>\n",
       "      <td>7</td>\n",
       "      <td>174.202.231.99</td>\n",
       "      <td>a17e25be-532d-4cf5-b916-9308c8c3961f</td>\n",
       "      <td>Houston</td>\n",
       "      <td>77008.0</td>\n",
       "      <td>Mozilla/5.0 (iPhone; CPU iPhone OS 16_1_1 like...</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>Website</td>\n",
       "      <td>https://www.cureus.com/articles/58184-a-review...</td>\n",
       "      <td>Critical Care|Emergency Medicine|General Pract...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     ID DEVICETYPE  PLATFORM_ID    BIDREQUESTIP  \\\n",
       "0  1001    Desktop            2    170.173.0.22   \n",
       "1  1002    Desktop            2   65.216.253.25   \n",
       "2  1003    Desktop            2    66.232.79.22   \n",
       "3  1004    Desktop            3  137.54.125.246   \n",
       "4  1005     Mobile            7  174.202.231.99   \n",
       "\n",
       "                        USERPLATFORMUID     USERCITY  USERZIPCODE  \\\n",
       "0  6974dcaa-f932-480e-9fb5-c52e20e1393a     Portland      97206.0   \n",
       "1  c12f3f8f-8fcf-484a-90e1-1ac04db8cdcf    Arlington      22202.0   \n",
       "2  a698de4b-e200-46dd-b5fb-40402175ae18  New Meadows      83654.0   \n",
       "3  45967533-75c8-4fbd-a00c-e6ff20447aaa          NaN  229114624.0   \n",
       "4  a17e25be-532d-4cf5-b916-9308c8c3961f      Houston      77008.0   \n",
       "\n",
       "                                           USERAGENT            PLATFORMTYPE  \\\n",
       "0  Mozilla/5.0 (Windows NT 10.0; Win64; x64) Appl...  Online Medical Journal   \n",
       "1  Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7...  Online Medical Journal   \n",
       "2  Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7...  Online Medical Journal   \n",
       "3  Mozilla/5.0 (Windows NT 10.0; Win64; x64) Appl...  Online Medical Journal   \n",
       "4  Mozilla/5.0 (iPhone; CPU iPhone OS 16_1_1 like...  Online Medical Journal   \n",
       "\n",
       "  CHANNELTYPE                                                URL  \\\n",
       "0     Website  https://www.cancertherapyadvisor.com/home/canc...   \n",
       "1     Website  https://www.cancertherapyadvisor.com/home/deci...   \n",
       "2     Website  https://www.cancertherapyadvisor.com/home/canc...   \n",
       "3     Website  https://globalrph.com/medcalcs/warfarin-mainte...   \n",
       "4     Website  https://www.cureus.com/articles/58184-a-review...   \n",
       "\n",
       "                                            KEYWORDS    TAXONOMY  IS_HCP  \n",
       "0  General|Endocrine|False|Medicine|Surgery|Urolo...         NaN     0.0  \n",
       "1  Bone Marrow|Radiography|Chronic|Oncology|Psych...         NaN     0.0  \n",
       "2  General|Endocrine|False|Medicine|Surgery|Urolo...         NaN     0.0  \n",
       "3  Dental|Total|Clinical|Pharmacology|Physicians|...  2084P0800X     1.0  \n",
       "4  Critical Care|Emergency Medicine|General Pract...         NaN     0.0  "
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "7946aa79",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(113937, 14)"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "50494d76",
   "metadata": {},
   "outputs": [],
   "source": [
    "#SAMPLE_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "8d7873c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ID                   int64\n",
       "DEVICETYPE          object\n",
       "PLATFORM_ID          int64\n",
       "BIDREQUESTIP        object\n",
       "USERPLATFORMUID     object\n",
       "USERCITY            object\n",
       "USERZIPCODE        float64\n",
       "USERAGENT           object\n",
       "PLATFORMTYPE        object\n",
       "CHANNELTYPE         object\n",
       "URL                 object\n",
       "KEYWORDS            object\n",
       "TAXONOMY            object\n",
       "IS_HCP             float64\n",
       "dtype: object"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "1197013a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Online Medical Journal      110120\n",
      "Online Learning Portal        2978\n",
      "Medical News Platform          798\n",
      "Electronic Health Record        40\n",
      "Tele-medicine Platform           1\n",
      "Name: PLATFORMTYPE, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "value_counts = train_df['PLATFORMTYPE'].value_counts()\n",
    "print(value_counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "a1c73703",
   "metadata": {},
   "outputs": [],
   "source": [
    "columns_to_drop = [\"ID\", \"DEVICETYPE\", \"PLATFORM_ID\", \"CHANNELTYPE\", \"USERAGENT\"]\n",
    "train_df.drop(columns=columns_to_drop, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "7c627484",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "++- BIDREQUESTIP -++\n",
      "71.105.120.171     1718\n",
      "142.154.205.202    1143\n",
      "68.132.98.211       866\n",
      "108.175.114.100     727\n",
      "108.175.114.101     707\n",
      "                   ... \n",
      "66.66.9.45            1\n",
      "97.80.251.36          1\n",
      "136.32.32.117         1\n",
      "64.127.133.6          1\n",
      "108.41.233.175        1\n",
      "Name: BIDREQUESTIP, Length: 33664, dtype: int64\n",
      "=======================\n",
      "++- USERPLATFORMUID -++\n",
      "3e2578c8-f794-41af-a38c-c5cfb3c0f014    1447\n",
      "d76f7c0b-1a64-4d4b-b36d-86c832be8837    1406\n",
      "d00f28d6-3a50-46cd-92f3-8601bd57ad0e     675\n",
      "fcd3d327-0ad5-425e-8ea8-33ffe6a31543     629\n",
      "fe53f32c-4646-4abe-afea-90b21d6b8531     617\n",
      "                                        ... \n",
      "6759cbf8-cf4f-4d0e-9eb8-00808e69e841       1\n",
      "bd2007ca-d0b5-4620-8078-b7c6db62037c       1\n",
      "0534212a-e0e9-49e7-ace9-608e0d0eae8a       1\n",
      "26a06716-2716-4ac2-9131-fa0f01f84526       1\n",
      "d26887c5-15f9-4b72-80dc-728039529e60       1\n",
      "Name: USERPLATFORMUID, Length: 53780, dtype: int64\n",
      "=======================\n",
      "++- USERCITY -++\n",
      "New York          4943\n",
      "Brooklyn          3237\n",
      "St Louis          2545\n",
      "Los Angeles       2154\n",
      "Houston           1747\n",
      "                  ... \n",
      "Foothill Ranch       1\n",
      "Henrietta            1\n",
      "Wartburg             1\n",
      "Winfield             1\n",
      "Gambier              1\n",
      "Name: USERCITY, Length: 4420, dtype: int64\n",
      "=======================\n",
      "++- USERZIPCODE -++\n",
      "63169.0        2116\n",
      "11226.0        1752\n",
      "22202.0        1259\n",
      "10001.0        1190\n",
      "90060.0        1058\n",
      "               ... \n",
      "56748.0           1\n",
      "77021.0           1\n",
      "74880.0           1\n",
      "93630.0           1\n",
      "760865488.0       1\n",
      "Name: USERZIPCODE, Length: 11278, dtype: int64\n",
      "=======================\n",
      "++- PLATFORMTYPE -++\n",
      "Online Medical Journal      110120\n",
      "Online Learning Portal        2978\n",
      "Medical News Platform          798\n",
      "Electronic Health Record        40\n",
      "Tele-medicine Platform           1\n",
      "Name: PLATFORMTYPE, dtype: int64\n",
      "=======================\n",
      "++- URL -++\n",
      "https://www.clinicaladvisor.com/home/features/clinical-challenge/pain-tingling-and-limited-range-of-motion-after-a-cat-bite-to-the-finger/                                                                                                                                                                                                                                                                                                                                                                                   5310\n",
      "https://www.gastroenterologyadvisor.com/                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     4299\n",
      "https://www.cureus.com/articles/105482-diverticulitis-with-microperforation                                                                                                                                                                                                                                                                                                                                                                                                                                                  2838\n",
      "https://www.clinicaladvisor.com/home/dermatologic-look-alikes/red-rashes-on-the-lower-legs/2/                                                                                                                                                                                                                                                                                                                                                                                                                                2708\n",
      "https://www.rheumatologyadvisor.com/home/general-rheumatology/deep-dive-overview-of-liver-manifestations-in-rheumatic-diseases/                                                                                                                                                                                                                                                                                                                                                                                              2587\n",
      "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ... \n",
      "https://www.infectiousdiseaseadvisor.com/home/topics/covid19/mixed-results-for-paxlovid-in-standard-risk-patients-with-covid-19/?utm_source=newsletter&utm_medium=email&utm_campaign=NWSLT_IDA_UPDT_062222_JM&hmEmail=kTgLcihhhDEW1GwCOOdG13UHIqcIj%2F6O&hmSubId=&NID=1316018294&elqTrackId=e3e7472aa24848f5b776f0dfa4cae5e5&elq=e6d2fec6b6d24ee89c79463b98493739&elqaid=353&elqat=1&elqCampaignId=194                                                                                                                          1\n",
      "https://www.clinicaladvisor.com/home/meeting-coverage/acaai-2022/early-atopic-dermatitis-modifies-the-risk-for-allergic-respiratory-disease/?utm_source=newsletter&utm_medium=email&utm_campaign=NWLTR_CAD_CONF_ACAAI_ASTEPRO_112222_RM&hmEmail=Ysc25hIpkOHdmgLIaUrt9Bhfr1jEQITVgqbP1HaB5lo=&sha256email=c372454efec279dee597fd62192657913f5a5108d9d7a648a2d518ed2f4abcad&hmSubId=&NID=1003876251&elqTrackId=031b0c57d3bc455eb8736ad8693830db&elq=db6bd4eba8354842aff4c502062d50df&elqaid=7476&elqat=1&elqCampaignId=6232       1\n",
      "https://www.rheumatologyadvisor.com/home/news/early-screening-and-management-of-cardiovascular-risk-factors-important-in-psoriatic-arthritis-and-ankylosing-spondylitis/?utm_source=google&utm_medium=ppc&utm_campaign=traffic-drivers-rheum&gclid=EAIaIQobChMIpf6cxoWQ_AIVAqvICh1JwA4XEAEYASAAEgKTN_D_BwE                                                                                                                                                                                                                      1\n",
      "https://allmedx.com/q/Flu vaccine lowers risk of stroke?utm_source=Email8271&utm_medium=email&utm_campaign=Email8271&em_tag=94264\u000b\u000b\u000b                                                                                                                                                                                                                                                                                                                                                                                            1\n",
      "https://radrounds.com/radiology-case-images-teaching-file/bilothorax/?fbclid=IwAR3Yw9WM9wiMWr1a1QPTfo4ktG3z5v7TJqCASTbHHi4jNub55m23gxSvsFg                                                                                                                                                                                                                                                                                                                                                                                      1\n",
      "Name: URL, Length: 5231, dtype: int64\n",
      "=======================\n",
      "++- KEYWORDS -++\n",
      "Family Practice|Drainage|Clinical|Dermatology|Ophthalmology|Medicine|Allergic|General|Diagnosis|Neurology|Hepatology|Health|Cardiovascular|Surgical|Psychiatry|Oral|Urology|Cardiology|Gastroenterology|Orthopedics|Erythema|Arthritis|Asthma|Cellulitis|Pediatrics|Surgery|False|Oncology|Rheumatology                                                                                                                                                                                                                                                                                                                                                                                                                                          5317\n",
      "Transplantation|Technology|Chronic|Neoplasms|Urology|Pancreas|Mental Health|Arthritis|Refractory|Myocardial Infarction|Aged|Cardiology|Oncology|Surgical|Balloon|Anesthesia|Synthetic|Hepatic Transplantation|Diagnosis|Neurology|Ophthalmology|Surgery|Total|Atrial Fibrillation|Overweight|Autoimmune|Atherectomy|Heart Defects|Neonatal|Psychological|Stomach|Metabolic|Hospitals|Graves|Esophagus|Liver|Oral|Rheumatology|Insomnia|Acquired|General|Induced|Gastroenterology|Psychiatry|Angioplasty|Cardiovascular|Child|Arrhythmia|Dermatology|Liver Transplantation|Anxiety Disorders|Delivery|Flu|Small|Resuscitation|Asthma|Pathology|Medicine|Health|Clinical|False|Biliary Tract|Lung|Sleep Disorders|Arrhythmias|Bariatric Surgery    4530\n",
      "Health|Male|Neurological Surgery|Otolaryngology|Preventive Medicine|Surgery|Analgesia|Neutrophils|Resuscitation|Dermatology|Neurology|General|Intravenous|Oral|Surgical|Trauma|Orthopedics|Medicine|Monocytes|Specialties|Preventive|Anastomosis|Physical Medicine & Rehabilitation|Rheumatology|Urology|Critical Care|General Practice|Abscess|Dentistry|Small|Gastroenterology|Cardiac|Technology|Operative|Large|Emergency Medicine|Rehabilitation|Drainage|False|Anesthesiology|Oncology|Ophthalmology|Pediatrics|Transplantation|Clinical|Diagnosis|Metabolic|Pathology|Total|Cardiology|Nuclear Medicine|Psychiatry                                                                                                                        2838\n",
      "Myopathies|Small|Rheumatoid|Psychiatry|Urology|General|False|Chronic|Induced|Total|Neurology|Arthralgia|Joints|Medicine|Health|Connective Tissue Diseases|Intrahepatic|Polyarthritis|Gastroenterology|Autoimmune Diseases|Liver Dysfunction|Liver Diseases|Arthritis|Controlled|Synthetic|Clinical|Metabolic|Cardiology|Rheumatology|Liver|Rheumatic Diseases|Genetic|Autoimmune|Dermatology|Oncology|Ophthalmology                                                                                                                                                                                                                                                                                                                              2741\n",
      "Hemoptysis|Oral|Rheumatology|Cardiovascular|Small|Rheumatoid|Oncology|Ophthalmology|Clinical|Cardiology|Hemorrhage|Health|Biopsy|Hepatology|Hypersensitivity|Refractory|False|Chronic|Psychiatry|Urology|Medicine|Neutrophils|Erythema|Asthma|Diagnosis|Neurology|Orthopedics|Pediatrics|General|Dermatology|Gastroenterology|Surgery|Hematuria|Disseminated Intravascular Coagulation|Arthritis                                                                                                                                                                                                                                                                                                                                                 2708\n",
      "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ... \n",
      "small|hospitals|biliary tract|thrombocytopenia|advanced|rheumatology|hepatology|oncology|angioedema|thyroid carcinoma|physicians|cystic fibrosis|pulmonary fibrosis|induced|alagille syndrome|pulmonary arterial hypertension|neurology|new|pain|myelofibrosis|disease|large|liver|vasculitis|biomarkers|multiple sclerosis|neuromyelitis optica|diagnosis|health|gastroenterology|idiopathic pulmonary fibrosis|cardiology|intrahepatic|the|hematology|clinical|carcinoma|urology|hereditary|hypertension|endocrinology|                                                                                                                                                                                                                           1\n",
      "Medicine|Gastroenterology|Health|Total|Neurology|General|Dermatology|Oral|Psychiatry|Graves|Molecular|Oncology|Graves Disease|Clinical|Ophthalmology|Rheumatology|Urology|False|Cardiology                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1\n",
      "biliary tract|rheumatology|stomach|psychiatry|oncology|general|total|pancreas|patient|ophthalmology|neurology|pain|disease|biologics|liver|medicine|gastroenterology|cardiology|the|controlled|hematology|clinical|dermatology|urology|esophagus|endocrinology|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     1\n",
      "chronic kidney disease|nephrology|rheumatology|psychiatry|lupus|oncology|erectile dysfunction|nephrology|nephritis|general|ophthalmology|chronic|neurology|cardiovascular disease|pain|sleep disorders|disease|large|health|medicine|gastroenterology|cardiovascular|anemia|reproductive|the|clinical|hematology|premature|dermatology|arthritis|carcinoma|transplantation|urology|urinary tract infections|diabetes|hypertension|endocrinology|                                                                                                                                                                                                                                                                                                    1\n",
      "the|lung|educational|pneumonia|radiology|pulmonary fibrosis|dyspnea|technology|pleural effusion|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1\n",
      "Name: KEYWORDS, Length: 2460, dtype: int64\n",
      "=======================\n",
      "++- TAXONOMY -++\n",
      "2084P0800X    7930\n",
      "2084N0400X    6621\n",
      "207Q00000X    3997\n",
      "207R00000X    3190\n",
      "208000000X     837\n",
      "              ... \n",
      "163WC0400X       1\n",
      "246QM0706X       1\n",
      "1835N1003X       1\n",
      "207RI0008X       1\n",
      "207XX0801X       1\n",
      "Name: TAXONOMY, Length: 207, dtype: int64\n",
      "=======================\n",
      "++- IS_HCP -++\n",
      "0.0    79756\n",
      "1.0    34180\n",
      "Name: IS_HCP, dtype: int64\n",
      "=======================\n"
     ]
    }
   ],
   "source": [
    "for column in train_df.columns:\n",
    "    print(\"++- \"+column+\" -++\")\n",
    "    print(train_df[column].value_counts())\n",
    "    print('=======================')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b452094b",
   "metadata": {},
   "source": [
    "Since, multiple URLs are repeating we can use them directly to train the model. Altough breaking them up will be better for accuracy, but nonetheless we can atleast use it meaningfully."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "0fea3545",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of Null Values:\n",
      "BIDREQUESTIP           0\n",
      "USERPLATFORMUID        4\n",
      "USERCITY            6359\n",
      "USERZIPCODE         4592\n",
      "PLATFORMTYPE           0\n",
      "URL                    0\n",
      "KEYWORDS               0\n",
      "TAXONOMY           81624\n",
      "IS_HCP                 1\n",
      "dtype: int64\n",
      "\n"
     ]
    }
   ],
   "source": [
    "null_sum = train_df.isnull().sum()\n",
    "\n",
    "print(\"Sum of Null Values:\")\n",
    "print(null_sum)\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a4e13bc",
   "metadata": {},
   "source": [
    "## Dropping the missing values in the USERPLATFORMUID as no valid relationship can be established."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "fe31f6a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "59158     152.11.230.114\n",
      "80923      73.59.230.146\n",
      "99416     152.11.230.114\n",
      "102512     73.59.230.146\n",
      "Name: BIDREQUESTIP, dtype: object\n"
     ]
    }
   ],
   "source": [
    "missing_uid_rows = train_df[train_df['USERPLATFORMUID'].isnull()]\n",
    "bidrequestip_values = missing_uid_rows['BIDREQUESTIP']\n",
    "print(bidrequestip_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "fd30ae42",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df.dropna(subset=['USERPLATFORMUID'], inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33548e20",
   "metadata": {},
   "source": [
    "## for missing value in IS_HCP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "e27db314",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73790    47.147.27.131\n",
      "Name: BIDREQUESTIP, dtype: object\n"
     ]
    }
   ],
   "source": [
    "missing_uid_rows = train_df[train_df['IS_HCP'].isnull()]\n",
    "bidrequestip_values = missing_uid_rows['BIDREQUESTIP']\n",
    "print(bidrequestip_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32a4ba2e",
   "metadata": {},
   "source": [
    "the missing value in IS_HCP has this BIDREQIP, so decided to follow the other values at this BIDREQIP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "031cb125",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df['IS_HCP'] = train_df.groupby('USERPLATFORMUID')['IS_HCP'].ffill()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "9f20869f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       IS_HCP   BIDREQUESTIP\n",
      "412       1.0  47.147.27.131\n",
      "4376      1.0  47.147.27.131\n",
      "17491     1.0  47.147.27.131\n",
      "73790     1.0  47.147.27.131\n"
     ]
    }
   ],
   "source": [
    "filtered_df = train_df[train_df['BIDREQUESTIP'] == '47.147.27.131']\n",
    "print(filtered_df[['IS_HCP', 'BIDREQUESTIP']])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aed500f9",
   "metadata": {},
   "source": [
    "Since IS_HCP is binary -->!float -->>>int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "9b106b15",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "train_df['IS_HCP'] = train_df['IS_HCP'].apply(np.int64)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "196b6be8",
   "metadata": {},
   "source": [
    "We can see the value of 1.0 is inserted into 73790     1.0  47.147.27.131"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "78cf3b5b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of Null Values:\n",
      "BIDREQUESTIP           0\n",
      "USERPLATFORMUID        0\n",
      "USERCITY            6359\n",
      "USERZIPCODE         4592\n",
      "PLATFORMTYPE           0\n",
      "URL                    0\n",
      "KEYWORDS               0\n",
      "TAXONOMY           81624\n",
      "IS_HCP                 0\n",
      "dtype: int64\n",
      "\n"
     ]
    }
   ],
   "source": [
    "null_sum = train_df.isnull().sum()\n",
    "\n",
    "print(\"Sum of Null Values:\")\n",
    "print(null_sum)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "c8ff98cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5009      Plymouth\n",
      "12542      Detroit\n",
      "19351     Plymouth\n",
      "21258      Detroit\n",
      "29326      Detroit\n",
      "42271     Plymouth\n",
      "64092     Plymouth\n",
      "65229     Plymouth\n",
      "66293      Detroit\n",
      "70688      Detroit\n",
      "87318     Plymouth\n",
      "94143      Detroit\n",
      "94208     Plymouth\n",
      "112735         NaN\n",
      "Name: USERCITY, dtype: object\n"
     ]
    }
   ],
   "source": [
    "zipcode = 482012153\n",
    "usercity_values = train_df[train_df['USERZIPCODE'] == zipcode]['USERCITY']\n",
    "print(usercity_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "b0173a18",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df['USERCITY'] = train_df['USERCITY'].fillna(train_df.groupby('USERZIPCODE')['USERCITY'].transform('first'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "f6cdcd8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# null_sum = train_df.isnull().sum()\n",
    "\n",
    "# print(\"Sum of Null Values:\")\n",
    "# print(null_sum)\n",
    "# print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "f7d95702",
   "metadata": {},
   "outputs": [],
   "source": [
    "# zipcode = 482012153\n",
    "# usercity_values = train_df[train_df['USERZIPCODE'] == zipcode]['USERCITY']\n",
    "# print(usercity_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e07418c",
   "metadata": {},
   "source": [
    "For Taxanomy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a902b77f",
   "metadata": {},
   "source": [
    "## handling category"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "4684a84f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of word_list: 1613\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['Pre-Excitation Syndromes',\n",
       " 'otitis media',\n",
       " 'metabolic syndrome',\n",
       " 'Hemoperitoneum',\n",
       " 'internal medicine',\n",
       " 'gastrointestinal diseases',\n",
       " 'Molecular Diagnostic',\n",
       " 'pneumothorax',\n",
       " 'diagnosis',\n",
       " 'depression',\n",
       " 'acetaminophen',\n",
       " 'pulmonary fibrosis',\n",
       " 'drug combinations',\n",
       " 'acquired immunodeficiency syndrome',\n",
       " 'arthritis',\n",
       " 'Orthodontics',\n",
       " 'pharyngitis',\n",
       " 'Disseminated Intravascular Coagulation',\n",
       " 'orthopedic',\n",
       " 'Ophthalmology',\n",
       " 'Status Asthmaticus',\n",
       " 'subarachnoid hemorrhage',\n",
       " 'hepatitis e',\n",
       " 'Epistaxis',\n",
       " 'anti-inflammatory agents',\n",
       " 'Catheterization',\n",
       " 'laser',\n",
       " 'Endocrine Cancers',\n",
       " 'CNS',\n",
       " 'Extravascular Lung Water',\n",
       " 'salivary gland',\n",
       " 'Premature',\n",
       " 'respiratory tract',\n",
       " 'hemophilia b',\n",
       " 'nidovirales infections',\n",
       " 'escherichia coli',\n",
       " 'vision problems',\n",
       " 'malaria',\n",
       " 'Pharynx',\n",
       " 'blood pressure control',\n",
       " 'levofloxacin',\n",
       " 'Dermatitis',\n",
       " 'primary prevention',\n",
       " 'Anticoagulant Drug',\n",
       " 'General Practitioners',\n",
       " 'Hematoma',\n",
       " 'Genetic',\n",
       " 'inflammation',\n",
       " 'shock',\n",
       " 'uveitis',\n",
       " 'genetic diseases',\n",
       " 'nasal cavity',\n",
       " 'Prostaglandins',\n",
       " 'anticoagulant therapy',\n",
       " 'whooping cough',\n",
       " 'arthropathy',\n",
       " 'granulomatosis with polyangiitis',\n",
       " 'Cardiomyopathies',\n",
       " 'geroscience',\n",
       " 'sexually transmitted diseases',\n",
       " 'toxoplasmosis',\n",
       " 'lymphatic diseases',\n",
       " 'cardiomegaly',\n",
       " 'Erythema',\n",
       " 'severe acute respiratory syndrome',\n",
       " 'organ transplant',\n",
       " 'covid-19',\n",
       " 'itching',\n",
       " 'conduct disorders',\n",
       " 'ramsay hunt syndrome',\n",
       " 'Myeloproliferative neoplasms',\n",
       " 'Lung Abscess',\n",
       " 'aortic rupture',\n",
       " 'biopsy',\n",
       " 'typhus',\n",
       " 'prednisone',\n",
       " 'hepatitis a',\n",
       " 'polycythemia',\n",
       " 'lemierre syndrome',\n",
       " 'pelvic inflammatory disease',\n",
       " 'anaplastic lymphoma kinase',\n",
       " 'Clinical Pathology',\n",
       " 'infant',\n",
       " 'anus',\n",
       " 'Pelvic Inflammatory Disease',\n",
       " 'Infected',\n",
       " 'Molecular',\n",
       " 'Minimally Invasive Surgical Procedures',\n",
       " 'Obstetrics & Gynecology',\n",
       " 'Second Primary',\n",
       " 'Age Groups',\n",
       " 'Inherited',\n",
       " 'Joint Diseases',\n",
       " 'bile ducts',\n",
       " 'swelling',\n",
       " 'Psychological',\n",
       " 'Cardiovascular Abnormalities',\n",
       " 'Juvenile Dermatomyositis',\n",
       " 'leptospirosis',\n",
       " 'Disruptive',\n",
       " 'Tuberculosis',\n",
       " 'chronic obstructive pulmonary disease',\n",
       " 'iga vasculitis',\n",
       " 'shingrix',\n",
       " 'apixaban',\n",
       " 'urogenital',\n",
       " 'vaccines',\n",
       " 'bronchitis',\n",
       " 'Cardiomegaly',\n",
       " 'hemolytic',\n",
       " 'Intracranial Hemorrhages',\n",
       " 'Neoplasms',\n",
       " 'rna virus infections',\n",
       " 'erysipeloid',\n",
       " 'defense mechanisms',\n",
       " 'mental competency',\n",
       " 'hemostatic disorders',\n",
       " 'reproductive',\n",
       " 'Phagocytes',\n",
       " 'hearing disorders',\n",
       " 'mental health recovery',\n",
       " 'keratosis',\n",
       " 'juvenile dermatomyositis',\n",
       " 'tonsillitis',\n",
       " 'immunosuppressed',\n",
       " 'congestive heart failure',\n",
       " 'Critical Care',\n",
       " 'wound infection',\n",
       " 'arteriovenous malformations',\n",
       " 'Neurology',\n",
       " 'Thyroid Diseases',\n",
       " 'ischemic heart disease',\n",
       " 'encephalomyelitis',\n",
       " 'Esophagus',\n",
       " 'behavioral sciences',\n",
       " 'Analgesia',\n",
       " 'clindamycin',\n",
       " 'Pharmacoepidemiology',\n",
       " 'hypereosinophilic syndrome',\n",
       " 'liver transplantation',\n",
       " 'ipilimumab',\n",
       " 'anastrozole',\n",
       " 'Biliary Tract',\n",
       " 'hyperventilation',\n",
       " 'Neuropathology',\n",
       " 'debridement',\n",
       " 'pulmonary edema',\n",
       " 'laser therapy',\n",
       " 'hordeolum',\n",
       " 'acanthamoeba keratitis',\n",
       " 'Sports Medicine',\n",
       " 'neurological disorders',\n",
       " 'pleurisy',\n",
       " 'nasal bone',\n",
       " 'triple therapy',\n",
       " 'copd',\n",
       " 'autoimmune diseases',\n",
       " 'Fatal Familial',\n",
       " 'janus kinase 1',\n",
       " 'Medical Specialties',\n",
       " 'bone marrow',\n",
       " 'Myelodysplastic Syndromes',\n",
       " 'Ankylosis',\n",
       " 'rheumatoid',\n",
       " 'Psychiatry',\n",
       " 'Psychiatric Rehabilitation',\n",
       " 'laryngopharyngeal reflux',\n",
       " 'tract disease',\n",
       " 'catheterization',\n",
       " 'asymptomatic infections',\n",
       " 'pneumoconiosis',\n",
       " 'protein c deficiency',\n",
       " 'Breathing Exercises',\n",
       " 'Abscess',\n",
       " 'Oral',\n",
       " 'Lymphoid Tissue',\n",
       " 'bacterial infections',\n",
       " 'general practitioners',\n",
       " 'Perfusion',\n",
       " 'elective surgical procedures',\n",
       " 'poems syndrome',\n",
       " 'Genetic Diseases',\n",
       " 'Eye Infections',\n",
       " 'digestive system neoplasms',\n",
       " 'Thyroid Cancer',\n",
       " 'Experimental',\n",
       " 'clinical pathology',\n",
       " 'myelodysplastic syndromes',\n",
       " 'hemothorax',\n",
       " 'embolic stroke',\n",
       " 'hyperthyroidism',\n",
       " 'Thyrotoxicosis',\n",
       " 'cardiovascular disease',\n",
       " 'fatigue syndrome',\n",
       " 'coinfection',\n",
       " 'h1n1',\n",
       " 'intestinal diseases',\n",
       " 'intestine',\n",
       " 'Gastrointestinal Diseases',\n",
       " 'nivolumab',\n",
       " 'cysts',\n",
       " 'patient care',\n",
       " 'perinatology',\n",
       " 'virus',\n",
       " 'rubella',\n",
       " 'gastrointestinal tracts',\n",
       " 'cns',\n",
       " 'tularemia',\n",
       " 'nasopharyngitis',\n",
       " 'Bone Diseases',\n",
       " 'Cellulitis',\n",
       " 'FIBRINOGEN',\n",
       " 'epidural',\n",
       " 'ruptured',\n",
       " 'aortic aneurysm',\n",
       " 'health personnel',\n",
       " 'Conscious Sedation',\n",
       " 'sarcoma',\n",
       " 'Attitude',\n",
       " 'livedo reticularis',\n",
       " 'postoperative complications',\n",
       " 'numbness',\n",
       " 'zoonoses',\n",
       " 'pelvic infection',\n",
       " 'post-traumatic',\n",
       " 'self-management',\n",
       " 'vascular diseases',\n",
       " 'child well-being',\n",
       " 'aids dementia complex',\n",
       " 'eosinophilic',\n",
       " 'turbinates',\n",
       " 'Reperfusion',\n",
       " 'Restless Legs Syndrome',\n",
       " 'anticoagulants',\n",
       " 'severe eosinophilic asthma',\n",
       " 'wheezing',\n",
       " 'Dendritic Cells',\n",
       " 'erythema infectiosum',\n",
       " 'Behavioral Sciences',\n",
       " 'Heart Block',\n",
       " 'back pain',\n",
       " 'encephalopathy',\n",
       " 'intestines',\n",
       " 'lassa fever',\n",
       " 'dermatology',\n",
       " 'strokes',\n",
       " 'Adrenal Insufficiency',\n",
       " 'ventricular fibrillation',\n",
       " 'Refractory',\n",
       " 'bronchiolitis',\n",
       " 'ophthalmology',\n",
       " 'pancreas',\n",
       " 'bronchopulmonary dysplasia',\n",
       " 'Jejunum',\n",
       " 'Anetoderma',\n",
       " 'Intestines',\n",
       " 'Ventricular Fibrillation',\n",
       " 'hydrocortisone',\n",
       " 'new',\n",
       " 'large intestine',\n",
       " 'venous insufficiency',\n",
       " 'prostaglandins',\n",
       " 'Lung',\n",
       " 'fever',\n",
       " 'shingles',\n",
       " 'neonatal intensive care',\n",
       " 'asthma',\n",
       " 'chemoprevention',\n",
       " 'coronary heart disease',\n",
       " 'Medical Oncology',\n",
       " 'bartonella infections',\n",
       " 'metabolic',\n",
       " 'infliximab',\n",
       " 'Arrhythmia',\n",
       " 'thromboplastin',\n",
       " 'dengue',\n",
       " 'aged',\n",
       " 'scarlet fever',\n",
       " 'tramadol',\n",
       " 'anxiety disorders',\n",
       " 'anthropometry',\n",
       " 'heparin',\n",
       " 'rash',\n",
       " 'venous thromboembolism',\n",
       " 'hepatic veno-occlusive disease',\n",
       " 'thymectomy',\n",
       " 'pain',\n",
       " 'blepharoplasty',\n",
       " 'allergens',\n",
       " 'neurodegenerative diseases',\n",
       " 'tetanus',\n",
       " 'intestinal mucosa',\n",
       " 'pregnancy complications',\n",
       " 'inhaled corticosteroids',\n",
       " 'advanced',\n",
       " 'Anesthesiology',\n",
       " 'gonorrhea',\n",
       " 'Clinical',\n",
       " 'Diabetes Mellitus',\n",
       " 'glycated hemoglobin',\n",
       " 'viremia',\n",
       " 'bone diseases',\n",
       " 'Choanal Atresia',\n",
       " 'wgs',\n",
       " 'varicocele',\n",
       " 'anesthesia',\n",
       " 'acyclovir',\n",
       " 'neoplastic',\n",
       " 'Sleep Deprivation',\n",
       " 'thyrotoxicosis',\n",
       " 'acos',\n",
       " 'tablet',\n",
       " 'Activated Protein C Resistance',\n",
       " 'Delivery',\n",
       " 'iliotibial band syndrome',\n",
       " 'new york heart association',\n",
       " 'erythema induratum',\n",
       " 'mycoplasma infections',\n",
       " 'Hypersensitivity',\n",
       " 'general practice',\n",
       " 'Trauma',\n",
       " 'patient',\n",
       " 'hepatitis',\n",
       " 'Sinus',\n",
       " 'Central Nervous System Infections',\n",
       " 'Health',\n",
       " 'Patient Care',\n",
       " 'Middle Ear',\n",
       " 'radiography',\n",
       " 'nasal septum',\n",
       " 'Health Care Professional',\n",
       " 'angioplasty',\n",
       " 'Prothrombin',\n",
       " 'laryngeal mask airway',\n",
       " 'pituitary apoplexy',\n",
       " 'heart transplantation',\n",
       " 'Cardiac Output',\n",
       " 'physical therapist',\n",
       " 'Bone Marrow',\n",
       " 'female',\n",
       " 'Lymphopenia',\n",
       " 'liver abscess',\n",
       " 'Diagnosis',\n",
       " 'neonatal sepsis',\n",
       " 'autoantibodies',\n",
       " 'cheyne-stokes respiration',\n",
       " 'lyme disease',\n",
       " 'Overweight',\n",
       " 'myocardial ischemia',\n",
       " 'ileum',\n",
       " 'hemorrhagic fever',\n",
       " 'Cardiac Rehabilitation',\n",
       " 'gfr',\n",
       " 'insulin resistance',\n",
       " 'Allergy Medications',\n",
       " 'yaws',\n",
       " 'atherosclerosis',\n",
       " 'noac',\n",
       " 'papillary',\n",
       " 'obstetrics & gynecology',\n",
       " 'herpes zoster',\n",
       " 'Asthma',\n",
       " 'stroke',\n",
       " 'Total',\n",
       " 'Kidney Diseases',\n",
       " 'Exercise Therapy',\n",
       " 'cardiometabolic risk',\n",
       " 'respiratory insufficiency',\n",
       " 'nocardia infections',\n",
       " 'Apnea',\n",
       " 'Diabetes Insipidus',\n",
       " 'joints',\n",
       " 'immunoglobulin g',\n",
       " 'aspergillosis',\n",
       " 'hepatitis d',\n",
       " 'thrombocytopenia',\n",
       " 'educational',\n",
       " 'sinusitis',\n",
       " 'drug development',\n",
       " 'spondylitis',\n",
       " 'immunoglobulin e',\n",
       " 'enhanced',\n",
       " 'neutropenia',\n",
       " 'rheumatic heart disease',\n",
       " 'reticuloendotheliosis',\n",
       " 'Myocardial Ischemia',\n",
       " 'early intervention',\n",
       " 'fpg',\n",
       " 'Intravenous',\n",
       " 'pseudoxanthoma elasticum',\n",
       " 'Hemorrhage',\n",
       " 'emotions',\n",
       " 'deficiency diseases',\n",
       " 'deep brain stimulation',\n",
       " 'disruptive',\n",
       " 'Seizures',\n",
       " 'Sleep Disorders',\n",
       " 'Blunt Cardiac Injury',\n",
       " 'lung abscess',\n",
       " 'pharynx',\n",
       " 'furunculosis',\n",
       " 'Corrective',\n",
       " 'hypopharynx',\n",
       " 'bronchopulmonary sequestration',\n",
       " 'dissecting',\n",
       " 'genomics',\n",
       " 'cysticercosis',\n",
       " 'body fluids',\n",
       " 'cryoglobulinemia',\n",
       " 'rabies',\n",
       " 'Starvation',\n",
       " 'tabes dorsalis',\n",
       " 'psychiatry',\n",
       " 'dna sequencing',\n",
       " 'Immune System',\n",
       " 'endurance training',\n",
       " 'Neuropathologists',\n",
       " 'takotsubo cardiomyopathy',\n",
       " 'End-Of-Life Care',\n",
       " 'protein folding',\n",
       " 'hospitals',\n",
       " 'broadly neutralizing antibodies',\n",
       " 'vocal cord dysfunction',\n",
       " 'eye infections',\n",
       " 'Educational',\n",
       " 'heart defects',\n",
       " 'congenital',\n",
       " 'Hepatology',\n",
       " 'Stomach',\n",
       " 'echinococcosis',\n",
       " 'Vascular Malformations',\n",
       " 'hematology & oncology',\n",
       " 'Flu',\n",
       " 'Percutaneous Transluminal',\n",
       " 'arrhythmogenic right ventricular dysplasia',\n",
       " 'Family Practice',\n",
       " 'post-exposure prophylaxis',\n",
       " 'leukoencephalopathy',\n",
       " 'cefixime',\n",
       " 'doctor',\n",
       " 'celecoxib',\n",
       " 'candidemia',\n",
       " 'intrinsic',\n",
       " 'translocation',\n",
       " 'kidney diseases',\n",
       " 'Gastrointestinal Tract',\n",
       " 'citalopram',\n",
       " 'sitagliptin',\n",
       " 'Specialties',\n",
       " 'lymphopenia',\n",
       " 'Congenital',\n",
       " 'pregnancy',\n",
       " 'foot deformities',\n",
       " 'intravenous',\n",
       " 'overweight',\n",
       " 'formulation',\n",
       " 'molecular diagnostics',\n",
       " 'Myopathies',\n",
       " 'hoarseness',\n",
       " 'urogenital neoplasms',\n",
       " 'idiopathic pulmonary fibrosis',\n",
       " 'analgesia',\n",
       " 'Angiotensin',\n",
       " 'immunoglobulin a',\n",
       " 'prothrombin time',\n",
       " 'light sensitivity',\n",
       " 'dpp-4',\n",
       " 'Dental',\n",
       " 'neuromyelitis optica',\n",
       " 'fabry disease',\n",
       " 'Bipolar and Related Disorders',\n",
       " 'smoldering multiple myeloma',\n",
       " 'common cold',\n",
       " 'pneumonia, viral',\n",
       " 'connective tissue diseases',\n",
       " 'Mental Processes',\n",
       " 'hypersensitivity',\n",
       " 'Atrial Flutter',\n",
       " 'disseminated intravascular coagulation',\n",
       " 'tachypnea',\n",
       " 'Molecular Pathology',\n",
       " 'hypoglycemia',\n",
       " 'severe asthma',\n",
       " 'burkitt lymphoma',\n",
       " 'surgical oncology',\n",
       " 'dirofilariasis',\n",
       " 'ventricular outflow obstruction',\n",
       " 'persistent left superior vena cava',\n",
       " 'granuloma',\n",
       " 'gingivitis',\n",
       " 'glomerular filtration rate',\n",
       " 'Liver',\n",
       " 'antithrombin iii deficiency',\n",
       " 'Eosinophilic Esophagitis',\n",
       " 'radiology',\n",
       " 'adrenal insufficiency',\n",
       " 'elimination disorders',\n",
       " 'molecular',\n",
       " 'oropharynx',\n",
       " 'Duodenum',\n",
       " 'hepatitis c',\n",
       " 'neoplasms',\n",
       " 'paraparesis',\n",
       " 'second primary',\n",
       " 'sleep disorders',\n",
       " 'perfusion',\n",
       " 'bisphosphonate-associated osteonecrosis of the jaw',\n",
       " 'acute lung injury',\n",
       " 'Salivary Gland',\n",
       " 'electrophysiology',\n",
       " 'Orthopedics',\n",
       " 'Dissociative Disorders',\n",
       " 'strongyloidiasis',\n",
       " 'lymphatic vessels',\n",
       " 'health education',\n",
       " 'appendicitis',\n",
       " 'deep vein thrombosis',\n",
       " 'transplants',\n",
       " 'waldenstrom macroglobulinemia',\n",
       " 'Dentition',\n",
       " 'sinus',\n",
       " 'infectious mononucleosis',\n",
       " 'Orthodontic Appliances',\n",
       " 'Arthritis',\n",
       " 'tracheitis',\n",
       " 'Monocytes',\n",
       " 'measles',\n",
       " 'atrioventricular block',\n",
       " 'Self-Management',\n",
       " 'Endodontics',\n",
       " 'dysphonia',\n",
       " 'flu vaccine',\n",
       " 'Surgical Intensive Care',\n",
       " 'cardiac tamponade',\n",
       " 'panitumumab',\n",
       " 'vaginosis',\n",
       " 'Aspergillosis',\n",
       " 'staphylococcus aureus',\n",
       " 'Intracranial Aneurysm',\n",
       " 'Shock',\n",
       " 'neutrophils',\n",
       " 'chromoblastomycosis',\n",
       " 'ranibizumab',\n",
       " 'Inborn',\n",
       " 'Hematology',\n",
       " 'keratoconjunctivitis',\n",
       " 'macrophages',\n",
       " 'joint pain',\n",
       " 'esophagus',\n",
       " 'bevacizumab',\n",
       " 'vaccination coverage',\n",
       " 'ascariasis',\n",
       " 'Early Goal-Directed Therapy',\n",
       " 'non-steroidal anti-inflammatory drug',\n",
       " 'Myocardial Reperfusion',\n",
       " 'beta-thalassemia',\n",
       " 'mycoses',\n",
       " 'Cardiovascular',\n",
       " 'molluscum contagiosum',\n",
       " 'cellulitis',\n",
       " 'fanconi anemia',\n",
       " 'siderosis',\n",
       " 'neurosyphilis',\n",
       " 'Neonatal',\n",
       " 'bronchiectasis',\n",
       " 'ankylosis',\n",
       " 'ear diseases',\n",
       " 'hematuria',\n",
       " 'ehlers-danlos syndrome',\n",
       " 'proteomics',\n",
       " 'dentist',\n",
       " 'vitamin k antagonists',\n",
       " 'monoclonal antibody',\n",
       " 'ibuprofen',\n",
       " 'Neurosurgical Procedures',\n",
       " 'Neuromuscular Diseases',\n",
       " 'ruxolitinib',\n",
       " 'Hypervitaminosis A',\n",
       " 'Neoplastic',\n",
       " 'pleural effusion',\n",
       " 'factor xa inhibitor',\n",
       " 'vibrio infections',\n",
       " 'infertility',\n",
       " 'eosinophilia-myalgia syndrome',\n",
       " 'zoster sine herpete',\n",
       " 'Aneurysm',\n",
       " 'azithromycin',\n",
       " 'cardiotoxicity',\n",
       " 'wes',\n",
       " 'botulism',\n",
       " 'elderly',\n",
       " 'mucormycosis',\n",
       " 'Dermatology',\n",
       " 'purple',\n",
       " 'transplant',\n",
       " 'candidiasis',\n",
       " 'leprosy',\n",
       " 'impetigo',\n",
       " 'vte',\n",
       " 'Anti-Inflammatory Agents',\n",
       " 'cardiovascular infections',\n",
       " 'Kidney Transplantation',\n",
       " 'hyperemia',\n",
       " 'rubella syndrome',\n",
       " 'Rhinitis',\n",
       " 'Fasciitis',\n",
       " 'Airway Management',\n",
       " 'Denervation',\n",
       " 'coronaviridae infections',\n",
       " 'Small',\n",
       " 'Nervous System',\n",
       " 'migraine',\n",
       " 'epiglottitis',\n",
       " 'mumps',\n",
       " 'attitude',\n",
       " 'cardiac arrest',\n",
       " 'paraneoplastic syndromes',\n",
       " 'Hospitals',\n",
       " 'Seasonal',\n",
       " 'cystic fibrosis',\n",
       " 'blood loss',\n",
       " 'Carpal Tunnel Syndrome',\n",
       " 'Sideroblastic',\n",
       " 'epistaxis',\n",
       " 'Infertility',\n",
       " 'stomach',\n",
       " 'Aortic Aneurysm',\n",
       " 'social withdrawal',\n",
       " 'bacteremia',\n",
       " 'granuloma inguinale',\n",
       " 'varicella-zoster',\n",
       " 'intrahepatic',\n",
       " 'chronic kidney disease',\n",
       " 'Hematuria',\n",
       " 'abscess',\n",
       " 'plus',\n",
       " 'sturge-weber syndrome',\n",
       " 'pericardial effusion',\n",
       " 'psoriasis',\n",
       " 'vertebral artery dissection',\n",
       " 'fasciitis',\n",
       " 'conscious sedation',\n",
       " 'Pharmacogenomics',\n",
       " 'Preventive',\n",
       " 'paronychia',\n",
       " 'granuloma annulare',\n",
       " 'immunocompromised',\n",
       " 'rheumatic diseases',\n",
       " 'Pulmonary Medicine',\n",
       " 'Ruptured',\n",
       " 'Post-Traumatic',\n",
       " 'prothrombin',\n",
       " 'Multiple Sclerosis',\n",
       " 'False',\n",
       " 'mucocele',\n",
       " 'scurvy',\n",
       " 'vaccine',\n",
       " 'Intensive Care',\n",
       " 'sickle cell trait',\n",
       " 'Myocardial Infarction',\n",
       " 'chalazion',\n",
       " 'cardiac rehabilitation',\n",
       " 'Small Intestines',\n",
       " 'Methylprednisolone',\n",
       " 'neutron capture therapy',\n",
       " 'Multiple Myeloma',\n",
       " 'vitamin k deficiency',\n",
       " 'prediabetic state',\n",
       " 'oncology',\n",
       " 'arrhythmia',\n",
       " 'lung injury',\n",
       " 'operative',\n",
       " 'Thalassemia',\n",
       " 'nonvalvular atrial fibrillation',\n",
       " 'Pediatrics',\n",
       " 'thrombosis',\n",
       " 'Hemarthrosis',\n",
       " 'Bernard-Soulier Syndrome',\n",
       " 'radiotherapy',\n",
       " 'breathing exercises',\n",
       " 'improved',\n",
       " 'skin rash',\n",
       " 'preventive',\n",
       " 'bone marrow diseases',\n",
       " 'Acquired',\n",
       " 'Sternotomy',\n",
       " 'vocal cords',\n",
       " 'pulmonary disease',\n",
       " 'Primary Immunodeficiency Diseases',\n",
       " 'persistent infection',\n",
       " 'dapagliflozin',\n",
       " 'laryngeal edema',\n",
       " 'Laser',\n",
       " 'Resistance Training',\n",
       " 'Neoplasms by Site',\n",
       " 'Perinatology',\n",
       " 'staphylococcal scalded skin syndrome',\n",
       " 'skin infections',\n",
       " 'virus diseases',\n",
       " 'muscle relaxation',\n",
       " 'keratitis',\n",
       " 'arrhythmias',\n",
       " 'Graves Disease',\n",
       " 'cerebrovascular accident',\n",
       " 'rivaroxaban',\n",
       " 'temporomandibular joint',\n",
       " 'famciclovir',\n",
       " 'lupus',\n",
       " 'exercise therapy',\n",
       " 'coronary artery disease',\n",
       " 'porphyrias',\n",
       " 'Thymectomy',\n",
       " 'Radiography',\n",
       " 'pilonidal sinus',\n",
       " 'Intestine',\n",
       " 'myocarditis',\n",
       " 'genital herpes',\n",
       " 'motor neuron disease',\n",
       " 'Dissecting',\n",
       " 'thalassemia',\n",
       " 'frontal sinus',\n",
       " 'rheumatic fever',\n",
       " 'intracranial aneurysm',\n",
       " 'Papillary',\n",
       " 'veterinary medicine',\n",
       " 'diclofenac',\n",
       " 'Skin Diseases',\n",
       " 'leukopenia',\n",
       " 'whipple disease',\n",
       " 'patient-controlled',\n",
       " 'eosinophilia',\n",
       " 'vomiting',\n",
       " 'Epidural Analgesia',\n",
       " 'transfusion-related acute lung injury',\n",
       " 'paraproteinemias',\n",
       " 'herpes zoster oticus',\n",
       " 'Liver Transplantation',\n",
       " 'baloxavir marboxil',\n",
       " 'erectile dysfunction',\n",
       " 'dental',\n",
       " 'tetralogy of fallot',\n",
       " 'liver',\n",
       " 'resistance training',\n",
       " 'Keratoacanthoma',\n",
       " 'sports medicine',\n",
       " 'leukocytosis',\n",
       " 'vaccine-preventable diseases',\n",
       " 'tingling',\n",
       " 'Arthralgia',\n",
       " 'kidney transplantation',\n",
       " 'Immune Reconstitution Inflammatory Syndrome',\n",
       " 'Vocational',\n",
       " 'Pain Medicine',\n",
       " 'marfan syndrome',\n",
       " 'headache',\n",
       " 'Rheumatic Diseases',\n",
       " 'Maze Procedure',\n",
       " 'Hamartoma',\n",
       " \"parkinson's disease\",\n",
       " 'myelitis',\n",
       " 'Secondary Prevention',\n",
       " 'varicella zoster virus infection',\n",
       " 'bariatric surgery',\n",
       " 'gram-negative bacterial infections',\n",
       " 'Anemia',\n",
       " 'eye diseases',\n",
       " 'lupus anticoagulant',\n",
       " 'mitral valve prolapse',\n",
       " 'tinea pedis',\n",
       " 'clavulanic acid',\n",
       " 'ketorolac',\n",
       " 'leukemia',\n",
       " 'Abortion',\n",
       " 'muscle pain',\n",
       " 'Vascular Diseases',\n",
       " 'pulmonary arterial hypertension',\n",
       " 'acute coronary syndrome',\n",
       " 'Brugada Syndrome',\n",
       " 'pharmacist',\n",
       " 'Renal Transplantation',\n",
       " 'plague',\n",
       " 'enterocolitis',\n",
       " 'birth cohort',\n",
       " 'high-density lipoprotein cholesterol',\n",
       " 'peritonsillar abscess',\n",
       " 'Malabsorption Syndromes',\n",
       " 'surgery',\n",
       " 'Autoimmune Diseases',\n",
       " 'multiple sclerosis',\n",
       " 'decompression',\n",
       " 'scabies',\n",
       " 'varicella-zoster virus',\n",
       " 'Birth Cohort',\n",
       " 'varicella',\n",
       " 'Afibrinogenemia',\n",
       " 'nasal mucosa',\n",
       " 'cholera',\n",
       " 'doac',\n",
       " 'obstetrical',\n",
       " 'Preventive Medicine',\n",
       " 'general hospitals',\n",
       " 'dendritic cells',\n",
       " 'polycythemia vera',\n",
       " 'small',\n",
       " 'Strokes',\n",
       " 'Dissection',\n",
       " 'curettage',\n",
       " 'Antibiotic Prophylaxis',\n",
       " 'Chemoprevention',\n",
       " 'central nervous system infections',\n",
       " 'Patient-Controlled',\n",
       " 'ppg',\n",
       " 'Ischemic Heart Disease',\n",
       " 'Craniotomy',\n",
       " 'Earache',\n",
       " 'Early Intervention',\n",
       " 'hemoptysis',\n",
       " 'antigens',\n",
       " 'neurological surgery',\n",
       " 'Emergency Medicine',\n",
       " 'Liver Dysfunction',\n",
       " 'Child',\n",
       " 'dissociative disorders',\n",
       " 'the',\n",
       " 'dietetics',\n",
       " 'Anastomosis',\n",
       " 'child care',\n",
       " 'General Hospitals',\n",
       " 'gastrointestinal tract',\n",
       " 'rheumatoid arthritis',\n",
       " 'urinary tract infections',\n",
       " 'nephrology',\n",
       " 'embolism',\n",
       " 'polyarthritis',\n",
       " 'scrapie',\n",
       " 'atrial fibrillation',\n",
       " 'olfactory mucosa',\n",
       " 'proton therapy',\n",
       " 'medical oncology',\n",
       " 'hemorrhage',\n",
       " 'Health Personnel',\n",
       " 'dyspareunia',\n",
       " 'infected',\n",
       " 'hematology',\n",
       " 'Surgical Pathology',\n",
       " 'vzv',\n",
       " 'meningitis',\n",
       " 'herpes simplex',\n",
       " 'letrozole',\n",
       " 'General Practice',\n",
       " 'radiosurgery',\n",
       " 'interventional cardiology',\n",
       " 'Metabolic Diseases',\n",
       " 'activities of daily living',\n",
       " 'Gastroenterology',\n",
       " 'Adrenal Hyperplasia',\n",
       " 'neurologic manifestations',\n",
       " 'total',\n",
       " 'Neurologic Manifestations',\n",
       " 'inborn',\n",
       " 'weight reduction',\n",
       " 'moderate pain',\n",
       " 'myocardial infarction',\n",
       " 'allergic',\n",
       " 'clinical',\n",
       " 'angiotensin',\n",
       " 'cardiology',\n",
       " 'intratracheal',\n",
       " 'difficulty concentrating',\n",
       " 'janus kinase 2',\n",
       " 'brachytherapy',\n",
       " 'cough',\n",
       " 'acid-base imbalance',\n",
       " 'Heart Defects',\n",
       " 'arthralgia',\n",
       " 'technology',\n",
       " 'Primary Prevention',\n",
       " 'liver diseases',\n",
       " 'myeloproliferative neoplasms',\n",
       " 'Curettage',\n",
       " 'Epidural',\n",
       " 'intubation',\n",
       " 'radiation pneumonitis',\n",
       " 'Biliary Atresia',\n",
       " 'community-acquired pneumonia',\n",
       " 'adrenal hyperplasia',\n",
       " 'ventricular dysfunction',\n",
       " 'seasonal',\n",
       " 'Periodontics',\n",
       " 'tachycardia',\n",
       " 'h1n1 vaccine',\n",
       " 'reperfusion',\n",
       " 'thoracic surgery',\n",
       " 'Mental Health',\n",
       " 'cardiac failure',\n",
       " 'pe',\n",
       " \"alzheimer's disease\",\n",
       " 'PROTHROMBIN',\n",
       " 'emergency medicine',\n",
       " 'Dietician',\n",
       " 'Therapeutic Uses',\n",
       " 'retinal artery occlusion',\n",
       " 'herpes zoster ophthalmicus',\n",
       " 'Deep Sedation',\n",
       " 'immunization',\n",
       " 'thromboembolism',\n",
       " 'paracetamol',\n",
       " 'urologic diseases',\n",
       " 'Necrolytic Migratory Erythema',\n",
       " 'next-generation sequencing',\n",
       " 'Therapeutic Effects',\n",
       " 'drug therapy',\n",
       " 'Transluminal Angioplasty',\n",
       " 'Macrophages',\n",
       " 'Tooth Extraction',\n",
       " 'diphtheria',\n",
       " 'therapeutic effects',\n",
       " 'immunity',\n",
       " 'pulmonary medicine',\n",
       " 'psittacosis',\n",
       " 'poliomyelitis',\n",
       " 'Transplantation',\n",
       " 'neurosurgical procedures',\n",
       " 'drug discovery',\n",
       " 'pulmonary embolism',\n",
       " 'Altitude Sickness',\n",
       " 'Gastrointestinal Tracts',\n",
       " 'sporotrichosis',\n",
       " 'prion diseases',\n",
       " 'malnutrition',\n",
       " 'abatacept',\n",
       " 'pediatrics',\n",
       " 'false',\n",
       " 'digestive tract',\n",
       " 'Granuloma',\n",
       " 'brain abscess',\n",
       " 'circulating tumour dna',\n",
       " 'Thrombophilia',\n",
       " 'non-high-density lipoprotein cholesterol',\n",
       " 'Neuromuscular Blockade',\n",
       " 'Allergic Bronchopulmonary',\n",
       " 'Intrinsic',\n",
       " 'croup',\n",
       " 'chronic',\n",
       " 'Physical Medicine & Rehabilitation',\n",
       " 'renal transplantation',\n",
       " 'ischemic stroke',\n",
       " 'Ischemic Heart Diseases',\n",
       " 'Peripheral Nervous System Diseases',\n",
       " 'Hemothorax',\n",
       " 'Obstetric',\n",
       " 'anemia',\n",
       " 'blackwater fever',\n",
       " 'science',\n",
       " 'cefuroxime',\n",
       " 'airway obstruction',\n",
       " 'critical care',\n",
       " 'Cardiac',\n",
       " 'graves disease',\n",
       " 'abortion',\n",
       " 'monkeypox',\n",
       " 'disease',\n",
       " 'male',\n",
       " 'Pharmacogenetics',\n",
       " 'Premedication',\n",
       " 'herpes',\n",
       " 'vocal cord paralysis',\n",
       " 'Protein S Deficiency',\n",
       " 'neuropathology',\n",
       " 'sofosbuvir',\n",
       " 'Embolism',\n",
       " 'Granulomatous Disease',\n",
       " 'respiratory distress syndrome',\n",
       " 'cidofovir',\n",
       " 'polyangiitis',\n",
       " 'herpes zoster virus',\n",
       " 'filariasis',\n",
       " 'Aquatic Therapy',\n",
       " 'Ablation Techniques',\n",
       " 'valacyclovir',\n",
       " 'obstetric',\n",
       " 'high-dose trivalent influenza vaccine',\n",
       " 'Resuscitation',\n",
       " 'Lung Diseases',\n",
       " 'Hair Diseases',\n",
       " 'trauma',\n",
       " 'Cannulation',\n",
       " 'sepsis',\n",
       " 'cardiovascular risk reduction',\n",
       " 'hemorrhagic disorders',\n",
       " 'carney complex',\n",
       " 'Pregnancy Complications',\n",
       " 'Lung Transplantation',\n",
       " 'immune system',\n",
       " 'Drainage',\n",
       " 'Dermatomyositis',\n",
       " 'dysentery',\n",
       " 'ecchymosis',\n",
       " 'Neurogenic',\n",
       " 'secondary prevention',\n",
       " ...]"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#getting all the words to list\n",
    "all_keywords = train_df['KEYWORDS'].str.cat(sep='|')\n",
    "word_list = list(set(all_keywords.split('|')))\n",
    "\n",
    "# Removing empty value from word_list\n",
    "word_list = list(filter(None, word_list))\n",
    "\n",
    "\n",
    "list_size = len(word_list)\n",
    "print(\"Size of word_list:\", list_size)\n",
    "word_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "0bc6a1e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Iterate over each word in word_list\n",
    "# for word in word_list:\n",
    "#     # Create a new column with the word as the column name and initialize it with 0\n",
    "#     train_df[word] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "228632c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\1108022777.py:3: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n"
     ]
    }
   ],
   "source": [
    "for word in word_list:\n",
    "    train_df[word] = train_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "d81cf114",
   "metadata": {},
   "outputs": [
    {
     "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>BIDREQUESTIP</th>\n",
       "      <th>USERPLATFORMUID</th>\n",
       "      <th>USERCITY</th>\n",
       "      <th>USERZIPCODE</th>\n",
       "      <th>PLATFORMTYPE</th>\n",
       "      <th>URL</th>\n",
       "      <th>KEYWORDS</th>\n",
       "      <th>TAXONOMY</th>\n",
       "      <th>IS_HCP</th>\n",
       "      <th>Pre-Excitation Syndromes</th>\n",
       "      <th>...</th>\n",
       "      <th>Activities of Daily Living</th>\n",
       "      <th>thyroid carcinoma</th>\n",
       "      <th>coronary disease</th>\n",
       "      <th>Hepatic Transplantation</th>\n",
       "      <th>biomarkers</th>\n",
       "      <th>Surgical Oncology</th>\n",
       "      <th>Rheumatology</th>\n",
       "      <th>diabetes insipidus</th>\n",
       "      <th>respiratory tract disease</th>\n",
       "      <th>heart diseases</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>170.173.0.22</td>\n",
       "      <td>6974dcaa-f932-480e-9fb5-c52e20e1393a</td>\n",
       "      <td>Portland</td>\n",
       "      <td>97206.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/canc...</td>\n",
       "      <td>General|Endocrine|False|Medicine|Surgery|Urolo...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>65.216.253.25</td>\n",
       "      <td>c12f3f8f-8fcf-484a-90e1-1ac04db8cdcf</td>\n",
       "      <td>Arlington</td>\n",
       "      <td>22202.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/deci...</td>\n",
       "      <td>Bone Marrow|Radiography|Chronic|Oncology|Psych...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>66.232.79.22</td>\n",
       "      <td>a698de4b-e200-46dd-b5fb-40402175ae18</td>\n",
       "      <td>New Meadows</td>\n",
       "      <td>83654.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/canc...</td>\n",
       "      <td>General|Endocrine|False|Medicine|Surgery|Urolo...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>137.54.125.246</td>\n",
       "      <td>45967533-75c8-4fbd-a00c-e6ff20447aaa</td>\n",
       "      <td>None</td>\n",
       "      <td>229114624.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://globalrph.com/medcalcs/warfarin-mainte...</td>\n",
       "      <td>Dental|Total|Clinical|Pharmacology|Physicians|...</td>\n",
       "      <td>2084P0800X</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>174.202.231.99</td>\n",
       "      <td>a17e25be-532d-4cf5-b916-9308c8c3961f</td>\n",
       "      <td>Houston</td>\n",
       "      <td>77008.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cureus.com/articles/58184-a-review...</td>\n",
       "      <td>Critical Care|Emergency Medicine|General Pract...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>24.59.163.238</td>\n",
       "      <td>3b644d8f-b225-4ea3-b370-160ff7858749</td>\n",
       "      <td>Syracuse</td>\n",
       "      <td>13215.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cureus.com/articles/131022-the-imp...</td>\n",
       "      <td>small|covid|nephrology|radiology|preventive me...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>67.203.36.94</td>\n",
       "      <td>456631b8-ca59-4e7a-96a0-53bcbf85eaef</td>\n",
       "      <td>Los Angeles</td>\n",
       "      <td>90060.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.gastroenterologyadvisor.com/</td>\n",
       "      <td>Transplantation|Technology|Chronic|Neoplasms|U...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>24.28.40.219</td>\n",
       "      <td>1e84b963-2a2a-4e1a-a767-33867aa89bd4</td>\n",
       "      <td>Dallas</td>\n",
       "      <td>75204.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.clinicaladvisor.com/home/features/...</td>\n",
       "      <td>Family Practice|Drainage|Clinical|Dermatology|...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>104.172.116.202</td>\n",
       "      <td>be61a8f7-0f00-487f-8a56-679c819fa01a</td>\n",
       "      <td>Granada Hills</td>\n",
       "      <td>91344.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/deci...</td>\n",
       "      <td>Intensive Care|Shock|Ischemic Heart Disease|He...</td>\n",
       "      <td>2084P0804X</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>170.178.236.25</td>\n",
       "      <td>ddbea19a-fa49-4d3d-965a-bee29cbe92da</td>\n",
       "      <td>Davenport</td>\n",
       "      <td>52807.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://fpnotebook.com/Endo/Pharm/SgltInhbtr.htm</td>\n",
       "      <td>chronic kidney disease|nephrology|radiology|da...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>10 rows × 1622 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      BIDREQUESTIP                       USERPLATFORMUID       USERCITY  \\\n",
       "0     170.173.0.22  6974dcaa-f932-480e-9fb5-c52e20e1393a       Portland   \n",
       "1    65.216.253.25  c12f3f8f-8fcf-484a-90e1-1ac04db8cdcf      Arlington   \n",
       "2     66.232.79.22  a698de4b-e200-46dd-b5fb-40402175ae18    New Meadows   \n",
       "3   137.54.125.246  45967533-75c8-4fbd-a00c-e6ff20447aaa           None   \n",
       "4   174.202.231.99  a17e25be-532d-4cf5-b916-9308c8c3961f        Houston   \n",
       "5    24.59.163.238  3b644d8f-b225-4ea3-b370-160ff7858749       Syracuse   \n",
       "6     67.203.36.94  456631b8-ca59-4e7a-96a0-53bcbf85eaef    Los Angeles   \n",
       "7     24.28.40.219  1e84b963-2a2a-4e1a-a767-33867aa89bd4         Dallas   \n",
       "8  104.172.116.202  be61a8f7-0f00-487f-8a56-679c819fa01a  Granada Hills   \n",
       "9   170.178.236.25  ddbea19a-fa49-4d3d-965a-bee29cbe92da      Davenport   \n",
       "\n",
       "   USERZIPCODE            PLATFORMTYPE  \\\n",
       "0      97206.0  Online Medical Journal   \n",
       "1      22202.0  Online Medical Journal   \n",
       "2      83654.0  Online Medical Journal   \n",
       "3  229114624.0  Online Medical Journal   \n",
       "4      77008.0  Online Medical Journal   \n",
       "5      13215.0  Online Medical Journal   \n",
       "6      90060.0  Online Medical Journal   \n",
       "7      75204.0  Online Medical Journal   \n",
       "8      91344.0  Online Medical Journal   \n",
       "9      52807.0  Online Medical Journal   \n",
       "\n",
       "                                                 URL  \\\n",
       "0  https://www.cancertherapyadvisor.com/home/canc...   \n",
       "1  https://www.cancertherapyadvisor.com/home/deci...   \n",
       "2  https://www.cancertherapyadvisor.com/home/canc...   \n",
       "3  https://globalrph.com/medcalcs/warfarin-mainte...   \n",
       "4  https://www.cureus.com/articles/58184-a-review...   \n",
       "5  https://www.cureus.com/articles/131022-the-imp...   \n",
       "6           https://www.gastroenterologyadvisor.com/   \n",
       "7  https://www.clinicaladvisor.com/home/features/...   \n",
       "8  https://www.cancertherapyadvisor.com/home/deci...   \n",
       "9   https://fpnotebook.com/Endo/Pharm/SgltInhbtr.htm   \n",
       "\n",
       "                                            KEYWORDS    TAXONOMY  IS_HCP  \\\n",
       "0  General|Endocrine|False|Medicine|Surgery|Urolo...         NaN       0   \n",
       "1  Bone Marrow|Radiography|Chronic|Oncology|Psych...         NaN       0   \n",
       "2  General|Endocrine|False|Medicine|Surgery|Urolo...         NaN       0   \n",
       "3  Dental|Total|Clinical|Pharmacology|Physicians|...  2084P0800X       1   \n",
       "4  Critical Care|Emergency Medicine|General Pract...         NaN       0   \n",
       "5  small|covid|nephrology|radiology|preventive me...         NaN       0   \n",
       "6  Transplantation|Technology|Chronic|Neoplasms|U...         NaN       0   \n",
       "7  Family Practice|Drainage|Clinical|Dermatology|...         NaN       0   \n",
       "8  Intensive Care|Shock|Ischemic Heart Disease|He...  2084P0804X       1   \n",
       "9  chronic kidney disease|nephrology|radiology|da...         NaN       0   \n",
       "\n",
       "   Pre-Excitation Syndromes  ...  Activities of Daily Living  \\\n",
       "0                         0  ...                           0   \n",
       "1                         0  ...                           0   \n",
       "2                         0  ...                           0   \n",
       "3                         0  ...                           0   \n",
       "4                         0  ...                           0   \n",
       "5                         0  ...                           0   \n",
       "6                         0  ...                           0   \n",
       "7                         0  ...                           0   \n",
       "8                         0  ...                           0   \n",
       "9                         0  ...                           0   \n",
       "\n",
       "   thyroid carcinoma  coronary disease  Hepatic Transplantation  biomarkers  \\\n",
       "0                  0                 0                        0           0   \n",
       "1                  0                 0                        0           0   \n",
       "2                  0                 0                        0           0   \n",
       "3                  0                 0                        0           0   \n",
       "4                  0                 0                        0           0   \n",
       "5                  0                 0                        0           0   \n",
       "6                  0                 0                        1           0   \n",
       "7                  0                 0                        0           0   \n",
       "8                  0                 0                        0           0   \n",
       "9                  0                 0                        0           0   \n",
       "\n",
       "   Surgical Oncology  Rheumatology  diabetes insipidus  \\\n",
       "0                  0             1                   0   \n",
       "1                  0             1                   0   \n",
       "2                  0             1                   0   \n",
       "3                  0             0                   0   \n",
       "4                  0             1                   0   \n",
       "5                  0             0                   0   \n",
       "6                  0             1                   0   \n",
       "7                  0             1                   0   \n",
       "8                  0             1                   0   \n",
       "9                  0             0                   0   \n",
       "\n",
       "   respiratory tract disease  heart diseases  \n",
       "0                          0               0  \n",
       "1                          0               0  \n",
       "2                          0               0  \n",
       "3                          0               0  \n",
       "4                          0               0  \n",
       "5                          0               0  \n",
       "6                          0               0  \n",
       "7                          0               0  \n",
       "8                          0               0  \n",
       "9                          0               0  \n",
       "\n",
       "[10 rows x 1622 columns]"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "dad8caa9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#test\n",
    "train_df = train_df.drop('TAXONOMY', axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "3c741c48",
   "metadata": {},
   "outputs": [],
   "source": [
    "# train_df.to_csv('train_df_with_KEYWORDS_cols.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2c37e4b",
   "metadata": {},
   "source": [
    "# TAXANOMY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "c381cc48",
   "metadata": {},
   "outputs": [
    {
     "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>BIDREQUESTIP</th>\n",
       "      <th>USERPLATFORMUID</th>\n",
       "      <th>USERCITY</th>\n",
       "      <th>USERZIPCODE</th>\n",
       "      <th>PLATFORMTYPE</th>\n",
       "      <th>URL</th>\n",
       "      <th>KEYWORDS</th>\n",
       "      <th>IS_HCP</th>\n",
       "      <th>Pre-Excitation Syndromes</th>\n",
       "      <th>otitis media</th>\n",
       "      <th>...</th>\n",
       "      <th>Activities of Daily Living</th>\n",
       "      <th>thyroid carcinoma</th>\n",
       "      <th>coronary disease</th>\n",
       "      <th>Hepatic Transplantation</th>\n",
       "      <th>biomarkers</th>\n",
       "      <th>Surgical Oncology</th>\n",
       "      <th>Rheumatology</th>\n",
       "      <th>diabetes insipidus</th>\n",
       "      <th>respiratory tract disease</th>\n",
       "      <th>heart diseases</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>170.173.0.22</td>\n",
       "      <td>6974dcaa-f932-480e-9fb5-c52e20e1393a</td>\n",
       "      <td>Portland</td>\n",
       "      <td>97206.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/canc...</td>\n",
       "      <td>General|Endocrine|False|Medicine|Surgery|Urolo...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>65.216.253.25</td>\n",
       "      <td>c12f3f8f-8fcf-484a-90e1-1ac04db8cdcf</td>\n",
       "      <td>Arlington</td>\n",
       "      <td>22202.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/deci...</td>\n",
       "      <td>Bone Marrow|Radiography|Chronic|Oncology|Psych...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>66.232.79.22</td>\n",
       "      <td>a698de4b-e200-46dd-b5fb-40402175ae18</td>\n",
       "      <td>New Meadows</td>\n",
       "      <td>83654.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/canc...</td>\n",
       "      <td>General|Endocrine|False|Medicine|Surgery|Urolo...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>137.54.125.246</td>\n",
       "      <td>45967533-75c8-4fbd-a00c-e6ff20447aaa</td>\n",
       "      <td>None</td>\n",
       "      <td>229114624.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://globalrph.com/medcalcs/warfarin-mainte...</td>\n",
       "      <td>Dental|Total|Clinical|Pharmacology|Physicians|...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>174.202.231.99</td>\n",
       "      <td>a17e25be-532d-4cf5-b916-9308c8c3961f</td>\n",
       "      <td>Houston</td>\n",
       "      <td>77008.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cureus.com/articles/58184-a-review...</td>\n",
       "      <td>Critical Care|Emergency Medicine|General Pract...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 1621 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     BIDREQUESTIP                       USERPLATFORMUID     USERCITY  \\\n",
       "0    170.173.0.22  6974dcaa-f932-480e-9fb5-c52e20e1393a     Portland   \n",
       "1   65.216.253.25  c12f3f8f-8fcf-484a-90e1-1ac04db8cdcf    Arlington   \n",
       "2    66.232.79.22  a698de4b-e200-46dd-b5fb-40402175ae18  New Meadows   \n",
       "3  137.54.125.246  45967533-75c8-4fbd-a00c-e6ff20447aaa         None   \n",
       "4  174.202.231.99  a17e25be-532d-4cf5-b916-9308c8c3961f      Houston   \n",
       "\n",
       "   USERZIPCODE            PLATFORMTYPE  \\\n",
       "0      97206.0  Online Medical Journal   \n",
       "1      22202.0  Online Medical Journal   \n",
       "2      83654.0  Online Medical Journal   \n",
       "3  229114624.0  Online Medical Journal   \n",
       "4      77008.0  Online Medical Journal   \n",
       "\n",
       "                                                 URL  \\\n",
       "0  https://www.cancertherapyadvisor.com/home/canc...   \n",
       "1  https://www.cancertherapyadvisor.com/home/deci...   \n",
       "2  https://www.cancertherapyadvisor.com/home/canc...   \n",
       "3  https://globalrph.com/medcalcs/warfarin-mainte...   \n",
       "4  https://www.cureus.com/articles/58184-a-review...   \n",
       "\n",
       "                                            KEYWORDS  IS_HCP  \\\n",
       "0  General|Endocrine|False|Medicine|Surgery|Urolo...       0   \n",
       "1  Bone Marrow|Radiography|Chronic|Oncology|Psych...       0   \n",
       "2  General|Endocrine|False|Medicine|Surgery|Urolo...       0   \n",
       "3  Dental|Total|Clinical|Pharmacology|Physicians|...       1   \n",
       "4  Critical Care|Emergency Medicine|General Pract...       0   \n",
       "\n",
       "   Pre-Excitation Syndromes  otitis media  ...  Activities of Daily Living  \\\n",
       "0                         0             0  ...                           0   \n",
       "1                         0             0  ...                           0   \n",
       "2                         0             0  ...                           0   \n",
       "3                         0             0  ...                           0   \n",
       "4                         0             0  ...                           0   \n",
       "\n",
       "   thyroid carcinoma  coronary disease  Hepatic Transplantation  biomarkers  \\\n",
       "0                  0                 0                        0           0   \n",
       "1                  0                 0                        0           0   \n",
       "2                  0                 0                        0           0   \n",
       "3                  0                 0                        0           0   \n",
       "4                  0                 0                        0           0   \n",
       "\n",
       "   Surgical Oncology  Rheumatology  diabetes insipidus  \\\n",
       "0                  0             1                   0   \n",
       "1                  0             1                   0   \n",
       "2                  0             1                   0   \n",
       "3                  0             0                   0   \n",
       "4                  0             1                   0   \n",
       "\n",
       "   respiratory tract disease  heart diseases  \n",
       "0                          0               0  \n",
       "1                          0               0  \n",
       "2                          0               0  \n",
       "3                          0               0  \n",
       "4                          0               0  \n",
       "\n",
       "[5 rows x 1621 columns]"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "fd87e890",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "# # Create an instance of LabelEncoder\n",
    "# label_encoder = LabelEncoder()\n",
    "\n",
    "# # Fit and transform the 'KEYWORDS' column\n",
    "# train_df['TAXONOMY_ENCODED'] = label_encoder.fit_transform(train_df['TAXONOMY'])\n",
    "\n",
    "# # Display the encoded values\n",
    "# print(train_df['TAXONOMY_ENCODED'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "0aad1569",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import pandas as pd\n",
    "\n",
    "# # Compute the correlation matrix\n",
    "# correlation_matrix = train_df[['TAXONOMY_ENCODED'] + [\n",
    "#     'diabetic retinopathy',\n",
    "#     'Total',\n",
    "#     'lung diseases',\n",
    "#     'arrhythmias',\n",
    "#     'glanders',\n",
    "#     'fasting plasma glucose',\n",
    "#     'Bradycardia',\n",
    "#     'Tachycardia',\n",
    "#     'herbal medicine',\n",
    "#     'actinomycosis'\n",
    "# ]].corr()\n",
    "\n",
    "# # Display the correlation matrix\n",
    "# print(correlation_matrix)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "e7f47946",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import pandas as pd\n",
    "# import seaborn as sns\n",
    "# import matplotlib.pyplot as plt\n",
    "\n",
    "# # Compute the correlation matrix\n",
    "# correlation_matrix = train_df[['TAXONOMY_ENCODED'] + [\n",
    "#     'diabetic retinopathy',\n",
    "#     'Total',\n",
    "#     'lung diseases',\n",
    "#     'arrhythmias',\n",
    "#     'glanders',\n",
    "#     'fasting plasma glucose',\n",
    "#     'Bradycardia',\n",
    "#     'Tachycardia',\n",
    "#     'herbal medicine',\n",
    "#     'actinomycosis'\n",
    "# ]].corr()\n",
    "\n",
    "# # Plot the correlation matrix as a heatmap\n",
    "# plt.figure(figsize=(10, 8))\n",
    "# sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', square=True)\n",
    "# plt.title('Correlation Matrix')\n",
    "# plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "7c21aece",
   "metadata": {},
   "outputs": [
    {
     "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>BIDREQUESTIP</th>\n",
       "      <th>USERPLATFORMUID</th>\n",
       "      <th>USERCITY</th>\n",
       "      <th>USERZIPCODE</th>\n",
       "      <th>PLATFORMTYPE</th>\n",
       "      <th>URL</th>\n",
       "      <th>KEYWORDS</th>\n",
       "      <th>IS_HCP</th>\n",
       "      <th>Pre-Excitation Syndromes</th>\n",
       "      <th>otitis media</th>\n",
       "      <th>...</th>\n",
       "      <th>Activities of Daily Living</th>\n",
       "      <th>thyroid carcinoma</th>\n",
       "      <th>coronary disease</th>\n",
       "      <th>Hepatic Transplantation</th>\n",
       "      <th>biomarkers</th>\n",
       "      <th>Surgical Oncology</th>\n",
       "      <th>Rheumatology</th>\n",
       "      <th>diabetes insipidus</th>\n",
       "      <th>respiratory tract disease</th>\n",
       "      <th>heart diseases</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>170.173.0.22</td>\n",
       "      <td>6974dcaa-f932-480e-9fb5-c52e20e1393a</td>\n",
       "      <td>Portland</td>\n",
       "      <td>97206.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/canc...</td>\n",
       "      <td>General|Endocrine|False|Medicine|Surgery|Urolo...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>65.216.253.25</td>\n",
       "      <td>c12f3f8f-8fcf-484a-90e1-1ac04db8cdcf</td>\n",
       "      <td>Arlington</td>\n",
       "      <td>22202.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/deci...</td>\n",
       "      <td>Bone Marrow|Radiography|Chronic|Oncology|Psych...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>66.232.79.22</td>\n",
       "      <td>a698de4b-e200-46dd-b5fb-40402175ae18</td>\n",
       "      <td>New Meadows</td>\n",
       "      <td>83654.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cancertherapyadvisor.com/home/canc...</td>\n",
       "      <td>General|Endocrine|False|Medicine|Surgery|Urolo...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>137.54.125.246</td>\n",
       "      <td>45967533-75c8-4fbd-a00c-e6ff20447aaa</td>\n",
       "      <td>None</td>\n",
       "      <td>229114624.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://globalrph.com/medcalcs/warfarin-mainte...</td>\n",
       "      <td>Dental|Total|Clinical|Pharmacology|Physicians|...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>174.202.231.99</td>\n",
       "      <td>a17e25be-532d-4cf5-b916-9308c8c3961f</td>\n",
       "      <td>Houston</td>\n",
       "      <td>77008.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cureus.com/articles/58184-a-review...</td>\n",
       "      <td>Critical Care|Emergency Medicine|General Pract...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>113932</th>\n",
       "      <td>68.82.97.126</td>\n",
       "      <td>051e4a06-4cb4-4b97-b0b1-d1c6a2b8e2c2</td>\n",
       "      <td>Philadelphia</td>\n",
       "      <td>19120.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.clinicaladvisor.com/home/consultat...</td>\n",
       "      <td>Cardiovascular|Clinical|False|Male|Oncology|Ps...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>113933</th>\n",
       "      <td>104.172.11.109</td>\n",
       "      <td>3289bba5-4a50-4b61-a5cc-68596bbdc2bf</td>\n",
       "      <td>Van Nuys</td>\n",
       "      <td>914014213.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.clinicaladvisor.com/home/features/...</td>\n",
       "      <td>Asthma|Arthritis|General|Clinical|Diagnosis|Rh...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>113934</th>\n",
       "      <td>174.21.94.113</td>\n",
       "      <td>9c36e90c-caa7-4323-8431-fb84f8293972</td>\n",
       "      <td>Seattle</td>\n",
       "      <td>98105.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.cureus.com/articles/39455-whats-th...</td>\n",
       "      <td>Rehabilitation|Transplantation|Clinical|Preven...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>113935</th>\n",
       "      <td>69.253.129.131</td>\n",
       "      <td>afc27760-31f7-4f6e-aa08-90d8a96525d0</td>\n",
       "      <td>Wilmington</td>\n",
       "      <td>19808.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.dermatologyadvisor.com/home/topics...</td>\n",
       "      <td>pain|disease|autoimmune|multiple sclerosis|gra...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>113936</th>\n",
       "      <td>108.41.233.175</td>\n",
       "      <td>d26887c5-15f9-4b72-80dc-728039529e60</td>\n",
       "      <td>White Plains</td>\n",
       "      <td>10605.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "      <td>https://www.medicalbag.com/</td>\n",
       "      <td>Genetic|Large|Autoimmune|Health|False|Abortion...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>113933 rows × 1621 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "          BIDREQUESTIP                       USERPLATFORMUID      USERCITY  \\\n",
       "0         170.173.0.22  6974dcaa-f932-480e-9fb5-c52e20e1393a      Portland   \n",
       "1        65.216.253.25  c12f3f8f-8fcf-484a-90e1-1ac04db8cdcf     Arlington   \n",
       "2         66.232.79.22  a698de4b-e200-46dd-b5fb-40402175ae18   New Meadows   \n",
       "3       137.54.125.246  45967533-75c8-4fbd-a00c-e6ff20447aaa          None   \n",
       "4       174.202.231.99  a17e25be-532d-4cf5-b916-9308c8c3961f       Houston   \n",
       "...                ...                                   ...           ...   \n",
       "113932    68.82.97.126  051e4a06-4cb4-4b97-b0b1-d1c6a2b8e2c2  Philadelphia   \n",
       "113933  104.172.11.109  3289bba5-4a50-4b61-a5cc-68596bbdc2bf      Van Nuys   \n",
       "113934   174.21.94.113  9c36e90c-caa7-4323-8431-fb84f8293972       Seattle   \n",
       "113935  69.253.129.131  afc27760-31f7-4f6e-aa08-90d8a96525d0    Wilmington   \n",
       "113936  108.41.233.175  d26887c5-15f9-4b72-80dc-728039529e60  White Plains   \n",
       "\n",
       "        USERZIPCODE            PLATFORMTYPE  \\\n",
       "0           97206.0  Online Medical Journal   \n",
       "1           22202.0  Online Medical Journal   \n",
       "2           83654.0  Online Medical Journal   \n",
       "3       229114624.0  Online Medical Journal   \n",
       "4           77008.0  Online Medical Journal   \n",
       "...             ...                     ...   \n",
       "113932      19120.0  Online Medical Journal   \n",
       "113933  914014213.0  Online Medical Journal   \n",
       "113934      98105.0  Online Medical Journal   \n",
       "113935      19808.0  Online Medical Journal   \n",
       "113936      10605.0  Online Medical Journal   \n",
       "\n",
       "                                                      URL  \\\n",
       "0       https://www.cancertherapyadvisor.com/home/canc...   \n",
       "1       https://www.cancertherapyadvisor.com/home/deci...   \n",
       "2       https://www.cancertherapyadvisor.com/home/canc...   \n",
       "3       https://globalrph.com/medcalcs/warfarin-mainte...   \n",
       "4       https://www.cureus.com/articles/58184-a-review...   \n",
       "...                                                   ...   \n",
       "113932  https://www.clinicaladvisor.com/home/consultat...   \n",
       "113933  https://www.clinicaladvisor.com/home/features/...   \n",
       "113934  https://www.cureus.com/articles/39455-whats-th...   \n",
       "113935  https://www.dermatologyadvisor.com/home/topics...   \n",
       "113936                        https://www.medicalbag.com/   \n",
       "\n",
       "                                                 KEYWORDS  IS_HCP  \\\n",
       "0       General|Endocrine|False|Medicine|Surgery|Urolo...       0   \n",
       "1       Bone Marrow|Radiography|Chronic|Oncology|Psych...       0   \n",
       "2       General|Endocrine|False|Medicine|Surgery|Urolo...       0   \n",
       "3       Dental|Total|Clinical|Pharmacology|Physicians|...       1   \n",
       "4       Critical Care|Emergency Medicine|General Pract...       0   \n",
       "...                                                   ...     ...   \n",
       "113932  Cardiovascular|Clinical|False|Male|Oncology|Ps...       1   \n",
       "113933  Asthma|Arthritis|General|Clinical|Diagnosis|Rh...       1   \n",
       "113934  Rehabilitation|Transplantation|Clinical|Preven...       1   \n",
       "113935  pain|disease|autoimmune|multiple sclerosis|gra...       1   \n",
       "113936  Genetic|Large|Autoimmune|Health|False|Abortion...       1   \n",
       "\n",
       "        Pre-Excitation Syndromes  otitis media  ...  \\\n",
       "0                              0             0  ...   \n",
       "1                              0             0  ...   \n",
       "2                              0             0  ...   \n",
       "3                              0             0  ...   \n",
       "4                              0             0  ...   \n",
       "...                          ...           ...  ...   \n",
       "113932                         0             0  ...   \n",
       "113933                         0             0  ...   \n",
       "113934                         0             0  ...   \n",
       "113935                         0             0  ...   \n",
       "113936                         0             0  ...   \n",
       "\n",
       "        Activities of Daily Living  thyroid carcinoma  coronary disease  \\\n",
       "0                                0                  0                 0   \n",
       "1                                0                  0                 0   \n",
       "2                                0                  0                 0   \n",
       "3                                0                  0                 0   \n",
       "4                                0                  0                 0   \n",
       "...                            ...                ...               ...   \n",
       "113932                           0                  0                 0   \n",
       "113933                           0                  0                 0   \n",
       "113934                           0                  0                 0   \n",
       "113935                           0                  0                 0   \n",
       "113936                           0                  0                 0   \n",
       "\n",
       "        Hepatic Transplantation  biomarkers  Surgical Oncology  Rheumatology  \\\n",
       "0                             0           0                  0             1   \n",
       "1                             0           0                  0             1   \n",
       "2                             0           0                  0             1   \n",
       "3                             0           0                  0             0   \n",
       "4                             0           0                  0             1   \n",
       "...                         ...         ...                ...           ...   \n",
       "113932                        0           0                  0             1   \n",
       "113933                        0           0                  0             1   \n",
       "113934                        0           0                  0             1   \n",
       "113935                        0           0                  0             0   \n",
       "113936                        0           0                  0             1   \n",
       "\n",
       "        diabetes insipidus  respiratory tract disease  heart diseases  \n",
       "0                        0                          0               0  \n",
       "1                        0                          0               0  \n",
       "2                        0                          0               0  \n",
       "3                        0                          0               0  \n",
       "4                        0                          0               0  \n",
       "...                    ...                        ...             ...  \n",
       "113932                   0                          0               0  \n",
       "113933                   0                          0               0  \n",
       "113934                   0                          0               0  \n",
       "113935                   0                          0               0  \n",
       "113936                   0                          0               0  \n",
       "\n",
       "[113933 rows x 1621 columns]"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "4928976c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\gagan\\AppData\\Roaming\\Python\\Python310\\site-packages\\sklearn\\preprocessing\\_encoders.py:868: FutureWarning: `sparse` was renamed to `sparse_output` in version 1.2 and will be removed in 1.4. `sparse_output` is ignored unless you leave `sparse` to its default value.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          BIDREQUESTIP                       USERPLATFORMUID      USERCITY  \\\n",
      "0         170.173.0.22  6974dcaa-f932-480e-9fb5-c52e20e1393a      Portland   \n",
      "1        65.216.253.25  c12f3f8f-8fcf-484a-90e1-1ac04db8cdcf     Arlington   \n",
      "2         66.232.79.22  a698de4b-e200-46dd-b5fb-40402175ae18   New Meadows   \n",
      "3       137.54.125.246  45967533-75c8-4fbd-a00c-e6ff20447aaa          None   \n",
      "4       174.202.231.99  a17e25be-532d-4cf5-b916-9308c8c3961f       Houston   \n",
      "...                ...                                   ...           ...   \n",
      "113936  108.41.233.175  d26887c5-15f9-4b72-80dc-728039529e60  White Plains   \n",
      "59158              NaN                                   NaN           NaN   \n",
      "80923              NaN                                   NaN           NaN   \n",
      "99416              NaN                                   NaN           NaN   \n",
      "102512             NaN                                   NaN           NaN   \n",
      "\n",
      "        USERZIPCODE            PLATFORMTYPE  \\\n",
      "0           97206.0  Online Medical Journal   \n",
      "1           22202.0  Online Medical Journal   \n",
      "2           83654.0  Online Medical Journal   \n",
      "3       229114624.0  Online Medical Journal   \n",
      "4           77008.0  Online Medical Journal   \n",
      "...             ...                     ...   \n",
      "113936      10605.0  Online Medical Journal   \n",
      "59158           NaN                     NaN   \n",
      "80923           NaN                     NaN   \n",
      "99416           NaN                     NaN   \n",
      "102512          NaN                     NaN   \n",
      "\n",
      "                                                      URL  \\\n",
      "0       https://www.cancertherapyadvisor.com/home/canc...   \n",
      "1       https://www.cancertherapyadvisor.com/home/deci...   \n",
      "2       https://www.cancertherapyadvisor.com/home/canc...   \n",
      "3       https://globalrph.com/medcalcs/warfarin-mainte...   \n",
      "4       https://www.cureus.com/articles/58184-a-review...   \n",
      "...                                                   ...   \n",
      "113936                        https://www.medicalbag.com/   \n",
      "59158                                                 NaN   \n",
      "80923                                                 NaN   \n",
      "99416                                                 NaN   \n",
      "102512                                                NaN   \n",
      "\n",
      "                                                 KEYWORDS  IS_HCP  \\\n",
      "0       General|Endocrine|False|Medicine|Surgery|Urolo...     0.0   \n",
      "1       Bone Marrow|Radiography|Chronic|Oncology|Psych...     0.0   \n",
      "2       General|Endocrine|False|Medicine|Surgery|Urolo...     0.0   \n",
      "3       Dental|Total|Clinical|Pharmacology|Physicians|...     1.0   \n",
      "4       Critical Care|Emergency Medicine|General Pract...     0.0   \n",
      "...                                                   ...     ...   \n",
      "113936  Genetic|Large|Autoimmune|Health|False|Abortion...     1.0   \n",
      "59158                                                 NaN     NaN   \n",
      "80923                                                 NaN     NaN   \n",
      "99416                                                 NaN     NaN   \n",
      "102512                                                NaN     NaN   \n",
      "\n",
      "        Pre-Excitation Syndromes  otitis media  ...  Surgical Oncology  \\\n",
      "0                            0.0           0.0  ...                0.0   \n",
      "1                            0.0           0.0  ...                0.0   \n",
      "2                            0.0           0.0  ...                0.0   \n",
      "3                            0.0           0.0  ...                0.0   \n",
      "4                            0.0           0.0  ...                0.0   \n",
      "...                          ...           ...  ...                ...   \n",
      "113936                       0.0           0.0  ...                0.0   \n",
      "59158                        NaN           NaN  ...                NaN   \n",
      "80923                        NaN           NaN  ...                NaN   \n",
      "99416                        NaN           NaN  ...                NaN   \n",
      "102512                       NaN           NaN  ...                NaN   \n",
      "\n",
      "        Rheumatology  diabetes insipidus  respiratory tract disease  \\\n",
      "0                1.0                 0.0                        0.0   \n",
      "1                1.0                 0.0                        0.0   \n",
      "2                1.0                 0.0                        0.0   \n",
      "3                0.0                 0.0                        0.0   \n",
      "4                1.0                 0.0                        0.0   \n",
      "...              ...                 ...                        ...   \n",
      "113936           1.0                 0.0                        0.0   \n",
      "59158            NaN                 NaN                        NaN   \n",
      "80923            NaN                 NaN                        NaN   \n",
      "99416            NaN                 NaN                        NaN   \n",
      "102512           NaN                 NaN                        NaN   \n",
      "\n",
      "        heart diseases  Electronic Health Record  Medical News Platform  \\\n",
      "0                  0.0                       0.0                    0.0   \n",
      "1                  0.0                       0.0                    0.0   \n",
      "2                  0.0                       0.0                    0.0   \n",
      "3                  0.0                       0.0                    0.0   \n",
      "4                  0.0                       0.0                    0.0   \n",
      "...                ...                       ...                    ...   \n",
      "113936             0.0                       NaN                    NaN   \n",
      "59158              NaN                       0.0                    0.0   \n",
      "80923              NaN                       0.0                    0.0   \n",
      "99416              NaN                       0.0                    0.0   \n",
      "102512             NaN                       0.0                    0.0   \n",
      "\n",
      "        Online Learning Portal  Online Medical Journal  Tele-medicine Platform  \n",
      "0                          0.0                     1.0                     0.0  \n",
      "1                          0.0                     1.0                     0.0  \n",
      "2                          0.0                     1.0                     0.0  \n",
      "3                          0.0                     1.0                     0.0  \n",
      "4                          0.0                     1.0                     0.0  \n",
      "...                        ...                     ...                     ...  \n",
      "113936                     NaN                     NaN                     NaN  \n",
      "59158                      0.0                     1.0                     0.0  \n",
      "80923                      0.0                     1.0                     0.0  \n",
      "99416                      0.0                     1.0                     0.0  \n",
      "102512                     0.0                     1.0                     0.0  \n",
      "\n",
      "[113937 rows x 1626 columns]\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "\n",
    "encoder = OneHotEncoder(sparse=False)\n",
    "platform_type = train_df['PLATFORMTYPE'].values.reshape(-1, 1)\n",
    "encoded_features = encoder.fit_transform(platform_type)\n",
    "encoded_df = pd.DataFrame(encoded_features, columns=encoder.categories_[0])\n",
    "\n",
    "\n",
    "df_encoded = pd.concat([train_df, encoded_df], axis=1)\n",
    "\n",
    "\n",
    "print(df_encoded)\n",
    "train_df = df_encoded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "aa67183a",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df.drop('PLATFORMTYPE', axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "0a297533",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(113937, 1625)"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "e215b8f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['BIDREQUESTIP', 'USERPLATFORMUID', 'USERCITY', 'USERZIPCODE', 'URL',\n",
       "       'KEYWORDS', 'IS_HCP', 'Pre-Excitation Syndromes', 'otitis media',\n",
       "       'metabolic syndrome',\n",
       "       ...\n",
       "       'Surgical Oncology', 'Rheumatology', 'diabetes insipidus',\n",
       "       'respiratory tract disease', 'heart diseases',\n",
       "       'Electronic Health Record', 'Medical News Platform',\n",
       "       'Online Learning Portal', 'Online Medical Journal',\n",
       "       'Tele-medicine Platform'],\n",
       "      dtype='object', length=1625)"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "5e93a55d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5929"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df['USERCITY'].isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "89d422ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4596"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df['USERZIPCODE'].isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "4cc588e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df.dropna(subset=['USERCITY'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "47acacdc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(108008, 1625)"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "9aadfbe2",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df.dropna(subset=['USERZIPCODE'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "bdfe33fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(108006, 1625)"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "b55368cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "columns_to_drop = ['BIDREQUESTIP', 'USERPLATFORMUID','URL','KEYWORDS']\n",
    "train_df.drop(columns_to_drop, axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "d905a811",
   "metadata": {},
   "outputs": [
    {
     "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>USERCITY</th>\n",
       "      <th>USERZIPCODE</th>\n",
       "      <th>IS_HCP</th>\n",
       "      <th>Pre-Excitation Syndromes</th>\n",
       "      <th>otitis media</th>\n",
       "      <th>metabolic syndrome</th>\n",
       "      <th>Hemoperitoneum</th>\n",
       "      <th>internal medicine</th>\n",
       "      <th>gastrointestinal diseases</th>\n",
       "      <th>Molecular Diagnostic</th>\n",
       "      <th>...</th>\n",
       "      <th>Surgical Oncology</th>\n",
       "      <th>Rheumatology</th>\n",
       "      <th>diabetes insipidus</th>\n",
       "      <th>respiratory tract disease</th>\n",
       "      <th>heart diseases</th>\n",
       "      <th>Electronic Health Record</th>\n",
       "      <th>Medical News Platform</th>\n",
       "      <th>Online Learning Portal</th>\n",
       "      <th>Online Medical Journal</th>\n",
       "      <th>Tele-medicine Platform</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Portland</td>\n",
       "      <td>97206.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Arlington</td>\n",
       "      <td>22202.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>New Meadows</td>\n",
       "      <td>83654.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Houston</td>\n",
       "      <td>77008.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Syracuse</td>\n",
       "      <td>13215.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 1621 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      USERCITY  USERZIPCODE  IS_HCP  Pre-Excitation Syndromes  otitis media  \\\n",
       "0     Portland      97206.0     0.0                       0.0           0.0   \n",
       "1    Arlington      22202.0     0.0                       0.0           0.0   \n",
       "2  New Meadows      83654.0     0.0                       0.0           0.0   \n",
       "4      Houston      77008.0     0.0                       0.0           0.0   \n",
       "5     Syracuse      13215.0     0.0                       0.0           0.0   \n",
       "\n",
       "   metabolic syndrome  Hemoperitoneum  internal medicine  \\\n",
       "0                 0.0             0.0                0.0   \n",
       "1                 0.0             0.0                0.0   \n",
       "2                 0.0             0.0                0.0   \n",
       "4                 0.0             0.0                0.0   \n",
       "5                 0.0             0.0                1.0   \n",
       "\n",
       "   gastrointestinal diseases  Molecular Diagnostic  ...  Surgical Oncology  \\\n",
       "0                        0.0                   0.0  ...                0.0   \n",
       "1                        0.0                   0.0  ...                0.0   \n",
       "2                        0.0                   0.0  ...                0.0   \n",
       "4                        0.0                   0.0  ...                0.0   \n",
       "5                        0.0                   0.0  ...                0.0   \n",
       "\n",
       "   Rheumatology  diabetes insipidus  respiratory tract disease  \\\n",
       "0           1.0                 0.0                        0.0   \n",
       "1           1.0                 0.0                        0.0   \n",
       "2           1.0                 0.0                        0.0   \n",
       "4           1.0                 0.0                        0.0   \n",
       "5           0.0                 0.0                        0.0   \n",
       "\n",
       "   heart diseases  Electronic Health Record  Medical News Platform  \\\n",
       "0             0.0                       0.0                    0.0   \n",
       "1             0.0                       0.0                    0.0   \n",
       "2             0.0                       0.0                    0.0   \n",
       "4             0.0                       0.0                    0.0   \n",
       "5             0.0                       0.0                    0.0   \n",
       "\n",
       "   Online Learning Portal  Online Medical Journal  Tele-medicine Platform  \n",
       "0                     0.0                     1.0                     0.0  \n",
       "1                     0.0                     1.0                     0.0  \n",
       "2                     0.0                     1.0                     0.0  \n",
       "4                     0.0                     1.0                     0.0  \n",
       "5                     0.0                     1.0                     0.0  \n",
       "\n",
       "[5 rows x 1621 columns]"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "964d2655",
   "metadata": {},
   "outputs": [
    {
     "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>USERCITY</th>\n",
       "      <th>USERZIPCODE</th>\n",
       "      <th>IS_HCP</th>\n",
       "      <th>Pre-Excitation Syndromes</th>\n",
       "      <th>otitis media</th>\n",
       "      <th>metabolic syndrome</th>\n",
       "      <th>Hemoperitoneum</th>\n",
       "      <th>internal medicine</th>\n",
       "      <th>gastrointestinal diseases</th>\n",
       "      <th>Molecular Diagnostic</th>\n",
       "      <th>...</th>\n",
       "      <th>Surgical Oncology</th>\n",
       "      <th>Rheumatology</th>\n",
       "      <th>diabetes insipidus</th>\n",
       "      <th>respiratory tract disease</th>\n",
       "      <th>heart diseases</th>\n",
       "      <th>Electronic Health Record</th>\n",
       "      <th>Medical News Platform</th>\n",
       "      <th>Online Learning Portal</th>\n",
       "      <th>Online Medical Journal</th>\n",
       "      <th>Tele-medicine Platform</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3176</td>\n",
       "      <td>8934</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>130</td>\n",
       "      <td>2207</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2700</td>\n",
       "      <td>7585</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1766</td>\n",
       "      <td>7018</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>3877</td>\n",
       "      <td>1351</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 1621 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   USERCITY  USERZIPCODE  IS_HCP  Pre-Excitation Syndromes  otitis media  \\\n",
       "0      3176         8934     0.0                       0.0           0.0   \n",
       "1       130         2207     0.0                       0.0           0.0   \n",
       "2      2700         7585     0.0                       0.0           0.0   \n",
       "4      1766         7018     0.0                       0.0           0.0   \n",
       "5      3877         1351     0.0                       0.0           0.0   \n",
       "\n",
       "   metabolic syndrome  Hemoperitoneum  internal medicine  \\\n",
       "0                 0.0             0.0                0.0   \n",
       "1                 0.0             0.0                0.0   \n",
       "2                 0.0             0.0                0.0   \n",
       "4                 0.0             0.0                0.0   \n",
       "5                 0.0             0.0                1.0   \n",
       "\n",
       "   gastrointestinal diseases  Molecular Diagnostic  ...  Surgical Oncology  \\\n",
       "0                        0.0                   0.0  ...                0.0   \n",
       "1                        0.0                   0.0  ...                0.0   \n",
       "2                        0.0                   0.0  ...                0.0   \n",
       "4                        0.0                   0.0  ...                0.0   \n",
       "5                        0.0                   0.0  ...                0.0   \n",
       "\n",
       "   Rheumatology  diabetes insipidus  respiratory tract disease  \\\n",
       "0           1.0                 0.0                        0.0   \n",
       "1           1.0                 0.0                        0.0   \n",
       "2           1.0                 0.0                        0.0   \n",
       "4           1.0                 0.0                        0.0   \n",
       "5           0.0                 0.0                        0.0   \n",
       "\n",
       "   heart diseases  Electronic Health Record  Medical News Platform  \\\n",
       "0             0.0                       0.0                    0.0   \n",
       "1             0.0                       0.0                    0.0   \n",
       "2             0.0                       0.0                    0.0   \n",
       "4             0.0                       0.0                    0.0   \n",
       "5             0.0                       0.0                    0.0   \n",
       "\n",
       "   Online Learning Portal  Online Medical Journal  Tele-medicine Platform  \n",
       "0                     0.0                     1.0                     0.0  \n",
       "1                     0.0                     1.0                     0.0  \n",
       "2                     0.0                     1.0                     0.0  \n",
       "4                     0.0                     1.0                     0.0  \n",
       "5                     0.0                     1.0                     0.0  \n",
       "\n",
       "[5 rows x 1621 columns]"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "city_encoder = LabelEncoder()\n",
    "train_df['USERCITY'] = city_encoder.fit_transform(train_df['USERCITY'])\n",
    "\n",
    "\n",
    "zipcode_encoder = LabelEncoder()\n",
    "train_df['USERZIPCODE'] = zipcode_encoder.fit_transform(train_df['USERZIPCODE'])\n",
    "\n",
    "\n",
    "train_df.head(5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e92348e9",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'feature_engineered_train_data' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[102], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m X_train \u001b[39m=\u001b[39m feature_engineered_train_data\u001b[39m.\u001b[39mdrop(\u001b[39m'\u001b[39m\u001b[39mHCP\u001b[39m\u001b[39m'\u001b[39m, axis\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m)\n\u001b[0;32m      2\u001b[0m y_train \u001b[39m=\u001b[39m feature_engineered_train_data[\u001b[39m'\u001b[39m\u001b[39mHCP\u001b[39m\u001b[39m'\u001b[39m]\n\u001b[0;32m      4\u001b[0m \u001b[39m# Split the test dataset into features and target variable\u001b[39;00m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'feature_engineered_train_data' is not defined"
     ]
    }
   ],
   "source": [
    "# X_train = feature_engineered_train_data.drop('HCP', axis=1)\n",
    "# y_train = feature_engineered_train_data['HCP']\n",
    "\n",
    "# # Split the test dataset into features and target variable\n",
    "# X_test = feature_engineered_test_data.drop('HCP', axis=1)\n",
    "# y_test = feature_engineered_test_data['HCP']\n",
    "\n",
    "# # Define the XGBoost classifier\n",
    "# model = xgb.XGBClassifier()\n",
    "\n",
    "# # Train the model\n",
    "# model.fit(X_train, y_train)\n",
    "\n",
    "# # Make predictions on the test set\n",
    "# y_pred = model.predict(X_test)\n",
    "\n",
    "# # Evaluate the model\n",
    "# accuracy = accuracy_score(y_test, y_pred)\n",
    "# print(\"Accuracy: {:.2f}%\".format(accuracy * 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48a1ba28",
   "metadata": {},
   "source": [
    "Changes made for the test_df file in the below section:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6de5e8dd",
   "metadata": {},
   "outputs": [
    {
     "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>USERCITY</th>\n",
       "      <th>USERZIPCODE</th>\n",
       "      <th>PLATFORMTYPE</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Fayetteville</td>\n",
       "      <td>28305.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Conneaut Lake</td>\n",
       "      <td>16316.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Covina</td>\n",
       "      <td>91724.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Brooklyn</td>\n",
       "      <td>11226.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Marietta</td>\n",
       "      <td>30062.0</td>\n",
       "      <td>Online Medical Journal</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        USERCITY  USERZIPCODE            PLATFORMTYPE\n",
       "0   Fayetteville      28305.0  Online Medical Journal\n",
       "1  Conneaut Lake      16316.0  Online Medical Journal\n",
       "2         Covina      91724.0  Online Medical Journal\n",
       "3       Brooklyn      11226.0  Online Medical Journal\n",
       "4       Marietta      30062.0  Online Medical Journal"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_df.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "d3c4f0b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.preprocessing import OneHotEncoder, LabelEncoder\n",
    "\n",
    "columns_to_drop = ['ID', 'DEVICETYPE', 'PLATFORM_ID', 'CHANNELTYPE', 'USERAGENT',\n",
    "                   'BIDREQUESTIP', 'USERPLATFORMUID', 'URL']\n",
    "\n",
    "\n",
    "test_df.drop(columns=columns_to_drop, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "f53d414f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Local\\Temp\\ipykernel_18664\\2337676739.py:13: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
      "C:\\Users\\gagan\\AppData\\Roaming\\Python\\Python310\\site-packages\\sklearn\\preprocessing\\_encoders.py:868: FutureWarning: `sparse` was renamed to `sparse_output` in version 1.2 and will be removed in 1.4. `sparse_output` is ignored unless you leave `sparse` to its default value.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   USERCITY  USERZIPCODE  Pre-Excitation Syndromes  otitis media  \\\n",
      "0       857         1827                         0             0   \n",
      "1       559         1091                         0             0   \n",
      "2       592         5481                         0             0   \n",
      "3       323          739                         0             0   \n",
      "4      1609         2008                         0             0   \n",
      "\n",
      "   metabolic syndrome  Hemoperitoneum  internal medicine  \\\n",
      "0                   0               0                  0   \n",
      "1                   0               0                  0   \n",
      "2                   0               0                  0   \n",
      "3                   0               0                  0   \n",
      "4                   0               0                  0   \n",
      "\n",
      "   gastrointestinal diseases  Molecular Diagnostic  pneumothorax  ...  \\\n",
      "0                          0                     0             0  ...   \n",
      "1                          0                     0             0  ...   \n",
      "2                          0                     0             0  ...   \n",
      "3                          0                     0             0  ...   \n",
      "4                          0                     0             0  ...   \n",
      "\n",
      "   Hepatic Transplantation  biomarkers  Surgical Oncology  Rheumatology  \\\n",
      "0                        0           0                  0             1   \n",
      "1                        0           0                  0             0   \n",
      "2                        0           0                  0             0   \n",
      "3                        0           0                  0             1   \n",
      "4                        0           0                  0             0   \n",
      "\n",
      "   respiratory tract disease  heart diseases  Electronic Health Record  \\\n",
      "0                          0               0                       0.0   \n",
      "1                          0               0                       0.0   \n",
      "2                          0               0                       0.0   \n",
      "3                          0               0                       0.0   \n",
      "4                          0               0                       0.0   \n",
      "\n",
      "   Medical News Platform  Online Learning Portal  Online Medical Journal  \n",
      "0                    0.0                     0.0                     1.0  \n",
      "1                    0.0                     0.0                     1.0  \n",
      "2                    0.0                     0.0                     1.0  \n",
      "3                    0.0                     0.0                     1.0  \n",
      "4                    0.0                     0.0                     1.0  \n",
      "\n",
      "[5 rows x 1432 columns]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "test_df['USERCITY'] = test_df['USERCITY'].fillna(test_df.groupby('USERZIPCODE')['USERCITY'].transform('first'))\n",
    "\n",
    "all_keywords = test_df['KEYWORDS'].str.cat(sep='|')\n",
    "word_list = list(set(all_keywords.split('|')))\n",
    "\n",
    "\n",
    "word_list = list(filter(None, word_list))\n",
    "\n",
    "\n",
    "for word in word_list:\n",
    "    test_df[word] = test_df['KEYWORDS'].apply(lambda x: 1 if word in x else 0)\n",
    "\n",
    "\n",
    "columns_to_drop = ['KEYWORDS']\n",
    "test_df.drop(columns_to_drop, axis=1, inplace=True)\n",
    "\n",
    "\n",
    "encoder = OneHotEncoder(sparse=False)\n",
    "platform_type = test_df['PLATFORMTYPE'].values.reshape(-1, 1)\n",
    "encoded_features = encoder.fit_transform(platform_type)\n",
    "encoded_df = pd.DataFrame(encoded_features, columns=encoder.categories_[0])\n",
    "\n",
    "\n",
    "test_df = pd.concat([test_df, encoded_df], axis=1)\n",
    "\n",
    "\n",
    "test_df.drop('PLATFORMTYPE', axis=1, inplace=True)\n",
    "\n",
    "\n",
    "test_df.dropna(subset=['USERCITY', 'USERZIPCODE'], inplace=True)\n",
    "\n",
    "\n",
    "city_encoder = LabelEncoder()\n",
    "test_df['USERCITY'] = city_encoder.fit_transform(test_df['USERCITY'])\n",
    "\n",
    "zipcode_encoder = LabelEncoder()\n",
    "test_df['USERZIPCODE'] = zipcode_encoder.fit_transform(test_df['USERZIPCODE'])\n",
    "\n",
    "\n",
    "print(test_df.head(5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "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>USERCITY</th>\n",
       "      <th>USERZIPCODE</th>\n",
       "      <th>Pre-Excitation Syndromes</th>\n",
       "      <th>otitis media</th>\n",
       "      <th>metabolic syndrome</th>\n",
       "      <th>Hemoperitoneum</th>\n",
       "      <th>internal medicine</th>\n",
       "      <th>gastrointestinal diseases</th>\n",
       "      <th>Molecular Diagnostic</th>\n",
       "      <th>pneumothorax</th>\n",
       "      <th>...</th>\n",
       "      <th>Hepatic Transplantation</th>\n",
       "      <th>biomarkers</th>\n",
       "      <th>Surgical Oncology</th>\n",
       "      <th>Rheumatology</th>\n",
       "      <th>respiratory tract disease</th>\n",
       "      <th>heart diseases</th>\n",
       "      <th>Electronic Health Record</th>\n",
       "      <th>Medical News Platform</th>\n",
       "      <th>Online Learning Portal</th>\n",
       "      <th>Online Medical Journal</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>857</td>\n",
       "      <td>1827</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>559</td>\n",
       "      <td>1091</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>592</td>\n",
       "      <td>5481</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>323</td>\n",
       "      <td>739</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1609</td>\n",
       "      <td>2008</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28487</th>\n",
       "      <td>2436</td>\n",
       "      <td>5898</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28488</th>\n",
       "      <td>323</td>\n",
       "      <td>730</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28489</th>\n",
       "      <td>1693</td>\n",
       "      <td>2340</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28490</th>\n",
       "      <td>903</td>\n",
       "      <td>2355</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28492</th>\n",
       "      <td>2987</td>\n",
       "      <td>1844</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>27008 rows × 1432 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       USERCITY  USERZIPCODE  Pre-Excitation Syndromes  otitis media  \\\n",
       "0           857         1827                         0             0   \n",
       "1           559         1091                         0             0   \n",
       "2           592         5481                         0             0   \n",
       "3           323          739                         0             0   \n",
       "4          1609         2008                         0             0   \n",
       "...         ...          ...                       ...           ...   \n",
       "28487      2436         5898                         0             0   \n",
       "28488       323          730                         0             0   \n",
       "28489      1693         2340                         0             0   \n",
       "28490       903         2355                         0             0   \n",
       "28492      2987         1844                         0             0   \n",
       "\n",
       "       metabolic syndrome  Hemoperitoneum  internal medicine  \\\n",
       "0                       0               0                  0   \n",
       "1                       0               0                  0   \n",
       "2                       0               0                  0   \n",
       "3                       0               0                  0   \n",
       "4                       0               0                  0   \n",
       "...                   ...             ...                ...   \n",
       "28487                   0               0                  0   \n",
       "28488                   0               0                  0   \n",
       "28489                   0               0                  1   \n",
       "28490                   0               0                  1   \n",
       "28492                   0               0                  0   \n",
       "\n",
       "       gastrointestinal diseases  Molecular Diagnostic  pneumothorax  ...  \\\n",
       "0                              0                     0             0  ...   \n",
       "1                              0                     0             0  ...   \n",
       "2                              0                     0             0  ...   \n",
       "3                              0                     0             0  ...   \n",
       "4                              0                     0             0  ...   \n",
       "...                          ...                   ...           ...  ...   \n",
       "28487                          0                     0             0  ...   \n",
       "28488                          0                     0             0  ...   \n",
       "28489                          0                     0             0  ...   \n",
       "28490                          0                     0             0  ...   \n",
       "28492                          0                     0             0  ...   \n",
       "\n",
       "       Hepatic Transplantation  biomarkers  Surgical Oncology  Rheumatology  \\\n",
       "0                            0           0                  0             1   \n",
       "1                            0           0                  0             0   \n",
       "2                            0           0                  0             0   \n",
       "3                            0           0                  0             1   \n",
       "4                            0           0                  0             0   \n",
       "...                        ...         ...                ...           ...   \n",
       "28487                        0           0                  0             1   \n",
       "28488                        0           0                  0             1   \n",
       "28489                        0           0                  0             0   \n",
       "28490                        0           0                  0             0   \n",
       "28492                        0           0                  0             0   \n",
       "\n",
       "       respiratory tract disease  heart diseases  Electronic Health Record  \\\n",
       "0                              0               0                       0.0   \n",
       "1                              0               0                       0.0   \n",
       "2                              0               0                       0.0   \n",
       "3                              0               0                       0.0   \n",
       "4                              0               0                       0.0   \n",
       "...                          ...             ...                       ...   \n",
       "28487                          0               0                       0.0   \n",
       "28488                          0               0                       0.0   \n",
       "28489                          0               0                       0.0   \n",
       "28490                          0               0                       0.0   \n",
       "28492                          0               0                       0.0   \n",
       "\n",
       "       Medical News Platform  Online Learning Portal  Online Medical Journal  \n",
       "0                        0.0                     0.0                     1.0  \n",
       "1                        0.0                     0.0                     1.0  \n",
       "2                        0.0                     0.0                     1.0  \n",
       "3                        0.0                     0.0                     1.0  \n",
       "4                        0.0                     0.0                     1.0  \n",
       "...                      ...                     ...                     ...  \n",
       "28487                    0.0                     0.0                     1.0  \n",
       "28488                    0.0                     0.0                     1.0  \n",
       "28489                    0.0                     0.0                     1.0  \n",
       "28490                    0.0                     0.0                     1.0  \n",
       "28492                    0.0                     0.0                     1.0  \n",
       "\n",
       "[27008 rows x 1432 columns]"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(27008, 1432)\n",
      "(108006, 1621)\n"
     ]
    }
   ],
   "source": [
    "print(test_df.shape)\n",
    "print(train_df.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95842cce",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Feature shape mismatch, expected: 1620, got 1432",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[164], line 22\u001b[0m\n\u001b[0;32m     19\u001b[0m model\u001b[39m.\u001b[39mfit(X_train, y_train)\n\u001b[0;32m     21\u001b[0m \u001b[39m# Make predictions on the test set\u001b[39;00m\n\u001b[1;32m---> 22\u001b[0m y_pred \u001b[39m=\u001b[39m model\u001b[39m.\u001b[39;49mpredict(X_test)\n\u001b[0;32m     24\u001b[0m \u001b[39m# Evaluate the model\u001b[39;00m\n\u001b[0;32m     25\u001b[0m accuracy \u001b[39m=\u001b[39m accuracy_score(y_test, y_pred)\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python310\\site-packages\\xgboost\\sklearn.py:1525\u001b[0m, in \u001b[0;36mXGBClassifier.predict\u001b[1;34m(self, X, output_margin, ntree_limit, validate_features, base_margin, iteration_range)\u001b[0m\n\u001b[0;32m   1515\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mpredict\u001b[39m(\n\u001b[0;32m   1516\u001b[0m     \u001b[39mself\u001b[39m,\n\u001b[0;32m   1517\u001b[0m     X: ArrayLike,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1522\u001b[0m     iteration_range: Optional[Tuple[\u001b[39mint\u001b[39m, \u001b[39mint\u001b[39m]] \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m,\n\u001b[0;32m   1523\u001b[0m ) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m np\u001b[39m.\u001b[39mndarray:\n\u001b[0;32m   1524\u001b[0m     \u001b[39mwith\u001b[39;00m config_context(verbosity\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mverbosity):\n\u001b[1;32m-> 1525\u001b[0m         class_probs \u001b[39m=\u001b[39m \u001b[39msuper\u001b[39;49m()\u001b[39m.\u001b[39;49mpredict(\n\u001b[0;32m   1526\u001b[0m             X\u001b[39m=\u001b[39;49mX,\n\u001b[0;32m   1527\u001b[0m             output_margin\u001b[39m=\u001b[39;49moutput_margin,\n\u001b[0;32m   1528\u001b[0m             ntree_limit\u001b[39m=\u001b[39;49mntree_limit,\n\u001b[0;32m   1529\u001b[0m             validate_features\u001b[39m=\u001b[39;49mvalidate_features,\n\u001b[0;32m   1530\u001b[0m             base_margin\u001b[39m=\u001b[39;49mbase_margin,\n\u001b[0;32m   1531\u001b[0m             iteration_range\u001b[39m=\u001b[39;49miteration_range,\n\u001b[0;32m   1532\u001b[0m         )\n\u001b[0;32m   1533\u001b[0m         \u001b[39mif\u001b[39;00m output_margin:\n\u001b[0;32m   1534\u001b[0m             \u001b[39m# If output_margin is active, simply return the scores\u001b[39;00m\n\u001b[0;32m   1535\u001b[0m             \u001b[39mreturn\u001b[39;00m class_probs\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python310\\site-packages\\xgboost\\sklearn.py:1114\u001b[0m, in \u001b[0;36mXGBModel.predict\u001b[1;34m(self, X, output_margin, ntree_limit, validate_features, base_margin, iteration_range)\u001b[0m\n\u001b[0;32m   1112\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_can_use_inplace_predict():\n\u001b[0;32m   1113\u001b[0m     \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m-> 1114\u001b[0m         predts \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mget_booster()\u001b[39m.\u001b[39;49minplace_predict(\n\u001b[0;32m   1115\u001b[0m             data\u001b[39m=\u001b[39;49mX,\n\u001b[0;32m   1116\u001b[0m             iteration_range\u001b[39m=\u001b[39;49miteration_range,\n\u001b[0;32m   1117\u001b[0m             predict_type\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mmargin\u001b[39;49m\u001b[39m\"\u001b[39;49m \u001b[39mif\u001b[39;49;00m output_margin \u001b[39melse\u001b[39;49;00m \u001b[39m\"\u001b[39;49m\u001b[39mvalue\u001b[39;49m\u001b[39m\"\u001b[39;49m,\n\u001b[0;32m   1118\u001b[0m             missing\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mmissing,\n\u001b[0;32m   1119\u001b[0m             base_margin\u001b[39m=\u001b[39;49mbase_margin,\n\u001b[0;32m   1120\u001b[0m             validate_features\u001b[39m=\u001b[39;49mvalidate_features,\n\u001b[0;32m   1121\u001b[0m         )\n\u001b[0;32m   1122\u001b[0m         \u001b[39mif\u001b[39;00m _is_cupy_array(predts):\n\u001b[0;32m   1123\u001b[0m             \u001b[39mimport\u001b[39;00m \u001b[39mcupy\u001b[39;00m  \u001b[39m# pylint: disable=import-error\u001b[39;00m\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python310\\site-packages\\xgboost\\core.py:2269\u001b[0m, in \u001b[0;36mBooster.inplace_predict\u001b[1;34m(self, data, iteration_range, predict_type, missing, validate_features, base_margin, strict_shape)\u001b[0m\n\u001b[0;32m   2265\u001b[0m         \u001b[39mraise\u001b[39;00m \u001b[39mTypeError\u001b[39;00m(\n\u001b[0;32m   2266\u001b[0m             \u001b[39m\"\u001b[39m\u001b[39m`shape` attribute is required when `validate_features` is True.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m   2267\u001b[0m         )\n\u001b[0;32m   2268\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(data\u001b[39m.\u001b[39mshape) \u001b[39m!=\u001b[39m \u001b[39m1\u001b[39m \u001b[39mand\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_features() \u001b[39m!=\u001b[39m data\u001b[39m.\u001b[39mshape[\u001b[39m1\u001b[39m]:\n\u001b[1;32m-> 2269\u001b[0m         \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[0;32m   2270\u001b[0m             \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mFeature shape mismatch, expected: \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_features()\u001b[39m}\u001b[39;00m\u001b[39m, \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m   2271\u001b[0m             \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mgot \u001b[39m\u001b[39m{\u001b[39;00mdata\u001b[39m.\u001b[39mshape[\u001b[39m1\u001b[39m]\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m\n\u001b[0;32m   2272\u001b[0m         )\n\u001b[0;32m   2274\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m\u001b[39mdata\u001b[39;00m \u001b[39mimport\u001b[39;00m (\n\u001b[0;32m   2275\u001b[0m     _array_interface,\n\u001b[0;32m   2276\u001b[0m     _is_cudf_df,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   2279\u001b[0m     _transform_pandas_df,\n\u001b[0;32m   2280\u001b[0m )\n\u001b[0;32m   2282\u001b[0m enable_categorical \u001b[39m=\u001b[39m _has_categorical(\u001b[39mself\u001b[39m, data)\n",
      "\u001b[1;31mValueError\u001b[0m: Feature shape mismatch, expected: 1620, got 1432"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import xgboost as xgb\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "X_train = train_df.drop('IS_HCP', axis=1)\n",
    "y_train = train_df['IS_HCP']\n",
    "\n",
    "X_test = test_df\n",
    "y_test = train_df['IS_HCP']\n",
    "\n",
    "\n",
    "model = xgb.XGBClassifier()\n",
    "\n",
    "\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy: {:.2f}%\".format(accuracy * 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y_pred' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[165], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m y_pred\n",
      "\u001b[1;31mNameError\u001b[0m: name 'y_pred' is not defined"
     ]
    }
   ],
   "source": [
    "y_pred"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}