{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Exogenous Processes" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "**Note:** Exogenous proccesses are currently still under development. We suggest you tread carefully when adding them to a model. You can help us out by raising issues on GitHub for problems you encounter.\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Exogenous processes are used in many structural models to embed dynamic features of the data which cannot be controlled by the individual like economic conditions (Diermeier et al., 2005), layoffs (Behrman et al., 2016) or job offer availability (Cohen-Goldner and Eckstein, 2008). The last two examples are arguably not completely exogenous which points to the second purpose of exogenous processes: simplifying the choice set. Although there are papers explicitly modeling the desire to have a child (Todd and Wolpin, 2006), most studies treat fertility as an exogenous process starting and ending at some age or a maximum number of children (Behrman et al., 2006).\n", "\n", "What does an exogenous process mean to the model? In models without exogenous processes the law of motion, the transition of states over periods, is **deterministic**. Given a state and a choice the state in the next period is certain. Exogenous processes introduce a **stochastic** element to the law of motion. Given a state and a choice there exist multiple states in the next period which are valid successors. The transition to one of the successors is determined by a probability which depends on the characteristics of the state.\n", "\n", "For the solution of the structural model, this means that the continuation values have to be weighted by the probabilities of the exogenous process. In the simulation, one has to sample the new values of the exogenous process in the law of motion.\n", "\n", "In the following, we will discuss three different kinds of exogenous processes.\n", "\n", "1. Processes affecting the rewards of choices (economic conditions).\n", "2. Processes affecting the availability of choices (job availability, retirement).\n", "3. Processes with increasing characteristics (children)." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import io\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", "\n", "import respy as rp\n", "\n", "pd.set_option(\"display.max_rows\", 100)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Processes affecting the rewards of choices\n", "\n", "We start from the basic model of the Robinson Crusoe economy. Just to reiterate, Robinson is on an island and can choose between two alternatives every period. He can either go fishing and accumulate experience to become a better fisher or stay in the hammock.\n", "\n", "We extend the basic model by representing Robinson's health with an exogenous process. For simplicity, we assume that the process has two outcomes. Robinson is either well or sick and only if he is sick, fishing is more difficult for him." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "params, options = rp.get_example_model(\"robinson_crusoe_basic\", with_data=False)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "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", "
value
categoryname
deltadelta0.95
wage_fishingexp_fishing0.30
nonpec_fishingconstant-0.20
nonpec_hammockconstant2.00
shocks_sdcorrsd_fishing0.50
sd_hammock0.50
corr_hammock_fishing0.00
\n", "
" ], "text/plain": [ " value\n", "category name \n", "delta delta 0.95\n", "wage_fishing exp_fishing 0.30\n", "nonpec_fishing constant -0.20\n", "nonpec_hammock constant 2.00\n", "shocks_sdcorr sd_fishing 0.50\n", " sd_hammock 0.50\n", " corr_hammock_fishing 0.00" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "params" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First, we have to define the exogenous process. We assume that Robinson has a chance of 90% for being well in the next period and a 10% chance of being sick. To implement the exogenous process, we have to alter the `params` and `options` of our model. Similar to when adding observables, we follow certain naming conventions so **respy** can process our inputs correctly. " ] }, { "cell_type": "raw", "metadata": {}, "source": [ "
\n", " Tutorials\n", "\n", " Find out more about observables.\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When specifying the parameter category, we have to use the prefix `exogenous_process` to indicate that the corresponding parameters belong to an exogenous process. `health` is used as the name of the exogenous process and `well` and `sick` are the potential values. With `probability` we indicate that the following value should be treated as a probability." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "params.loc[(\"exogenous_process_health_well\", \"probability\"), \"value\"] = 0.9\n", "params.loc[(\"exogenous_process_health_sick\", \"probability\"), \"value\"] = 0.1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we amend the rewards and add a penalty to the working alternative fishing if Robinson is sick. We also need to add a covariate which defines what `sick` in `params` means, because, up to now, `sick` is only a potential value of the variable `health`, but not a variable itself. To specify the covariate, we need to add it to the `options`." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "params.loc[(\"nonpec_fishing\", \"sick\"), \"value\"] = -2" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "options[\"covariates\"][\"sick\"] = \"health == 'sick'\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "That's it. There nothing else to be done to define the process. But before we begin to simulate data, we have to define the distribution of `health` in the first period of the simulated data. Note that, the parameters under the keyword `exogenous_process` only define the transition probabilities. The parameters are only necessary for n-step-ahead simulation with sampling as explained in the guide on initial conditions. We can do this using the `observable` keyword and use the same probabilities as the process." ] }, { "cell_type": "raw", "metadata": {}, "source": [ "
\n", " How-to Guide\n", "\n", " Find out more about different types of simulation.\n", "
" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "params.loc[(\"observable_health_well\", \"probability\"), \"value\"] = 0.9\n", "params.loc[(\"observable_health_sick\", \"probability\"), \"value\"] = 0.1" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "simulate = rp.get_simulate_func(params, options)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "df = simulate(params)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following figure shows that the shares of health conditions are indeed reflected in the data." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "df[\"Health\"].value_counts(normalize=True).plot.bar(rot=0);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Does the process affect the choices in the predicted way? The following figure shows that if Robinson is sick, choosing hammock is four times more likely than fishing." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "df.groupby(\"Health\")[\"Choice\"].value_counts(normalize=True).unstack().plot.bar(rot=0);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Processes affecting the availability of choices\n", "\n", "Exogenous processes are also used to influence the choice set. As an example, let us further extend the model with an exogenous process of the weather. There is a 20% chance of a tropical storm which makes fishing impossible and an 80% chance of sunny weather which allows all activities. Note that, this process works simultaenously with the health process. There is not restriction regarding the number of exogenous processes.\n", "\n", "Firstly, implement the transition probabilities." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "params.loc[(\"exogenous_process_weather_tropical_storm\", \"probability\"), \"value\"] = 0.2\n", "params.loc[(\"exogenous_process_weather_sunny\", \"probability\"), \"value\"] = 0.8" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Then, use the `negative_choice_set` setting in the `options` to indicate which choices are not available. `negative_choice_set` is a dictionary where the keys are the choices. The values are lists of conditions which prevent an individual to choose the alternative if the statement is true. All statements are connected via the logical or and not and. Here, we prevent any individual from choosing fishing if there is a tropical storm." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "options[\"negative_choice_set\"] = {\"fishing\": [\"weather == 'tropical_storm'\"]}" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "xxx\\respy\\respy\\pre_processing\\model_processing.py:217: UserWarning: The distribution of initial values for the exogenous process 'weather' is not defined in 'params'. Use the 'observable' keyword for this. This is only necessary for the n-step-ahead simulation. In the following, values are assumed to be equiprobable.\n", " \"The distribution of initial values for the exogenous process \"\n" ] } ], "source": [ "simulate = rp.get_simulate_func(params, options)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the warning is raised because we forgot to specify the distribution of `weather` in the first period." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "xxx\\respy\\respy\\pre_processing\\model_processing.py:217: UserWarning: The distribution of initial values for the exogenous process 'weather' is not defined in 'params'. Use the 'observable' keyword for this. This is only necessary for the n-step-ahead simulation. In the following, values are assumed to be equiprobable.\n", " \"The distribution of initial values for the exogenous process \"\n" ] } ], "source": [ "df = simulate(params)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Below we see that realizations of `weather` are indeed equiprobable in the first period." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tropical_storm 0.511\n", "sunny 0.489\n", "Name: Weather, dtype: float64" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.query(\"Period == 0\").Weather.value_counts(normalize=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We show the two figures from the health process first to show that this process has not changed." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, axs = plt.subplots(1, 2, figsize=(8, 4))\n", "\n", "df[\"Health\"].value_counts(normalize=True).plot.bar(ax=axs[0], rot=0)\n", "df.groupby(\"Health\")[\"Choice\"].value_counts(normalize=True).unstack().plot.bar(\n", " ax=axs[1], rot=0\n", ");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Secondly, we show the distribution of choices across weather conditions." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "df.groupby(\"Weather\")[\"Choice\"].value_counts(normalize=True).unstack().plot.bar(rot=0);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Processes with increasing characteristics\n", "\n", "Lastly, we implement a more complex exogenous process which can be used to model the desire to have a child instead of including it in the choice set. As this feature is frequently used in structural models analyzing female labor force participation (Behrman et al., 2016, Blundell et al., 2016). We focus on Robin Kreutzner, Robinson's half sister, who shares the same father, a Bremen merchant. She lives in York during the 17th century and works in a weaving mill. From age 15 onwards, there is a chance that Robin becomes pregnant and gives birth to one or two children in one period for the following 30 periods. As child care is extremely underdeveloped at that time and her mother cannot take care of the children every time, working at the weaving mill becomes more difficult for her with every child.\n", "\n", "The main difference of such a process in contrast to others is that in each state not all potential values of the process are available. We assume that the number of children can only increase, meaning there is no child death. Although singleton pregancies are the most common form of pregancies, we also allow for twins with a very small probability.\n", "\n", "The following cell contains the basic parameterization of the model. There is one working alternative, `weaving`, and one non-working alternative, `home`." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "params = pd.read_csv(\n", " io.StringIO(\n", " \"\"\"\n", "category,name,value\n", "delta,delta,0.95\n", "wage_weaving,exp_weaving,0.1\n", "nonpec_weaving,constant,-1\n", "nonpec_weaving,children,-5\n", "nonpec_home,constant,2.5\n", "shocks_sdcorr,sd_weaving,1\n", "shocks_sdcorr,sd_home,1\n", "shocks_sdcorr,corr_home_weaving,-0.2\n", "\"\"\"\n", " ),\n", " index_col=[\"category\", \"name\"],\n", ")\n", "\n", "options = {\n", " \"n_periods\": 30,\n", " \"covariates\": {\"constant\": \"1\"},\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we will define the process for this very artificial example. The main reason why the following distribution is so complex is that the process has to be defined going from a certain number of children to another number of children. Note that, all parameters are coefficients of an multinomial logit as explained in the guide on the initial conditions." ] }, { "cell_type": "raw", "metadata": {}, "source": [ "
\n", " How-to Guide\n", "\n", " Find out more about initial conditions.\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The general idea for the transition probabilities is as follows:\n", "\n", "- The number of children cannot drop.\n", "- Up to the third child, there is a ...\n", " - 90% chance of having no additional child\n", " - 9% chance of having one additional child\n", " - 1% chance of having two additional children\n", " \n", " ... in the next period.\n", "- Beyond the third child, there is a ...\n", " - 98% chance of having no additional child\n", " - 1.9% chance of having one additional child\n", " - 0.1% chance of having two additional children\n", " \n", " ... in the next period.\n", "- No one has more than six children.\n", "\n", "Let us take a look at the first set of parameters. Under `exogenous_process_children_0` we specify the transition probabilities from any state with any number of children to a state with no children at all. The first parameter `has_children` adds a huge negative penalty in case the state has children. Thus, the transition probability from any state with children to a state with zero children is zero. For states with zero children, we want to have a 90% chance of having no children in the next period as well. Thus, we use $\\log 0.9 \\approx -1.05$ as the parameter value. (This trick is also explained in the initial conditions guide.)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "params.loc[(\"exogenous_process_children_0\", \"no_children\"), \"value\"] = -0.105\n", "params.loc[(\"exogenous_process_children_0\", \"has_children\"), \"value\"] = -1e300" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To define the transition to having one child, we use $-2.408 \\approx \\log 0.09$ as the parameter for a state with no children. $-0.105 \\approx \\log 0.9$ ensures that with 90% chance, there is no additional child for states with already one child. The huge penalty for `more_than_one_child` ensures that there is no backward motion." ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "params.loc[(\"exogenous_process_children_1\", \"no_children\"), \"value\"] = -2.408\n", "params.loc[(\"exogenous_process_children_1\", \"one_child\"), \"value\"] = -0.105\n", "params.loc[(\"exogenous_process_children_1\", \"more_than_one_child\"), \"value\"] = -1e300" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we define the transition to states with two children. The majority of the parameters is analogously defined to the former explanations. But, note that the first parameter specifies the transition from states with no children to states with two children and therefore the possibility of having twins. The parameter value is $-4.605 \\approx \\log 0.01$." ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "params.loc[(\"exogenous_process_children_2\", \"no_children\"), \"value\"] = -4.605\n", "params.loc[(\"exogenous_process_children_2\", \"one_child\"), \"value\"] = -2.408\n", "params.loc[(\"exogenous_process_children_2\", \"two_children\"), \"value\"] = -0.105\n", "params.loc[(\"exogenous_process_children_2\", \"more_than_two_children\"), \"value\"] = -1e300\n", "\n", "params.loc[(\"exogenous_process_children_3\", \"no_children\"), \"value\"] = -1e300\n", "params.loc[(\"exogenous_process_children_3\", \"one_child\"), \"value\"] = -4.605\n", "params.loc[(\"exogenous_process_children_3\", \"two_children\"), \"value\"] = -2.408\n", "params.loc[(\"exogenous_process_children_3\", \"three_children\"), \"value\"] = -0.105\n", "params.loc[\n", " (\"exogenous_process_children_3\", \"more_than_three_children\"), \"value\"\n", "] = -1e300" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As discussed before, the transition probabilities to states with at least four children change." ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "params.loc[(\"exogenous_process_children_4\", \"less_than_two_children\"), \"value\"] = -1e300\n", "params.loc[(\"exogenous_process_children_4\", \"two_children\"), \"value\"] = -6.908\n", "params.loc[(\"exogenous_process_children_4\", \"three_children\"), \"value\"] = -3.963\n", "params.loc[(\"exogenous_process_children_4\", \"four_children\"), \"value\"] = -0.02\n", "params.loc[\n", " (\"exogenous_process_children_4\", \"more_than_four_children\"), \"value\"\n", "] = -1e300\n", "\n", "params.loc[\n", " (\"exogenous_process_children_5\", \"less_than_three_children\"), \"value\"\n", "] = -1e300\n", "params.loc[(\"exogenous_process_children_5\", \"three_children\"), \"value\"] = -6.908\n", "params.loc[(\"exogenous_process_children_5\", \"four_children\"), \"value\"] = -3.963\n", "params.loc[(\"exogenous_process_children_5\", \"five_children\"), \"value\"] = -0.02\n", "params.loc[(\"exogenous_process_children_5\", \"six_children\"), \"value\"] = -1e300\n", "\n", "params.loc[\n", " (\"exogenous_process_children_6\", \"less_than_four_children\"), \"value\"\n", "] = -1e300\n", "params.loc[(\"exogenous_process_children_6\", \"four_children\"), \"value\"] = -6.908\n", "params.loc[(\"exogenous_process_children_6\", \"five_children\"), \"value\"] = -3.963" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we need to specify that all Robins start with no children." ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "params.loc[(\"observable_children_0\", \"probability\"), \"value\"] = 1\n", "params.loc[(\"observable_children_1\", \"probability\"), \"value\"] = 0\n", "params.loc[(\"observable_children_2\", \"probability\"), \"value\"] = 0\n", "params.loc[(\"observable_children_3\", \"probability\"), \"value\"] = 0\n", "params.loc[(\"observable_children_4\", \"probability\"), \"value\"] = 0\n", "params.loc[(\"observable_children_5\", \"probability\"), \"value\"] = 0\n", "params.loc[(\"observable_children_6\", \"probability\"), \"value\"] = 0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The many covariates are defined here and added to the `options` of the model." ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "options[\"covariates\"].update(\n", " {\n", " \"no_children\": \"children == 0\",\n", " \"has_children\": \"children > 0\",\n", " \"one_child\": \"children == 1\",\n", " \"more_than_one_child\": \"children > 1\",\n", " \"two_children\": \"children == 2\",\n", " \"less_than_two_children\": \"children < 2\",\n", " \"more_than_two_children\": \"children > 2\",\n", " \"three_children\": \"children == 3\",\n", " \"less_than_three_children\": \"children < 3\",\n", " \"more_than_three_children\": \"children > 3\",\n", " \"four_children\": \"children == 4\",\n", " \"less_than_four_children\": \"children < 4\",\n", " \"more_than_four_children\": \"children > 4\",\n", " \"five_children\": \"children == 5\",\n", " \"six_children\": \"children == 6\",\n", " }\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let us simulate the data!" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "simulate = rp.get_simulate_func(params, options)\n", "df = simulate(params)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Firstly, we take a look at the final distribution of children in the last period." ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "df.query(\"Period == Period.max()\").Children.value_counts(\n", " normalize=True\n", ").sort_index().plot.bar(rot=0);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Secondly, we take a look at the transitions from the previous number of children to the value in the next period." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "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", "
Children0123456
Prev_Children
0.08756858940000
1.00649865678000
2.0005150509500
3.0000521112180
4.00000938140
5.000000904
6.000000010
\n", "
" ], "text/plain": [ "Children 0 1 2 3 4 5 6\n", "Prev_Children \n", "0.0 8756 858 94 0 0 0 0\n", "1.0 0 6498 656 78 0 0 0\n", "2.0 0 0 5150 509 5 0 0\n", "3.0 0 0 0 5211 121 8 0\n", "4.0 0 0 0 0 938 14 0\n", "5.0 0 0 0 0 0 90 4\n", "6.0 0 0 0 0 0 0 10" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df[\"Prev_Children\"] = df.groupby(\"Identifier\")[\"Children\"].transform(\"shift\")\n", "pd.crosstab(df.Prev_Children, df.Children)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "At last, we plot the choice probabilities versus the number of children. As expected, a higher number of children is correlated with choosing `home` because of the penalty in the non-pecuniary rewards of `weaving`." ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "df.groupby(\"Children\")[\"Choice\"].value_counts(normalize=True).unstack().plot.bar(stacked=True);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Notes for the estimation\n", "\n", "The example for the exogenous process for children required many parameters which are not directly suited for estimation. Part of the parameters, the penalties, only exist to give structure to the process and turn a general exogenous process where all values are accessible all the time to an incrementing process. During the estimation of the model, these parameters should be fixed such that the optimizer does not accidentally redefine the process.\n", "\n", "Another part of the parameters is repetitive for the groups up to three children and beyond. If the parameters should have the same value, use `estimagic`'s [equality constraints](https://estimagic.readthedocs.io/en/latest/how_to_guides/optimization/how_to_specify_constraints.html). This ensures that the optimizer only sees one parameter instead of all similar parameters." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## References\n", "\n", "- Behrman, J. R., Tincani, M. M., Todd, P. E., & Wolpin, K. I. (2016). [Teacher quality in public and private schools under a voucher system: The case of Chile.](https://scholarship.rice.edu/bitstream/handle/1911/94185/Teacher-Quality-Chile.pdf) *Journal of Labor Economics, 34*(2), 319-362.\n", "\n", "- Blundell, R., Costa Dias, M., Meghir, C., & Shaw, J. (2016). [Female labor supply, human capital, and welfare reform.](https://www.nber.org/papers/w19007.pdf) *Econometrica, 84*(5), 1705-1753.\n", "\n", "- Cohen‐Goldner, S., & Eckstein, Z. (2008). [Labor mobility of immigrants: Training, experience, language, and opportunities.](https://www.econstor.eu/bitstream/10419/21422/1/dp519.pdf) *International Economic Review, 49*(3), 837-872.\n", "\n", "- Diermeier, D., Keane, M., & Merlo, A. (2005). [A political economy model of congressional careers.](https://www.econstor.eu/bitstream/10419/31182/1/586098267.PDF) *American Economic Review, 95*(1), 347-373.\n", "\n", "- Todd, P. E., & Wolpin, K. I. (2006). [Assessing the impact of a school subsidy program in Mexico: Using a social experiment to validate a dynamic behavioral model of child schooling and fertility.](https://pdfs.semanticscholar.org/5176/d1142bee77741599114ca4f661ddfa5c5101.pdf) *American economic review, 96*(5), 1384-1417." ] } ], "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.10" } }, "nbformat": 4, "nbformat_minor": 4 }