diff --git a/analysis_of_tags.ipynb b/analysis_of_tags.ipynb
new file mode 100644
index 0000000..0236607
--- /dev/null
+++ b/analysis_of_tags.ipynb
@@ -0,0 +1,639 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Analysis of tag"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Tags are our class labels. As we were trying to predict them, we should deep dive and understand them very well. After removing all the duplicated data we are left with 4.2 Million data points and 42k unique tags.\n",
+    "The number of times a tag appeared is an interesting thing to understand. So I just counted it and put it into a dictionary. If we observe the table below, the “.a” tag appeared in 18 questions, the “.app” tag appeared in 37 questions, and so on. Remember, we will never have a tag repeating two times in the same question."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To save time a subset of the original dataset is used here."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sklearn as sk\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.feature_extraction.text import CountVectorizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "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>Id</th>\n",
+       "      <th>Title</th>\n",
+       "      <th>Body</th>\n",
+       "      <th>Tags</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>How to check if an uploaded file is an image w...</td>\n",
+       "      <td>&lt;p&gt;I'd like to check if an uploaded file is an...</td>\n",
+       "      <td>php image-processing file-upload upload mime-t...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>How can I prevent firefox from closing when I ...</td>\n",
+       "      <td>&lt;p&gt;In my favorite editor (vim), I regularly us...</td>\n",
+       "      <td>firefox</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>R Error Invalid type (list) for variable</td>\n",
+       "      <td>&lt;p&gt;I am import matlab file and construct a dat...</td>\n",
+       "      <td>r matlab machine-learning</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>4</td>\n",
+       "      <td>How do I replace special characters in a URL?</td>\n",
+       "      <td>&lt;p&gt;This is probably very simple, but I simply ...</td>\n",
+       "      <td>c# url encoding</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>5</td>\n",
+       "      <td>How to modify whois contact details?</td>\n",
+       "      <td>&lt;pre&gt;&lt;code&gt;function modify(.......)\\r\\n{\\r\\n  ...</td>\n",
+       "      <td>php api file-get-contents</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Id                                              Title  \\\n",
+       "0   1  How to check if an uploaded file is an image w...   \n",
+       "1   2  How can I prevent firefox from closing when I ...   \n",
+       "2   3           R Error Invalid type (list) for variable   \n",
+       "3   4      How do I replace special characters in a URL?   \n",
+       "4   5               How to modify whois contact details?   \n",
+       "\n",
+       "                                                Body  \\\n",
+       "0  <p>I'd like to check if an uploaded file is an...   \n",
+       "1  <p>In my favorite editor (vim), I regularly us...   \n",
+       "2  <p>I am import matlab file and construct a dat...   \n",
+       "3  <p>This is probably very simple, but I simply ...   \n",
+       "4  <pre><code>function modify(.......)\\r\\n{\\r\\n  ...   \n",
+       "\n",
+       "                                                Tags  \n",
+       "0  php image-processing file-upload upload mime-t...  \n",
+       "1                                            firefox  \n",
+       "2                          r matlab machine-learning  \n",
+       "3                                    c# url encoding  \n",
+       "4                          php api file-get-contents  "
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = pd.read_csv(\"train_000.csv\")\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dataframe shape:  (41234, 4)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Dataframe shape: \",df.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Removing Duplicates"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total number of duplicate questions :  0\n",
+      "Dataframe shape after removing duplicate values :  (41234, 4)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\lenovo\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:3: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
+      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
+     ]
+    }
+   ],
+   "source": [
+    "duplicates = df.sort_values('Title', ascending=False).duplicated('Title')\n",
+    "print(\"Total number of duplicate questions : \", duplicates.sum())\n",
+    "df = df[~duplicates]\n",
+    "print(\"Dataframe shape after removing duplicate values : \", df.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Data Analysis on Tags"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "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>Id</th>\n",
+       "      <th>Title</th>\n",
+       "      <th>Body</th>\n",
+       "      <th>Tags</th>\n",
+       "      <th>tag_count</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>How to check if an uploaded file is an image w...</td>\n",
+       "      <td>&lt;p&gt;I'd like to check if an uploaded file is an...</td>\n",
+       "      <td>php image-processing file-upload upload mime-t...</td>\n",
+       "      <td>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>How can I prevent firefox from closing when I ...</td>\n",
+       "      <td>&lt;p&gt;In my favorite editor (vim), I regularly us...</td>\n",
+       "      <td>firefox</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>R Error Invalid type (list) for variable</td>\n",
+       "      <td>&lt;p&gt;I am import matlab file and construct a dat...</td>\n",
+       "      <td>r matlab machine-learning</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>4</td>\n",
+       "      <td>How do I replace special characters in a URL?</td>\n",
+       "      <td>&lt;p&gt;This is probably very simple, but I simply ...</td>\n",
+       "      <td>c# url encoding</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>5</td>\n",
+       "      <td>How to modify whois contact details?</td>\n",
+       "      <td>&lt;pre&gt;&lt;code&gt;function modify(.......)\\r\\n{\\r\\n  ...</td>\n",
+       "      <td>php api file-get-contents</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Id                                              Title  \\\n",
+       "0   1  How to check if an uploaded file is an image w...   \n",
+       "1   2  How can I prevent firefox from closing when I ...   \n",
+       "2   3           R Error Invalid type (list) for variable   \n",
+       "3   4      How do I replace special characters in a URL?   \n",
+       "4   5               How to modify whois contact details?   \n",
+       "\n",
+       "                                                Body  \\\n",
+       "0  <p>I'd like to check if an uploaded file is an...   \n",
+       "1  <p>In my favorite editor (vim), I regularly us...   \n",
+       "2  <p>I am import matlab file and construct a dat...   \n",
+       "3  <p>This is probably very simple, but I simply ...   \n",
+       "4  <pre><code>function modify(.......)\\r\\n{\\r\\n  ...   \n",
+       "\n",
+       "                                                Tags  tag_count  \n",
+       "0  php image-processing file-upload upload mime-t...          5  \n",
+       "1                                            firefox          1  \n",
+       "2                          r matlab machine-learning          3  \n",
+       "3                                    c# url encoding          3  \n",
+       "4                          php api file-get-contents          3  "
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df[\"tag_count\"] = df[\"Tags\"].apply(lambda x : len(x.split()))\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3    11922\n",
+       "2    10963\n",
+       "4     7870\n",
+       "1     5641\n",
+       "5     4838\n",
+       "Name: tag_count, dtype: int64"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df[\"tag_count\"].value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Maximum number of tags in a question:  5\n",
+      "Minimum number of tags in a question:  1\n",
+      "Average number of tags in a question:  2.8860406460687784\n"
+     ]
+    }
+   ],
+   "source": [
+    "print( \"Max number of tags in a question: \", df[\"tag_count\"].max())\n",
+    "print( \"Min number of tags in a question: \", df[\"tag_count\"].min())\n",
+    "print( \"Average number of tags in a question: \", df[\"tag_count\"].mean())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Frequency')"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.countplot(df[\"tag_count\"])\n",
+    "plt.title(\"Number of tags in a questions \")\n",
+    "plt.xlabel(\"Number of Tags\")\n",
+    "plt.ylabel(\"Frequency\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Counting frequency of different tags and saving it to a dictionary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vectorizer = CountVectorizer(tokenizer= lambda text : text.split(\" \"))\n",
+    "tag_dtm = vectorizer.fit_transform(df[\"Tags\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['.class-file',\n",
+       " '.each',\n",
+       " '.emf',\n",
+       " '.hgtags',\n",
+       " '.htaccess',\n",
+       " '.htpasswd',\n",
+       " '.mov',\n",
+       " '.net',\n",
+       " '.net-1.1',\n",
+       " '.net-2.0',\n",
+       " '.net-3.5',\n",
+       " '.net-4.0',\n",
+       " '.net-4.5',\n",
+       " '.net-assembly',\n",
+       " '.net-cf-3.5']"
+      ]
+     },
+     "execution_count": 67,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tags = vectorizer.get_feature_names()\n",
+    "tags[:15]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "freqs = tag_dtm.sum(axis=0).A1\n",
+    "result = dict(zip(tags,freqs))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "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>Tags</th>\n",
+       "      <th>Counts</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>.class-file</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>.each</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>.emf</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>.hgtags</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>.htaccess</td>\n",
+       "      <td>146</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "          Tags  Counts\n",
+       "0  .class-file       1\n",
+       "1        .each       6\n",
+       "2         .emf       1\n",
+       "3      .hgtags       1\n",
+       "4    .htaccess     146"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tag_df = pd.DataFrame(result.items(), columns=[\"Tags\", \"Counts\"])\n",
+    "tag_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tag_df_sorted = tag_df.sort_values(['Counts'], ascending=False)\n",
+    "tag_counts = tag_df_sorted[\"Counts\"].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(tag_counts[:50])\n",
+    "plt.scatter(x= list(range(0,50,2)), y = tag_counts[0:50:2], c= 'yellow')\n",
+    "plt.scatter(x= list(range(0,50,10)), y = tag_counts[0:50:10], c = \"blue\")\n",
+    "plt.grid()\n",
+    "plt.xlabel(\"Tag Number\")\n",
+    "plt.ylabel(\"Number of times the tag Appear\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "itr=np.arange(20)\n",
+    "tag_df_sorted.head(20).plot(kind='bar')\n",
+    "plt.title('Frequency of top 20 tags')\n",
+    "plt.xticks(itr, tag_df_sorted['Tags'])\n",
+    "plt.xlabel('Tags')\n",
+    "plt.ylabel('Counts')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### From the above bar plot we can see that C# ,java,php are the most searched tags on stackoverflow."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

	Id	Title	Body	Tags
0	1	How to check if an uploaded file is an image w...	<p>I'd like to check if an uploaded file is an...	php image-processing file-upload upload mime-t...
1	2	How can I prevent firefox from closing when I ...	<p>In my favorite editor (vim), I regularly us...	firefox
2	3	R Error Invalid type (list) for variable	<p>I am import matlab file and construct a dat...	r matlab machine-learning
3	4	How do I replace special characters in a URL?	<p>This is probably very simple, but I simply ...	c# url encoding
4	5	How to modify whois contact details?	<pre><code>function modify(.......)\\r\\n{\\r\\n ...	php api file-get-contents