{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:center\">\n",
    "    <a href=\"https://skills.network\" target=\"_blank\">\n",
    "    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/assets/logos/SN_web_lightmode.png\" width=\"200\" alt=\"Skills Network Logo\"  />\n",
    "    </a>\n",
    "</p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Data Normalization Techniques**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estimated time needed: **30** minutes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lab, you will focus on data normalization. This includes identifying compensation-related columns, applying normalization techniques, and visualizing the data distributions.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objectives\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lab, you will perform the following:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Identify duplicate rows and remove them.\n",
    "\n",
    "- Check and handle missing values in key columns.\n",
    "\n",
    "- Identify and normalize compensation-related columns.\n",
    "\n",
    "- Visualize the effect of normalization techniques on data distributions.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hands on Lab\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 1: Install and Import Libraries\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pandas in /opt/conda/lib/python3.12/site-packages (3.0.0)\n",
      "Requirement already satisfied: numpy>=1.26.0 in /opt/conda/lib/python3.12/site-packages (from pandas) (2.4.1)\n",
      "Requirement already satisfied: python-dateutil>=2.8.2 in /opt/conda/lib/python3.12/site-packages (from pandas) (2.9.0.post0)\n",
      "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.12/site-packages (from python-dateutil>=2.8.2->pandas) (1.17.0)\n"
     ]
    }
   ],
   "source": [
    "!pip install pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: matplotlib in /opt/conda/lib/python3.12/site-packages (3.10.8)\n",
      "Requirement already satisfied: contourpy>=1.0.1 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (1.3.3)\n",
      "Requirement already satisfied: cycler>=0.10 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (0.12.1)\n",
      "Requirement already satisfied: fonttools>=4.22.0 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (4.61.1)\n",
      "Requirement already satisfied: kiwisolver>=1.3.1 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (1.4.9)\n",
      "Requirement already satisfied: numpy>=1.23 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (2.4.1)\n",
      "Requirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (24.2)\n",
      "Requirement already satisfied: pillow>=8 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (12.1.0)\n",
      "Requirement already satisfied: pyparsing>=3 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (3.3.2)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (2.9.0.post0)\n",
      "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.12/site-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n"
     ]
    }
   ],
   "source": [
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2: Load the Dataset into a DataFrame\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the <code>pandas.read_csv()</code> function for reading CSV files. However, in this version of the lab, which operates on JupyterLite, the dataset needs to be downloaded to the interface using the provided code below.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The functions below will download the dataset into your browser:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   ResponseId                      MainBranch                 Age  \\\n",
      "0           1  I am a developer by profession  Under 18 years old   \n",
      "1           2  I am a developer by profession     35-44 years old   \n",
      "2           3  I am a developer by profession     45-54 years old   \n",
      "3           4           I am learning to code     18-24 years old   \n",
      "4           5  I am a developer by profession     18-24 years old   \n",
      "\n",
      "            Employment RemoteWork   Check  \\\n",
      "0  Employed, full-time     Remote  Apples   \n",
      "1  Employed, full-time     Remote  Apples   \n",
      "2  Employed, full-time     Remote  Apples   \n",
      "3   Student, full-time        NaN  Apples   \n",
      "4   Student, full-time        NaN  Apples   \n",
      "\n",
      "                                    CodingActivities  \\\n",
      "0                                              Hobby   \n",
      "1  Hobby;Contribute to open-source projects;Other...   \n",
      "2  Hobby;Contribute to open-source projects;Other...   \n",
      "3                                                NaN   \n",
      "4                                                NaN   \n",
      "\n",
      "                                             EdLevel  \\\n",
      "0                          Primary/elementary school   \n",
      "1       Bachelor’s degree (B.A., B.S., B.Eng., etc.)   \n",
      "2    Master’s degree (M.A., M.S., M.Eng., MBA, etc.)   \n",
      "3  Some college/university study without earning ...   \n",
      "4  Secondary school (e.g. American high school, G...   \n",
      "\n",
      "                                           LearnCode  \\\n",
      "0                             Books / Physical media   \n",
      "1  Books / Physical media;Colleague;On the job tr...   \n",
      "2  Books / Physical media;Colleague;On the job tr...   \n",
      "3  Other online resources (e.g., videos, blogs, f...   \n",
      "4  Other online resources (e.g., videos, blogs, f...   \n",
      "\n",
      "                                     LearnCodeOnline  ... JobSatPoints_6  \\\n",
      "0                                                NaN  ...            NaN   \n",
      "1  Technical documentation;Blogs;Books;Written Tu...  ...            0.0   \n",
      "2  Technical documentation;Blogs;Books;Written Tu...  ...            NaN   \n",
      "3  Stack Overflow;How-to videos;Interactive tutorial  ...            NaN   \n",
      "4  Technical documentation;Blogs;Written Tutorial...  ...            NaN   \n",
      "\n",
      "  JobSatPoints_7 JobSatPoints_8 JobSatPoints_9 JobSatPoints_10  \\\n",
      "0            NaN            NaN            NaN             NaN   \n",
      "1            0.0            0.0            0.0             0.0   \n",
      "2            NaN            NaN            NaN             NaN   \n",
      "3            NaN            NaN            NaN             NaN   \n",
      "4            NaN            NaN            NaN             NaN   \n",
      "\n",
      "  JobSatPoints_11           SurveyLength SurveyEase ConvertedCompYearly JobSat  \n",
      "0             NaN                    NaN        NaN                 NaN    NaN  \n",
      "1             0.0                    NaN        NaN                 NaN    NaN  \n",
      "2             NaN  Appropriate in length       Easy                 NaN    NaN  \n",
      "3             NaN               Too long       Easy                 NaN    NaN  \n",
      "4             NaN              Too short       Easy                 NaN    NaN  \n",
      "\n",
      "[5 rows x 114 columns]\n",
      "Initial dataframe: (65437, 114)\n"
     ]
    }
   ],
   "source": [
    "file_path = \"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/n01PQ9pSmiRX6520flujwQ/survey-data.csv\"\n",
    "\n",
    "df = pd.read_csv(file_path)\n",
    "\n",
    "# Display the first few rows to check if data is loaded correctly\n",
    "print(df.head())\n",
    "print('Initial dataframe:', df.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df = pd.read_csv(\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/n01PQ9pSmiRX6520flujwQ/survey-data.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 1: Handling Duplicates\n",
    "##### Task 1: Identify and remove duplicate rows.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fraction of duplicates in each column\n",
      "ResponseId: 0.0\n",
      "LanguageHaveWorkedWith: 0.6353\n",
      "LanguageWantToWorkWith: 0.652\n",
      "ToolsTechHaveWorkedWith: 0.6961\n",
      "ToolsTechWantToWorkWith: 0.7471\n"
     ]
    }
   ],
   "source": [
    "## Write your code here\n",
    "frdupl = []\n",
    "for col in df.columns:\n",
    "    nunique = df[col].nunique(dropna=False) # number of unique values for this column\n",
    "    frdupl.append((col, round(((df[col].size - nunique) / df[col].size), 4)))\n",
    "frdupl = sorted(frdupl, key=lambda n:n[1])\n",
    "print('Fraction of duplicates in each column')\n",
    "for i in range(5):\n",
    "    print(*frdupl[i], sep=': ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of duplicate rows: 487\n",
      "Final dataframe: (64950, 114)\n"
     ]
    }
   ],
   "source": [
    "## Write your code here\n",
    "subset_cols = list(df.drop(['ResponseId'], axis=1).columns)\n",
    "dup_rows = df[df.duplicated(subset=subset_cols)]\n",
    "print('Number of duplicate rows:', dup_rows.shape[0])\n",
    "df_d = df.drop_duplicates(subset=subset_cols)\n",
    "print('Final dataframe:', df_d.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 2: Handling Missing Values\n",
    "##### Task 2: Identify missing values in `CodingActivities`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fraction of missing values in each column\n",
      "AINextMuch less integrated    0.9823\n",
      "AINextLess integrated         0.9637\n",
      "AINextNo change               0.8076\n",
      "AINextMuch more integrated    0.7931\n",
      "EmbeddedAdmired               0.7424\n",
      "dtype: float64\n",
      "CodingActivities: 0.1641\n",
      "ConvertedCompYearly: 0.6392\n"
     ]
    }
   ],
   "source": [
    "## Write your code here\n",
    "frnan = df_d.isna().mean().sort_values(ascending=False).round(decimals=4)\n",
    "print('Fraction of missing values in each column')\n",
    "print(frnan.head())\n",
    "print('CodingActivities:', frnan.CodingActivities)\n",
    "print('ConvertedCompYearly:', frnan.ConvertedCompYearly)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Task 3: Impute missing values in CodingActivities with forward-fill.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count     54293\n",
      "unique      118\n",
      "top       Hobby\n",
      "freq       9936\n",
      "Name: CodingActivities, dtype: object\n"
     ]
    }
   ],
   "source": [
    "print(df_d.CodingActivities.describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count     64950\n",
      "unique      118\n",
      "top       Hobby\n",
      "freq      11851\n",
      "Name: CodingActivities, dtype: object\n"
     ]
    }
   ],
   "source": [
    "## Write your code here\n",
    "df_dm = df_d.copy()\n",
    "df_dm['CodingActivities'] = df_dm['CodingActivities'].ffill()\n",
    "print(df_dm['CodingActivities'].describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**:  Before normalizing ConvertedCompYearly, ensure that any missing values (NaN) in this column are handled appropriately. You can choose to either drop the rows containing NaN or replace the missing values with a suitable statistic (e.g., median or mean).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count       23435\n",
      "mean        86155\n",
      "std        186756\n",
      "min             1\n",
      "25%         32712\n",
      "50%         65000\n",
      "75%        107971\n",
      "max      16256603\n",
      "Name: ConvertedCompYearly, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "## Write your code here\n",
    "print(df_dm.ConvertedCompYearly.describe().astype(int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of unique values: 6114\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('Number of unique values:', len(df_dm.ConvertedCompYearly.unique()))\n",
    "df_dm.ConvertedCompYearly.hist(log=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count       64950\n",
      "mean        72633\n",
      "std        112638\n",
      "min             1\n",
      "25%         65000\n",
      "50%         65000\n",
      "75%         65000\n",
      "max      16256603\n",
      "Name: ConvertedCompYearly, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "## Write your code here\n",
    "# The data in the ConvertedCompYearly column has 64% missing values and it is skewed.\n",
    "# Hence, it is better to use a median value.\n",
    "MedianValue = df_dm['ConvertedCompYearly'].median()\n",
    "df_dm['ConvertedCompYearly'] = df_dm['ConvertedCompYearly'].fillna(MedianValue)\n",
    "print(df_dm['ConvertedCompYearly'].describe().astype(int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 3: Normalizing Compensation Data\n",
    "##### Task 4: Identify compensation-related columns, such as ConvertedCompYearly.\n",
    "Normalization is commonly applied to compensation data to bring values within a comparable range. Here, you’ll identify ConvertedCompYearly or similar columns, which contain compensation information. This column will be used in the subsequent tasks for normalization.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CompTotal\n",
      "AIComplex\n",
      "ConvertedCompYearly\n"
     ]
    }
   ],
   "source": [
    "## Write your code here\n",
    "for col in df_dm.columns:\n",
    "    if 'comp' in col.lower():\n",
    "        print(col)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Task 5: Normalize ConvertedCompYearly using Min-Max Scaling.\n",
    "Min-Max Scaling brings all values in a column to a 0-1 range, making it useful for comparing data across different scales. Here, you will apply Min-Max normalization to the ConvertedCompYearly column, creating a new column ConvertedCompYearly_MinMax with normalized values.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    64950.000000\n",
      "mean         0.004468\n",
      "std          0.006929\n",
      "min          0.000000\n",
      "25%          0.003998\n",
      "50%          0.003998\n",
      "75%          0.003998\n",
      "max          1.000000\n",
      "Name: ConvertedCompYearly_MinMax, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "## Write your code here\n",
    "df_dm['ConvertedCompYearly_MinMax'] = (df_dm['ConvertedCompYearly'] - df_dm['ConvertedCompYearly'].min()) / (df_dm['ConvertedCompYearly'].max() - df_dm['ConvertedCompYearly'].min())\n",
    "print(df_dm['ConvertedCompYearly_MinMax'].describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Task 6: Apply Z-score Normalization to `ConvertedCompYearly`.\n",
    "\n",
    "Z-score normalization standardizes values by converting them to a distribution with a mean of 0 and a standard deviation of 1. This method is helpful for datasets with a Gaussian (normal) distribution. Here, you’ll calculate Z-scores for the ConvertedCompYearly column, saving the results in a new column ConvertedCompYearly_Zscore.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    6.495000e+04\n",
      "mean     2.100450e-17\n",
      "std      1.000000e+00\n",
      "min     -6.448243e-01\n",
      "25%     -6.776682e-02\n",
      "50%     -6.776682e-02\n",
      "75%     -6.776682e-02\n",
      "max      1.436804e+02\n",
      "Name: ConvertedCompYearly_Zscore, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "## Write your code here\n",
    "df_dm['ConvertedCompYearly_Zscore'] = (df_dm['ConvertedCompYearly'] - df_dm['ConvertedCompYearly'].mean()) / df_dm['ConvertedCompYearly'].std()\n",
    "print(df_dm['ConvertedCompYearly_Zscore'].describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Section 4: Visualization of Normalized Data\n",
    "##### Task 7: Visualize the distribution of `ConvertedCompYearly`, `ConvertedCompYearly_Normalized`, and `ConvertedCompYearly_Zscore`\n",
    "\n",
    "Visualization helps you understand how normalization changes the data distribution. In this task, create histograms for the original ConvertedCompYearly, as well as its normalized versions (ConvertedCompYearly_MinMax and ConvertedCompYearly_Zscore). This will help you compare how each normalization technique affects the data range and distribution.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Write your code here\n",
    "for col in ['ConvertedCompYearly', 'ConvertedCompYearly_MinMax', 'ConvertedCompYearly_Zscore']:\n",
    "    bins = int(2 * (len(df_dm[col]) ** (1/3)))  # Rice Rule (more robust for large datasets)\n",
    "    nticks = int(bins / 8)\n",
    "    ticks = np.linspace(df_dm[col].min(), df_dm[col].max(), nticks)\n",
    "    h = df_dm[col].hist(figsize=(8, 5), bins=bins, edgecolor='black', log=True)\n",
    "    h.set(title=f'Histogram of {col}', ylabel='Number', xticks=ticks, xlabel='Compensation')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lab, you practiced essential normalization techniques, including:\n",
    "\n",
    "- Identifying and handling duplicate rows.\n",
    "\n",
    "- Checking for and imputing missing values.\n",
    "\n",
    "- Applying Min-Max scaling and Z-score normalization to compensation data.\n",
    "\n",
    "- Visualizing the impact of normalization on data distribution.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright © IBM Corporation. All rights reserved.\n"
   ]
  }
 ],
 "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.13.5"
  },
  "prev_pub_hash": "5b2314eae200c68d20ee3204d822e6fad4f5845945b4895f383c3007af43740d"
 },
 "nbformat": 4,
 "nbformat_minor": 4
}