{ "cells": [ { "cell_type": "markdown", "id": "85bae542", "metadata": {}, "source": [ "# 2.2.3 Feature Engineering\n", "\n", "What we've seen so far is how to load data into a Pandas data frame and perform some initial exploration and sanity checks to verify it looks how we expect. Following that, it's still unlikely the data will be ready to be fed straight into an analysis or model so we must mould it to fit our needs.\n", "\n", "This is what we'll focus on for most of the rest of this module. In the literature you'll find it referred to as \"preprocessing\", \"wrangling\", \"feature engineering\" and many other terms, which all cover some aspect of curating and manipulating the raw source data. In this section we focus on numerical data, but we discuss approaches for other types of data in [Section 2.2.4](2-02-04-DataManipulation).\n", "\n", "Here we'll be using data from the Anthropometric Survey of US Army Personnel ([ANSUR 2](https://www.openlab.psu.edu/ansur2/)), which includes comprehensive body shape and size measurements for people in the US army that were taken in 2012 and released publicly in 2017. There's data on both males and females, we'll use the female data here:" ] }, { "cell_type": "code", "execution_count": 1, "id": "ec512e89", "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 2, "id": "600597a4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "RangeIndex: 1986 entries, 0 to 1985\n", "Columns: 108 entries, SubjectId to WritingPreference\n", "dtypes: int64(99), object(9)\n", "memory usage: 1.6+ MB\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
SubjectIdabdominalextensiondepthsittingacromialheightacromionradialelengthanklecircumferenceaxillaheightballoffootcircumferenceballoffootlengthbiacromialbreadthbicepscircumferenceflexed...BranchPrimaryMOSSubjectsBirthLocationSubjectNumericRaceEthnicityDODRaceAgeHeightinWeightlbsWritingPreference
01003723112823012041180222177373315...Combat Support92YGermany2NaN22661142Right hand
11003819413793202071292225178372272...Combat Service Support25UCalifornia3Mexican32164120Right hand
21004218313693292331271237196397300...Combat Service Support35DTexas1NaN12368147Right hand
31004326113563062141250240188384364...Combat Service Support25UDistrict of Columbia8Caribbean Islander22266175Right hand
41005130913033082141210217182378320...Combat Arms42ATexas1NaN14563195Right hand
\n", "

5 rows × 108 columns

\n", "
" ], "text/plain": [ " SubjectId abdominalextensiondepthsitting acromialheight \\\n", "0 10037 231 1282 \n", "1 10038 194 1379 \n", "2 10042 183 1369 \n", "3 10043 261 1356 \n", "4 10051 309 1303 \n", "\n", " acromionradialelength anklecircumference axillaheight \\\n", "0 301 204 1180 \n", "1 320 207 1292 \n", "2 329 233 1271 \n", "3 306 214 1250 \n", "4 308 214 1210 \n", "\n", " balloffootcircumference balloffootlength biacromialbreadth \\\n", "0 222 177 373 \n", "1 225 178 372 \n", "2 237 196 397 \n", "3 240 188 384 \n", "4 217 182 378 \n", "\n", " bicepscircumferenceflexed ... Branch PrimaryMOS \\\n", "0 315 ... Combat Support 92Y \n", "1 272 ... Combat Service Support 25U \n", "2 300 ... Combat Service Support 35D \n", "3 364 ... Combat Service Support 25U \n", "4 320 ... Combat Arms 42A \n", "\n", " SubjectsBirthLocation SubjectNumericRace Ethnicity DODRace \\\n", "0 Germany 2 NaN 2 \n", "1 California 3 Mexican 3 \n", "2 Texas 1 NaN 1 \n", "3 District of Columbia 8 Caribbean Islander 2 \n", "4 Texas 1 NaN 1 \n", "\n", " Age Heightin Weightlbs WritingPreference \n", "0 26 61 142 Right hand \n", "1 21 64 120 Right hand \n", "2 23 68 147 Right hand \n", "3 22 66 175 Right hand \n", "4 45 63 195 Right hand \n", "\n", "[5 rows x 108 columns]" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df = pd.read_csv(\"data/ANSUR_II_FEMALE_Public.csv\")\n", "df.info()\n", "df.head()" ] }, { "cell_type": "markdown", "id": "832c7479", "metadata": {}, "source": [ "It's also an interesting example of data documentation, with over 250 pages of notes on how the measurements were taken in its [Measurer’s Handbook](http://tools.openlab.psu.edu/publicData/ANSURII-TR11-017.pdf), for example.\n" ] }, { "cell_type": "markdown", "id": "f150057d", "metadata": {}, "source": [ "## Scaling & Transforming Features\n", "\n", "It's common to need to map the original feature values in a dataset on to a different scale, either to improve their \"human\" interpretability (for yourself or others you're presenting results to), or what we could call their \"model interpretability\" (converting values to be more compatible with the design and assumptions of a particular algorithm). Here we show how some frequently used operations can be performed with Pandas.\n", "\n", "### Converting Units\n", "\n", "Despite the name, the `weightkg` column in the ANSUR 2 dataset is in units of 100 grams (tenths of a kilogram):" ] }, { "cell_type": "code", "execution_count": 3, "id": "95eea5ef", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "count 1986.000000\n", "mean 677.582075\n", "std 109.846458\n", "min 358.000000\n", "25% 601.000000\n", "50% 668.000000\n", "75% 745.750000\n", "max 1196.000000\n", "Name: weightkg, dtype: float64" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df[\"weightkg\"].describe()" ] }, { "cell_type": "markdown", "id": "4ad1a7cb", "metadata": {}, "source": [ "And the `stature` (the person's height) column is in millimetres:" ] }, { "cell_type": "code", "execution_count": 4, "id": "bccaad99", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "count 1986.000000\n", "mean 1628.473313\n", "std 64.199512\n", "min 1409.000000\n", "25% 1586.250000\n", "50% 1626.000000\n", "75% 1672.000000\n", "max 1829.000000\n", "Name: stature, dtype: float64" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df[\"stature\"].describe()" ] }, { "cell_type": "markdown", "id": "250ce781", "metadata": {}, "source": [ "For interpreting the data ourselves and presenting it to others it's helpful to have values on scales we're familiar with. It's quick to perform simple mathematical operations on columns with Pandas - let's convert the `weightkg` column to actually be in kilograms, and the `stature` column to be in metres:" ] }, { "cell_type": "code", "execution_count": 5, "id": "ee575a3b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Median weight: 66.8 kg\n", "Median height: 1.626 m\n" ] } ], "source": [ "df[\"weightkg\"] = df[\"weightkg\"] / 10 # 100g -> kg\n", "print(\"Median weight:\", df[\"weightkg\"].median(), \"kg\")\n", "\n", "df[\"stature\"] = df[\"stature\"] / 1000 # mm -> metres\n", "print(\"Median height:\", df[\"stature\"].median(), \"m\")" ] }, { "cell_type": "markdown", "id": "f2bd49ea", "metadata": {}, "source": [ "These look more familiar (at least if you're used to using the metric system!) We can also see that women in the army are lighter and taller on average compared to the general population ([73.1 kg median weight and 1.613 metres median height](https://www.cdc.gov/nchs/data/series/sr_03/sr03-046-508.pdf)), so we'd need to be careful not to generalise results from this data to the USA as a whole." ] }, { "cell_type": "markdown", "id": "338dbf71", "metadata": {}, "source": [ "### Normalisation\n", "\n", "We'll often have features that are on different scales (magnitudes). For example the axilla (armpit) height and ankle circumference in this dataset:" ] }, { "cell_type": "code", "execution_count": 6, "id": "6cff467b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original:\n", "anklecircumference : min = 170.00, max = 275.00, mean = 215.74, std = 14.89\n", "axillaheight : min = 1038.00, max = 1419.00, mean = 1239.03, std = 55.80\n" ] } ], "source": [ "def get_stats(series):\n", " \"\"\"Get a formatted message with the minimum, maximum, mean, and\n", " standard deviation of a pandas series\"\"\"\n", " return \"min = {:.2f}, max = {:.2f}, mean = {:.2f}, std = {:.2f}\".format(\n", " series.min(),\n", " series.max(),\n", " series.mean(),\n", " series.std(),\n", " )\n", "\n", "\n", "columns = [\"anklecircumference\", \"axillaheight\"]\n", "\n", "print(\"Original:\")\n", "for col in columns:\n", " print(col, \":\", get_stats(df[col]))\n" ] }, { "cell_type": "markdown", "id": "b6cff657", "metadata": {}, "source": [ "The maximum axilla height is 1419 mm, and the biggest ankle only 275 mm in circumference. Having features with different magnitudes can have unintended consequences for some algorithms, such as those that use a metric of similarity between data points (like [k-nearest neighbours](https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm)), for example. Say we wanted to compute how \"similar\" someone with the largest ankle circumference and axilla height was to the \"average\" person in those columns. Algorithms like these will often compute a metric like:\n", "\n", "$$\n", "(\\mathrm{ankle}_{max} - \\mathrm{ankle}_{mean})^2 + (\\mathrm{axilla}_{max} - \\mathrm{axilla}_{mean})^2 \\\\\n", "(275.00 - 215.74)^2 + (1419.00 - 1239.03)^2 \\\\\n", "59.26^2 + 179.97^2 \\\\\n", "\\simeq 3512 + 32389\n", "$$\n", "\n", "Note that the axilla height ends up contributing almost 10 times more to the similarity metric, but only because it's a measurement of a larger distance. We probably intended differences in ankle size and armpit height to contribute equally.\n", "\n", "One common way to solve this is to min-max scale, or \"normalise\" the data, as follows:" ] }, { "cell_type": "code", "execution_count": 7, "id": "b5c8b02f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Min-max scaled:\n", "anklecircumference : min = 0.00, max = 1.00, mean = 0.44, std = 0.14\n", "axillaheight : min = 0.00, max = 1.00, mean = 0.53, std = 0.15\n" ] } ], "source": [ "def norm_min_max(series):\n", " \"\"\"Min-max scale a pandas series\"\"\"\n", " return (series - series.min()) / (series.max() - series.min())\n", "\n", "\n", "print(\"Min-max scaled:\")\n", "for col in columns:\n", " df[col] = norm_min_max(df[col])\n", " print(col, \":\", get_stats(df[col]))\n" ] }, { "cell_type": "markdown", "id": "0b3982f4", "metadata": {}, "source": [ "With this scaling applied both columns have a minimum value of 0 and a maximum of 1, and so they become relative measurements of how close someone is to the largest value for each feature." ] }, { "cell_type": "markdown", "id": "335dbdae", "metadata": {}, "source": [ "### Standardisation\n", "\n", "Another popular scaling approach is to \"standardise\" the data, or transform it so the feature has a mean of zero and a standard deviation of one, which can be achieved by subtracting the original mean and dividing by the original standard deviation of the feature:" ] }, { "cell_type": "code", "execution_count": 8, "id": "8af37053", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original:\n", "footlength : min = 198.00, max = 286.00, mean = 246.29, std = 12.44\n", "earlength : min = 46.00, max = 74.00, mean = 59.36, std = 3.88\n", "\n", "Standardised:\n", "footlength : min = -3.88, max = 3.19, mean = -0.00, std = 1.00\n", "earlength : min = -3.44, max = 3.77, mean = -0.00, std = 1.00\n" ] } ], "source": [ "def standardize(series):\n", " \"\"\"Standardise a pandas series to have zero mean and unit\n", " standard deviation\"\"\"\n", " return (series - series.mean()) / series.std()\n", "\n", "\n", "columns = [\"footlength\", \"earlength\"]\n", "\n", "print(\"Original:\")\n", "for col in columns:\n", " print(col, \":\", get_stats(df[col]))\n", "\n", "print(\"\\nStandardised:\")\n", "for col in columns:\n", " df[col] = standardize(df[col])\n", " print(col, \":\", get_stats(df[col]))\n" ] }, { "cell_type": "markdown", "id": "c41ddd30", "metadata": {}, "source": [ "Note that although both columns have the same mean and standard deviation after the transformation, they have different minimum and maximum values. Alternatively, after _normalisation_ the features have the same minimum and maximum values but different means and standard deviations.\n", "\n", "One key consequence of the different approaches is that standardisation preserves outliers (the range of the values is not restricted), whilst normalisation forces each feature to lie within the same range. Which is more appropriate depends on the use case(and you may want to try both and see which performs better)." ] }, { "cell_type": "markdown", "id": "38d0151a", "metadata": {}, "source": [ "### Transformation\n", "\n", "Let's have a look at the distribution of ages in the ANSUR 2 data:" ] }, { "cell_type": "code", "execution_count": 9, "id": "0a6286b2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 0, 'Age')" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "df[\"Age\"].plot.hist(bins=20)\n", "plt.title(\"Age: Original\")\n", "plt.xlabel(\"Age\")" ] }, { "cell_type": "markdown", "id": "88caf3dc", "metadata": {}, "source": [ "Plotting and visualisation is the focus of Module 3, so we won't discuss the details of how to create plots here.\n", "\n", "We see the majority of people are young adults under 35, but there is a long tail of older personnel up to around 60 years old. Some statistical analyses and models make assumptions about the data being normally distributed, or otherwise may perform poorly when long tails/outliers are present. In these cases one option is to log transform the data:" ] }, { "cell_type": "code", "execution_count": 10, "id": "c954a53c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 0, 'log(Age)')" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "log_age = np.log(df[\"Age\"])\n", "\n", "plt.hist(log_age, bins=20)\n", "plt.title(\"Age: Log Transformed\")\n", "plt.xlabel(\"log(Age)\")" ] }, { "cell_type": "markdown", "id": "994a6bad", "metadata": {}, "source": [ "This has the effect of reducing the skewness of the distribution and making it \"more normal\". Whether this, or another transformation, is appropriate for your analysis is a nuanced topic beyond the scope of this course. [Here's a longer discussion](https://data.library.virginia.edu/interpreting-log-transformations-in-a-linear-model/) on the consequences of log transforming data. Another popular algorithm for improving the normality of data is the [Box-Cox transformation](https://www.itl.nist.gov/div898/handbook/eda/section3/eda336.htm)." ] }, { "cell_type": "markdown", "id": "20000c07", "metadata": {}, "source": [ "## Creating New Features\n", "\n", "Another common task is to use domain knowledge to create new features that may be of interest for an analysis, or could add predictive power to a model. For this dataset it may be useful to compute the body mass index of the army personnel, for example, the formula for which is:\n", "\n", "$$\n", "\\textrm{BMI} = \\frac{\\textrm{weight}}{\\textrm{height}^2}\n", "$$\n", "\n", "with weight in kilograms and height in metres. It's quick to do this with Pandas:" ] }, { "cell_type": "code", "execution_count": 11, "id": "d6e5c51d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "count 1986.000000\n", "mean 25.495970\n", "std 3.491673\n", "min 16.366156\n", "25% 23.077535\n", "50% 25.266752\n", "75% 27.609363\n", "max 40.778999\n", "Name: bmi, dtype: float64" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df[\"bmi\"] = df[\"weightkg\"] / df[\"stature\"]**2\n", "df[\"bmi\"].describe()" ] }, { "cell_type": "markdown", "id": "32e9b495", "metadata": {}, "source": [ "To apply an arbitrary function to a Pandas data frame you can also use [`apply`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.apply.html):" ] }, { "cell_type": "code", "execution_count": 12, "id": "b1e86fc6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0 26.997041\n", "1 19.262506\n", "2 22.647148\n", "3 28.378575\n", "4 35.853259\n", " ... \n", "1981 29.234331\n", "1982 27.558173\n", "1983 28.193653\n", "1984 24.201059\n", "1985 22.652319\n", "Length: 1986, dtype: float64" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def calculate_bmi(person):\n", " \"\"\"Calculate body mass index from a person's data.\n", " Person is a pandas series which must include 'weightkg' and 'stature' in its index.\"\"\"\n", " return person[\"weightkg\"] / person[\"stature\"] ** 2\n", "\n", "\n", "df.apply(calculate_bmi, axis=1)" ] }, { "cell_type": "markdown", "id": "0b46bb73", "metadata": {}, "source": [ "With `axis=1` the function will be applied to each row in the data frame, or with `axis=0` to each column.\n", "\n", "`apply` works like using a `for` loop on the data, which means it doesn't benefit from the optimised vector operations `numpy` provides:" ] }, { "cell_type": "code", "execution_count": 13, "id": "ee55726e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "19.5 ms ± 1.39 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" ] } ], "source": [ "%%timeit\n", "\n", "df.apply(calculate_bmi, axis=1)" ] }, { "cell_type": "code", "execution_count": 14, "id": "713d03bd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "126 µs ± 3.28 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)\n" ] } ], "source": [ "%%timeit\n", "\n", "df[\"weightkg\"] / df[\"stature\"]**2" ] }, { "cell_type": "markdown", "id": "843504e3", "metadata": {}, "source": [ "Using `apply` is almost two hundred times slower (the exact ratio will vary depending on your system), and for larger datasets or more complex functions this can add up to a lot of time! We cover ways to make Python code run faster in more detail in the \"Programming for Speed\" module of our [Research Software Engineering course](https://alan-turing-institute.github.io/rsd-engineeringcourse/html/index.html), but it's better to avoid using `apply` if you can.\n", "\n", "As well as curating domain-specific features, another option is to generate many possible combinations of the original columns, and then perhaps select a subset of promising ones after further analysis (see feature selection below). The [`PolynomialFeatures`](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.PolynomialFeatures.html#sklearn.preprocessing.PolynomialFeatures) class in the scikit-learn library generates features that are polynomial combinations of the original features (`weight`, `height`, `weight^2`, `height^2`, `weight * height`, ...), for example.\n", "\n", "Which columns and functions to use and combine into new features is problem-specific and there's no one-size-fits-all solution." ] }, { "cell_type": "markdown", "id": "8b85a6dd", "metadata": {}, "source": [ "## Binning\n", "\n", "Binning is the process of converting a column of continuous values into a discrete set of categories, such as mapping a person's age to an age range (or age \"bin\"):\n", "\n", "| Age | Age Range | Bin Index |\n", "| -- | -- | -- |\n", "| 24 | 20-29 | 0 |\n", "| 45 | 40-49 | 2 |\n", "| 37 | 30-39 | 1 |\n", "| 52 | 50-59 | 3 |\n", "| 28 | 20-29 | 0 |\n", "| 44 | 40-49 | 2 |\n", "\n", "To incorporate the bins in an analysis we usually give them an ordered index from bins with the smallest values (0, meaning an age between 20-29 above) to the largest values (3, meaning an age between 50-59 above).\n", "\n", "There are several scenarios where binning may be useful:\n", "\n", "- To create domain-relevant categories relevant for your research question. You may be interested in differences between children, adults and the elderly, for example, rather than between specific ages.\n", "- As a way of dealing with outliers. Biases caused by data with unusually large (or small) values may be mitigated be grouping extreme values in a single bin.\n", "- In some cases using binned data could improve the performance of a model (it may help to reduce [overfitting](https://en.wikipedia.org/wiki/Overfitting), for example).\n", "\n", "To show how binning works in Pandas we'll use the arm span data (`span` column) in ANSUR 2, which has this distribution:" ] }, { "cell_type": "code", "execution_count": 15, "id": "1743b458", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def plot_span_dist(bins=None):\n", " \"\"\"\n", " Plot the distribution of arm span and show the location of bins, if given\n", " \"\"\"\n", " plt.figure(figsize=(10, 5))\n", " df[\"span\"].plot.hist(bins=20, edgecolor=\"k\", facecolor=\"None\", linewidth=2)\n", " if bins is not None:\n", " # add a vertical line at each bin edge\n", " [plt.axvline(edge, color=\"k\", linestyle=\"--\") for edge in bins]\n", " # add bin index labels\n", " [\n", " plt.annotate(\n", " f\"Bin\\n{i}\",\n", " (edge + 5, 325),\n", " rotation=0,\n", " fontsize=14,\n", " annotation_clip=False,\n", " )\n", " for i, edge in enumerate(bins[:-1])\n", " ]\n", " # add shading for each bin width\n", " colors = [\"r\", \"b\", \"g\", \"m\", \"y\"]\n", " [\n", " plt.axvspan(bins[i], bins[i + 1], alpha=0.1, color=colors[i % len(colors)])\n", " for i in range(0, len(bins) - 1)\n", " ]\n", " plt.xlabel(\"Arm Span [mm]\")\n", " \n", "plot_span_dist()" ] }, { "cell_type": "markdown", "id": "7407da94", "metadata": {}, "source": [ "Again, don't worry about the details of this plotting function for now, we'll be looking at that in Module 3.\n" ] }, { "cell_type": "markdown", "id": "f024e7bc", "metadata": {}, "source": [ "Pandas provides a binning function [`pd.cut`](https://pandas.pydata.org/docs/reference/api/pandas.cut.html), which by default segments the data into a number of ***equal-width*** bins:" ] }, { "cell_type": "code", "execution_count": 16, "id": "46d727ca", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0 (1569.0, 1692.0]\n", "1 (1692.0, 1815.0]\n", "2 (1692.0, 1815.0]\n", "3 (1692.0, 1815.0]\n", "4 (1692.0, 1815.0]\n", " ... \n", "1981 (1692.0, 1815.0]\n", "1982 (1569.0, 1692.0]\n", "1983 (1692.0, 1815.0]\n", "1984 (1569.0, 1692.0]\n", "1985 (1569.0, 1692.0]\n", "Name: span, Length: 1986, dtype: category\n", "Categories (5, interval[float64, right]): [(1322.385, 1446.0] < (1446.0, 1569.0] < (1569.0, 1692.0] < (1692.0, 1815.0] < (1815.0, 1938.0]]" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# The second argument, 5, is the number of bins to segment the data into.\n", "# Setting 'retbins=True' returns an array of bin edges that we use for plotting below.\n", "span_bins, bin_edges = pd.cut(df[\"span\"], 5, retbins=True)\n", "span_bins" ] }, { "cell_type": "markdown", "id": "a88ca117", "metadata": {}, "source": [ "This returns a Pandas series with a \"category\" data type (see [here](https://pandas.pydata.org/pandas-docs/stable/user_guide/categorical.html) for more information). Each value in the data is assigned to the bin (or category) whose range encompasses it, with each bin labelled as `(minimum value, maximum value]` (which is a bin including values `minimum < x <= maximum`). The bins span all values from the minimum to the maximum arm span, and each bin has the same width:" ] }, { "cell_type": "code", "execution_count": 17, "id": "6a85c48d", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_span_dist(bin_edges)" ] }, { "cell_type": "markdown", "id": "926b17d6", "metadata": {}, "source": [ "Rather than the verbose bin label seen in the result from `pd.cut` above, you can also extract a bin index (ranked from smallest to largest) using the `.cat.codes` attribute:" ] }, { "cell_type": "code", "execution_count": 18, "id": "c0236648", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0 2\n", "1 3\n", "2 3\n", "3 3\n", "4 3\n", " ..\n", "1981 3\n", "1982 2\n", "1983 3\n", "1984 2\n", "1985 2\n", "Length: 1986, dtype: int8" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "span_bins.cat.codes" ] }, { "cell_type": "markdown", "id": "ff3b5e61", "metadata": {}, "source": [ "We talk more about categorical data in [Section 2.2.4.3](2-02-04-03-CategoricalData). Pandas also provides an alternative binning function, [`pd.qcut`](https://pandas.pydata.org/docs/reference/api/pandas.qcut.html), which creates bins based on quantiles. In this case each bin contains approximately the same ***proportion*** of the data:" ] }, { "cell_type": "code", "execution_count": 19, "id": "0e6ec250", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1322.999, 1591.0] 404\n", "(1591.0, 1636.0] 396\n", "(1636.0, 1678.0] 398\n", "(1678.0, 1728.0] 391\n", "(1728.0, 1938.0] 397\n", "Name: span, dtype: int64" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "span_qbins, bin_edges = pd.qcut(df[\"span\"], 5, retbins=True)\n", "span_qbins.value_counts(sort=False)" ] }, { "cell_type": "markdown", "id": "d4765681", "metadata": {}, "source": [ "And to achieve this the bins must have different widths (being narrower in the central portion of the distribution):" ] }, { "cell_type": "code", "execution_count": 20, "id": "43ec5233", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_span_dist(bin_edges)" ] }, { "cell_type": "markdown", "id": "bcf0a811", "metadata": {}, "source": [ "You can customise `pd.cut` and `pd.qcut` to return bins of any width or bins for any quantile respectively by passing an array of bin edges as their second argument, for example `pd.cut(df[\"span\"], [1300, 1600, 1700, 2000])`, see the [Pandas documentation](https://pandas.pydata.org/docs/reference/api/pandas.cut.html) for details.\n" ] }, { "cell_type": "markdown", "id": "41ae151b", "metadata": {}, "source": [ "## Feature Selection and Dimensionality Reduction\n", "\n", "It's beyond the scope of what we cover here, but another important topic is the \"curse of dimensionality\", or what to do when we have many features (columns) relative to the number of samples (rows) in the dataset. [This blog post](http://blog.dominodatalab.com/the-curse-of-dimensionality) summarises how this can cause problems in some models.\n", "\n", "Broadly speaking there are three techniques that can be used when this is a problem:\n", "\n", "- **Feature selection:** Only include a subset of the available features in the model, keeping those that are the strongest predictors for the target variable. Scikit-learn has some algorithms for feature selection available, see [here](https://scikit-learn.org/stable/modules/feature_selection.html).\n", "- **Dimensionality reduction:** Condense the original features into a smaller number of new features (each one being a function/combination of the original features) that maintain important relationships in the data. The most well-known technique here is [Principal Component Analysis](https://en.wikipedia.org/wiki/Principal_component_analysis), which also has a [scikit-learn implementation](https://scikit-learn.org/stable/modules/decomposition.html#pca).\n", "- **Regularisation:** Modifies the \"cost function\" of a model to penalise complexity (i.e., preferring solutions that give a large weighting to a smaller number of features). [See this blog post](https://programmathically.com/regularization-in-machine-learning/) for more details. " ] }, { "cell_type": "markdown", "id": "a284e11d", "metadata": {}, "source": [ "## Pipelines\n", "\n", "We've shown how to quickly perform various feature engineering techniques in Pandas, but it's important to consider how to integrate these into a modelling or analysis pipeline. In particular, any transformations you use whilst training a model should be saved so they can later be re-used to test the model on new data. There are other libraries and frameworks which can help you do this more efficiently, such as `scikit-learn` (see the [Dataset transformations section](https://scikit-learn.org/stable/data_transforms.html) of the user guide)." ] } ], "metadata": { "jupytext": { "cell_metadata_filter": "-all", "notebook_metadata_filter": "-all", "text_representation": { "extension": ".md", "format_name": "markdown" } }, "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.9.15" } }, "nbformat": 4, "nbformat_minor": 5 }