{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"tags": [
"remove-input"
]
},
"outputs": [],
"source": [
"from datascience import *\n",
"import matplotlib\n",
"path_data = '../../../assets/data/'\n",
"matplotlib.use('Agg')\n",
"%matplotlib inline\n",
"import matplotlib.pyplot as plots\n",
"plots.style.use('fivethirtyeight')\n",
"import numpy as np"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Applying a Function to a Column\n",
"\n",
"We have seen many examples of creating new columns of tables by applying functions to existing columns or to other arrays. All of those functions took arrays as their arguments. But frequently we will want to convert the entries in a column by a function that doesn't take an array as its argument. For example, it might take just one number as its argument, as in the function `cut_off_at_100` defined below."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"def cut_off_at_100(x):\n",
" \"\"\"The smaller of x and 100\"\"\"\n",
" return min(x, 100)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"17"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"cut_off_at_100(17)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"100"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"cut_off_at_100(117)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"100"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"cut_off_at_100(100)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The function `cut_off_at_100` simply returns its argument if the argument is less than or equal to 100. But if the argument is greater than 100, it returns 100.\n",
"\n",
"In our earlier examples using Census data, we saw that the variable `AGE` had a value 100 that meant \"100 years old or older\". Cutting off ages at 100 in this manner is exactly what `cut_off_at_100` does.\n",
"\n",
"To use this function on many ages at once, we will have to be able to *refer* to the function itself, without actually calling it. Analogously, we might show a cake recipe to a chef and ask her to use it to bake 6 cakes. In that scenario, we are not using the recipe to bake any cakes ourselves; our role is merely to refer the chef to the recipe. Similarly, we can ask a table to call `cut_off_at_100` on 6 different numbers in a column."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"First, we create the table `ages` with a column for people and one for their ages. For example, person `C` is 52 years old."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
" \n",
"
\n",
"
Person
Age
\n",
"
\n",
" \n",
" \n",
"
\n",
"
A
17
\n",
"
\n",
"
\n",
"
B
117
\n",
"
\n",
"
\n",
"
C
52
\n",
"
\n",
"
\n",
"
D
100
\n",
"
\n",
"
\n",
"
E
6
\n",
"
\n",
"
\n",
"
F
101
\n",
"
\n",
" \n",
"
"
],
"text/plain": [
"Person | Age\n",
"A | 17\n",
"B | 117\n",
"C | 52\n",
"D | 100\n",
"E | 6\n",
"F | 101"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ages = Table().with_columns(\n",
" 'Person', make_array('A', 'B', 'C', 'D', 'E', 'F'),\n",
" 'Age', make_array(17, 117, 52, 100, 6, 101)\n",
")\n",
"ages"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## `apply`\n",
"\n",
"To cut off each of the ages at 100, we will use a new Table method. The `apply` method calls a function on each element of a column, forming a new array of return values. To indicate which function to call, just name it (without quotation marks or parentheses). The name of the column of input values is a string that must still appear within quotation marks."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 17, 100, 52, 100, 6, 100])"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ages.apply(cut_off_at_100, 'Age')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"What we have done here is `apply` the function `cut_off_at_100` to each value in the `Age` column of the table `ages`. The output is the array of corresponding return values of the function. For example, 17 stayed 17, 117 became 100, 52 stayed 52, and so on.\n",
"\n",
"This array, which has the same length as the original `Age` column of the `ages` table, can be used as the values in a new column called `Cut Off Age` alongside the existing `Person` and `Age` columns."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
" \n",
"
\n",
"
Person
Age
Cut Off Age
\n",
"
\n",
" \n",
" \n",
"
\n",
"
A
17
17
\n",
"
\n",
"
\n",
"
B
117
100
\n",
"
\n",
"
\n",
"
C
52
52
\n",
"
\n",
"
\n",
"
D
100
100
\n",
"
\n",
"
\n",
"
E
6
6
\n",
"
\n",
"
\n",
"
F
101
100
\n",
"
\n",
" \n",
"
"
],
"text/plain": [
"Person | Age | Cut Off Age\n",
"A | 17 | 17\n",
"B | 117 | 100\n",
"C | 52 | 52\n",
"D | 100 | 100\n",
"E | 6 | 6\n",
"F | 101 | 100"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ages.with_column(\n",
" 'Cut Off Age', ages.apply(cut_off_at_100, 'Age')\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Functions as Values\n",
"We've seen that Python has many kinds of values. For example, `6` is a number value, `\"cake\"` is a text value, `Table()` is an empty table, and `ages` is a name for a table value (since we defined it above).\n",
"\n",
"In Python, every function, including `cut_off_at_100`, is also a value. It helps to think about recipes again. A recipe for cake is a real thing, distinct from cakes or ingredients, and you can give it a name like \"Ani's cake recipe.\" When we defined `cut_off_at_100` with a `def` statement, we actually did two separate things: we created a function that cuts off numbers at 100, and we gave it the name `cut_off_at_100`.\n",
"\n",
"We can refer to any function by writing its name, without the parentheses or arguments necessary to actually call it. We did this when we called `apply` above. When we write a function's name by itself as the last line in a cell, Python produces a text representation of the function, just like it would print out a number or a string value."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"cut_off_at_100"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Notice that we did not write `\"cut_off_at_100\"` with quotes (which is just a piece of text), or `cut_off_at_100()` (which is a function call, and an invalid one at that). We simply wrote `cut_off_at_100` to refer to the function.\n",
"\n",
"Just like we can define new names for other values, we can define new names for functions. For example, suppose we want to refer to our function as `cut_off` instead of `cut_off_at_100`. We can just write this:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"cut_off = cut_off_at_100"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now `cut_off` is a name for a function. It's the same function as `cut_off_at_100`, so the printed value is exactly the same."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"cut_off"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let us see another application of `apply`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Example: Prediction\n",
"\n",
"Data science is often used to make predictions about the future. If we are trying to predict an outcome for a particular individual – for example, how she will respond to a treatment, or whether he will buy a product – it is natural to base the prediction on the outcomes of other similar individuals.\n",
"\n",
"The table below is adapted from a historical data set on the heights of parents and their adult children. Each row corresponds to one adult child. The variables are a numerical code for the family, the heights (in inches) of the father and mother, the number of children in the family, as well as the child's birth rank (1 = oldest), sex (coded only as \"male\" or \"female\"), and height in inches."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
" \n",
"
\n",
"
family
father
mother
children
childNum
sex
childHeight
\n",
"
\n",
" \n",
" \n",
"
\n",
"
1
78.5
67
4
1
male
73.2
\n",
"
\n",
"
\n",
"
1
78.5
67
4
2
female
69.2
\n",
"
\n",
"
\n",
"
1
78.5
67
4
3
female
69
\n",
"
\n",
"
\n",
"
1
78.5
67
4
4
female
69
\n",
"
\n",
"
\n",
"
2
75.5
66.5
4
1
male
73.5
\n",
"
\n",
"
\n",
"
2
75.5
66.5
4
2
male
72.5
\n",
"
\n",
"
\n",
"
2
75.5
66.5
4
3
female
65.5
\n",
"
\n",
"
\n",
"
2
75.5
66.5
4
4
female
65.5
\n",
"
\n",
"
\n",
"
3
75
64
2
1
male
71
\n",
"
\n",
"
\n",
"
3
75
64
2
2
female
68
\n",
"
\n",
" \n",
"
\n",
"
... (924 rows omitted)
"
],
"text/plain": [
"family | father | mother | children | childNum | sex | childHeight\n",
"1 | 78.5 | 67 | 4 | 1 | male | 73.2\n",
"1 | 78.5 | 67 | 4 | 2 | female | 69.2\n",
"1 | 78.5 | 67 | 4 | 3 | female | 69\n",
"1 | 78.5 | 67 | 4 | 4 | female | 69\n",
"2 | 75.5 | 66.5 | 4 | 1 | male | 73.5\n",
"2 | 75.5 | 66.5 | 4 | 2 | male | 72.5\n",
"2 | 75.5 | 66.5 | 4 | 3 | female | 65.5\n",
"2 | 75.5 | 66.5 | 4 | 4 | female | 65.5\n",
"3 | 75 | 64 | 2 | 1 | male | 71\n",
"3 | 75 | 64 | 2 | 2 | female | 68\n",
"... (924 rows omitted)"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Data on heights of parents and their adult children\n",
"family_heights = Table.read_table(path_data + 'family_heights.csv').drop(3)\n",
"family_heights"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A primary reason for collecting the data was to be able to predict the adult height of a child born to parents similar to those in the dataset. Let us try to do this, by using the simple average of the parents' height as the variable on which to base our prediction. \n",
"\n",
"This parent average height is our *predictor* variable. In the cell below, its values are in the array `parent_averages`.\n",
"\n",
"The table `heights` consists of just the parent average heights and child heights. The scatter plot of the two variables shows a positive association as we would expect for these variables."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"heights.scatter('Parent Average')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now suppose the researchers encountered a new couple, similar to those in this dataset, and wondered how tall their child would be. What would be a good way for him to go about predicting the child's height, given that the parent average height was, say, 68 inches?\n",
"\n",
"One reasonable approach would be to base the prediction on all the points that correspond to a parent average height of around 68 inches. The prediction equals the average child's height calculated from those points alone.\n",
"\n",
"Let's execute this plan. For now we will just make a reasonable definition of what \"around 68 inches\" means, and work with that. Later in the course we will examine the consequences of such choices.\n",
"\n",
"We will take \"close\" to mean \"within half an inch\". The figure below shows all the points corresponding to a parent average height between 67.5 inches and 68.5 inches. These are all the points in the strip between the red lines. Each of these points corresponds to one child; our prediction of the height of the new couple's child is the average height of all the children in the strip. That's represented by the gold dot.\n",
"\n",
"Ignore the code, and just focus on understanding the mental process of arriving at that gold dot."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"heights.scatter('Parent Average')\n",
"plots.plot([67.5, 67.5], [50, 85], color='red', lw=2)\n",
"plots.plot([68.5, 68.5], [50, 85], color='red', lw=2)\n",
"plots.scatter(68, 67.62, color='gold', s=40);"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In order to calculate exactly where the gold dot should be, we first need to indentify all the points in the strip. These correspond to the rows where `Parent Average` is between 67.5 inches and 68.5 inches."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
" \n",
"
\n",
"
Parent Average
Child
\n",
"
\n",
" \n",
" \n",
"
\n",
"
68
74
\n",
"
\n",
"
\n",
"
68
70
\n",
"
\n",
"
\n",
"
68
68
\n",
"
\n",
"
\n",
"
68
67
\n",
"
\n",
"
\n",
"
68
67
\n",
"
\n",
"
\n",
"
68
66
\n",
"
\n",
"
\n",
"
68
63.5
\n",
"
\n",
"
\n",
"
68
63
\n",
"
\n",
"
\n",
"
67.5
65
\n",
"
\n",
"
\n",
"
68.1
62.7
\n",
"
\n",
" \n",
"
\n",
"
... (175 rows omitted)
"
],
"text/plain": [
"Parent Average | Child\n",
"68 | 74\n",
"68 | 70\n",
"68 | 68\n",
"68 | 67\n",
"68 | 67\n",
"68 | 66\n",
"68 | 63.5\n",
"68 | 63\n",
"67.5 | 65\n",
"68.1 | 62.7\n",
"... (175 rows omitted)"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"close_to_68 = heights.where('Parent Average', are.between(67.5, 68.5))\n",
"close_to_68"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The predicted height of a child who has a parent average height of 68 inches is the average height of the children in these rows. That's 67.62 inches."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"67.62"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.average(close_to_68.column('Child'))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We now have a way to predict the height of a child given any value of the parent average height near those in our dataset. We can define a function `predict_child` that does this. The body of the function consists of the code in the two cells above, apart from choices of names."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"def predict_child(p_avg):\n",
" \"\"\"Predict the height of a child whose parents have a parent average height of p_avg.\n",
" \n",
" The prediction is the average height of the children whose parent average height is\n",
" in the range p_avg plus or minus 0.5.\n",
" \"\"\"\n",
" \n",
" close_points = heights.where('Parent Average', are.between(p_avg-0.5, p_avg + 0.5))\n",
" return np.average(close_points.column('Child')) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Given a parent average height of 68 inches, the function `predict_child` returns the same prediction (67.62 inches) as we got earlier. The advantage of defining the function is that we can easily change the value of the predictor and get a new prediction."
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"67.62"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"predict_child(68)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"66.08640776699029"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"predict_child(66)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"How good are these predictions? We can get a sense of this by comparing the predictions with the data that we already have. To do this, we first apply the function `predict_child` to the column of `Parent Average` heights, and collect the results in a new column labeled `Prediction`."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"# Apply predict_child to all the midparent heights\n",
"\n",
"heights_with_predictions = heights.with_column(\n",
" 'Prediction', heights.apply(predict_child, 'Parent Average')\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"