my-markdown-library 0.1.0

data/F24Lec_MD/lec07/7.2-historical-inequality.md

@@ -0,0 +1,237 @@
+---
+title: "7.2-historical-inequality"
+type: lecture-notebook
+week: 7
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec07/7.2-historical-inequality.ipynb"
+---
+
+```python
+import pandas as pd
+import numpy as np
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+from datascience import *
+%matplotlib inline
+plt.style.use('seaborn-v0_8-muted')
+mpl.rcParams['figure.figsize'] = (10.0, 10.0)
+```
+
+# Income Inequality Historically
+
+<!-- Written by Amal Bhatnagar -->
+
+In the last chart on the previous page, you may have noticed that income inequality was rising in the United States in the last few decades. We will examine this in more detail, and also observe global trends in inequality.
+
+## The United States
+
+Let's look at historical trends of income inequality in the US over the last 100 years. The data has been collected from [The World Inequality Database](https://wid.world/), which is co-directed by Berkeley Economics professors Emanuel Saez and Gabriel Zucman. Specifically, we will observe income distributions for the bottom 50 percent, top 10 percent, and top 1 percent.
+
+```python
+us_hist = Table.read_table("US_inequality.csv")
+us_hist.show(5)
+```
+
+```python
+us_hist.take(np.arange(100,105))
+```
+
+Let's begin with some data cleaning: it seems like our 3 brackets are 'vertically stacked' on top of each other. Instead, we would like a table with 5 columns: `Year`, `bottom 50% income share`, `top 10% income share`, and `top 1% income share`.
+
+```python
+bottom_50_us = us_hist.where("Percentile", "p0p50").drop("Percentile").relabeled("Income Share", "Bottom 50% Share")
+top_10_us = us_hist.where("Percentile", "p90p100").drop("Percentile").relabeled("Income Share", "Top 10% Share")
+top_1_us = us_hist.where("Percentile", "p99p100").drop("Percentile").relabeled("Income Share", "Top 1% Share")
+us_hist_joined = bottom_50_us.join("Year", top_10_us).join("Year", top_1_us)
+us_hist_joined
+```
+
+Oh no, there are some `nan` values! NaN (not a number) values are very common in real world datasets: often, we may not have some observations simply because no data was collected, or perhaps the data collected was faulty. Sometimes, we can try to impute or replace NaN values in order to avoid having gaps in our data, but for now let's ignore NaNs and when plotting to see what's going on:
+
+```python
+# mpl.rcParams['figure.dpi'] = 120
+us_hist_joined.plot("Year", width=11, height=7)
+plt.title("Income Share over Time", fontsize = 16)
+plt.ylabel("Proportion", fontsize = 14)
+plt.xlabel("Year", fontsize = 14)
+plt.show()
+```
+
+# Income Inequality for the Rest of the World
+
+Now let's examine the trends of income inequality in other parts of the world.
+
+```python
+world_hist = Table.read_table("World_Inequality.csv")
+bottom_50_world = world_hist.where("Percentile", "p0p50").drop("Percentile")
+top_10_world = world_hist.where("Percentile", "p90p100").drop("Percentile")
+top_1_world = world_hist.where("Percentile", "p99p100").drop("Percentile")
+top_10_world
+```
+
+```python
+top_10_world.plot("Year", width=11, height=7)
+plt.ylabel("Gini Coefficient", fontsize=14)
+plt.xlabel("Year", fontsize=14)
+plt.title("Income Inequality over Time", fontsize=18);
+```
+
+Just like the US, it seems global inequality has been rising around the world, especially in China, India, Russia, and across Europe. However, in absolute terms, the level of income inequality in Europe is much lower than that in the United States. 
+
+Also look at Russia: income inequality spiked up around 1991. This was likely caused by the fall of the USSR: the failing Soviet state left the ownership of state assets uncontested, which allowed former USSR officials to acquire state property through informal deals. This led to the rise of many Russian oligarchs - those who rapidly accumulated wealth during the era of Russian privatization directly follwing the dissolution of the Soviet Union.
+
+```python
+top_10_world.select("Year", "USA", "Europe").plot("Year", width=11, height=7)
+plt.ylabel("Gini Coefficient", fontsize=14)
+plt.xlabel("Year", fontsize=14)
+plt.title("Income Inequality over Time", fontsize=18);
+```
+
+##  The Elephant Graph
+
+```{figure} elephant_curve.jpg
+---
+width: 500px
+name: elephant-curve
+---
+The elephant curve {cite}`10inequality-elephantCurve`
+```
+
+The elephant curve is a graph that shows the real income growth per adult across each income group’s percentile around the world. 
+
+There are 3 key features of the elephant curve: a hump for the world’s poorest, valley for the middle class, and trunk for the upper class. The thump is made of the world’s poorest countries, most likely those from developing countries. The valley comprises the working class from the developed world and upper class from developing countries. The trunk is made of people from the upper class from developed countries. The hump and valley indicate growth among emerging countries, and the top global 1%’s growth is higher than any other income group, thus explaining the positively sloped shape of the trunk. 
+
+
+A study done by the Brookings Institution] found that “poorer countries, and the lower income groups within those countries, have grown most rapidly in the past 20 years” {cite}`10inequality-brookings`. This supports the World Bank’s claim that inequality between countries and within countries is decreasing. The Brookings Institution used only household surveys, however, which usually excludes the top and bottom percentile of the population, due to non-response bias. Still, the study is useful in corroborating the trends and growth in global income inequality.
+
+# Factors that Affect Income Inequality
+
+Economists have isolated multiple factors that influence a country's income inequality
+- top marginal tax rates
+- unemployment rates
+- population growth
+
+We will look at each of these scenarios independently and see its overall trends
+
+## Top marginal tax rates
+
+Let's also take a look at the top marginal tax rates in the United States throughout this time. Overall, the United States (and most of the rest of the world) has a progressive tax system, which means that the more income you earn, the higher percentage you will be taxed at. A good way to reduce income inequality is through progressive taxation; having the richer paying a higher portion of their income will help increase equality. Currently, the top marginal tax rate is 37%, as we can see in the table below.
+
+```{figure} MTR.png
+---
+width: 500px
+name: irs
+---
+Marginal tax rates. Image from the IRS
+```
+
+The top marginal tax rate only applies to the portion of your income above a certain income level. For example, if you earned 19501 dollars in 2019, then you will pay 1940 dollars plus 12% of $19501-19401$, i.e. 12 dollars. For another example, if you earned 80000 dollars, then you will pay $9086 + 0.22(80000-78950) = 9317$ dollars in tax, effectively a $\frac{9317}{80000} = 11.6\%$ tax rate.
+
+In general, the idea is you will pay a lower tax rate for your first $x$ dollars, but a higher rate for dollars earned over $x$.
+
+Now let's look at the historical trends in marginal top tax rates, which is the % taxed at the highest tax bracket.
+
+```python
+toptax = Table.read_table("toptaxrate.csv")
+toptax
+```
+
+```python
+# mpl.rcParams['figure.dpi'] = 120
+toptax.plot(0,1, width=11, height=7)
+plt.title("Top Marginal Tax Rate over Time", fontsize = 18)
+plt.show()
+```
+
+```python
+# mpl.rcParams['figure.dpi'] = 120
+us_hist_joined.plot("Year", width=11, height=7)
+plt.title("Income Share over Time", fontsize = 18)
+plt.ylabel("Proportion", fontsize = 14)
+plt.xlabel("Year", fontsize = 14)
+plt.show()
+```
+
+This graph depicts income inequality decreasing between 1910 and 1970 and increasing from 1970 to present. 
+
+In 1913, Congress implemented the current income tax to promote equality. Originally meant to help compensate for revenue lost from reducing high tariffs, the new policy essentially made the top 1% start contributing to taxes. Additionally, the top marginal tax rate increased from 7% in 1913 to 73% in 1918, thus helping reduce income inequality. Right before the Great Depression, income inequality peaked, where the richest 1% possessed 19.6% of all income. During the Great Depression, top marginal tax rates increased, peaking at 94% in 1944. The top marginal tax rate decreased but remained high over subsequent decades, where it was 70% in 1965 and 50% in 1982. These high top marginal tax rates are correlated with low income inequality. During the Great Depression, the richest 1% had about 15% of total income. For the 10 years after the Great Depression, the top 1% had below 10% of total income and 8% for the 30 years afterwards. This period was known as the Great Compression, as income differentials between the top 1% and the rest of the country decreased.
+
+In the 1970s, the economy took a turn for the worse with high unemployment and inflation (stagflation) and low growth. In order to stimulate economic growth, the government reduced top marginal tax rates (70% to 38.5% in 1980s), deregulated corporate institutions, and attacked labor union memberships (membership decreased by half within 30 years). Although these policies improved economic growth, it resulted in higher income inequality.
+
+The graph below better shows that the share of income earned by the bottom 50% percentile steadily decreased, while the share earned by the top 1% increased steadily. This means that the top 1% has more wealth than the entire bottom 50% of the population. Suppose a class of 100 people has \$100 in aggregate. In a world with perfect equality, each person would have \$1. With this current level of income inequality, one person would have more wealth than 50 people combined. 
+
+The media continues to report on the nation's significant income disparity. [The Washington Post wrote a story](https://www.washingtonpost.com/business/2019/09/26/income-inequality-america-highest-its-been-since-census-started-tracking-it-data-show/) and found that “The number of families earning \$15,000 or less has fallen since 2007, according to the latest census data, while the number of households bringing in \$250,000 a year or more has grown more than 15 percent.” 
+
+Can we conclude that high marginal tax rates lead to low income inequality but slow economic growth?
+
+## Unemployment rates
+
+Economists believe that unemployment is one of the leading factors that leads to income inequality. When looking at what influences the Gini coefficient, a paper from [Princeton](https://rpds.princeton.edu/sites/rpds/files/media/menendez_unemployment_ar.pdf) found that the unemployment rate had the largest effect on the income inequality rates
+
+Below, we look at the unemployment rates for the past 20 years across many different countries. These are the same countries and regions that we will further study below.
+
+```python
+unemployment = Table.read_table("Unemployment.csv")
+unemployment
+```
+
+As we can see from the graph, the unemployment rates for China, India and the rest of the world have stayed somewhat steady. On the other hand, Brazil, the US, Russia and Europe are encountering drastically different unemployment situations than before.
+
+```python
+# mpl.rcParams['figure.dpi'] = 120
+unemployment.plot("Year", width=11, height=7)
+plt.ylabel("Unemployment Rate (%)", fontsize = 14)
+plt.xlabel("Year", fontsize =14)
+plt.title("Unemployment Rate over Time", fontsize = 18)
+plt.show()
+```
+
+```python
+top_10_world.plot("Year", width=11, height=7)
+plt.ylabel("Gini Coefficient", size=14)
+plt.xlabel("Year", fontsize=14)
+plt.title("International Income Inequality over Time", fontsize=18)
+plt.show()
+```
+
+The graphs above show a positive correlation between unemployment and income inequality. As unemployment increases, income inequality also increases. In 2011, Hanan Morsy, an Egyptian economist who serves as the Director of Macroeconomic Policy, Forecasting and Research at the African Development Bank, actually researched this topic {cite}`10inequality-morsy`. Her group examined the member nations of the Organization  for  Economic  Cooperation  and  Development  (OECD) between 1980 and 2005. She found that specific groups that were vulnerable to the economic shocks that led to an increase in income inequality:
+- young workers
+- low-skilled workers
+- workers who had been out of work for a long time
+
+Her solution was to increase job creation opportunities for temporary, recently fired, and recently hired workers, provide job assistance and training to prevent long-term unemployment, and improve incentives for working by aligning incentives with productivity of labor. Morsy's research found that the most vulnerable groups to economic shocks were young, low-skilled and temporary workers. Creating opportunities for these different demographics would help them be more protected from potential shocks and thus decrease income inequality.
+
+## Population growth
+
+As the number of people in a country's population increase, it becomes more difficult for a country to distribute its public goods to everyone. This leads to many social consequences in which resources are not fairly distributed to all members of the population, cause inaccessibility for different parts of the population
+
+The table below shows how the population growth has changed for the same countries we saw above. We are only looking at data for the past 10 years.
+
+```python
+pop_growth = Table.read_table("Population Growth.csv")
+pop_growth
+```
+
+```python
+pop_growth.plot("Year", width=11, height=7)
+plt.title("Population Growth over Time", fontsize = 18)
+plt.ylabel("Population Growth (%)", fontsize = 14)
+plt.xlabel("Year", fontsize = 14)
+plt.show()
+```
+
+```python
+top_10_world.plot("Year", width=11, height=7)
+plt.ylabel("Gini Coefficient", fontsize=14)
+plt.xlabel("Year", fontsize=14)
+plt.title("International Income Inequality over Time", fontsize=18)
+plt.show()
+```
+
+The graphs above show that most countries high population growth between 1-2% during the 1980's. The effects of this can be seen in the rising income inequality during the 90's.  
+
+Recent research by University of Toronto's Marijn Bolhuis and Univeristy of Oxford's Alexandra de Pleijt shows that there is a strong correlation between a country's population growth (measured by birth rates) and its income inequality {cite}`10inequality-popGrowth`. Their most recent study in 2016 analyzed income inequality and birth rates data between 1870 and 2000 across 67 countries. They concluded that if a country had 50% higher income inequality, then that country's birth rate would be about twice as high as another country with the same level of economic development. Bolhuis says that these higher birth rates mean that economic growth has to be equal to or greater than the birth rate to offset the implications of higher birth rates. 
+
+This is part of a larger debate about the relationship between birth rates and income inequality. Economist Thomas Piketty finds that low birth rates, rather than high birth rates, are causing today's income inequality. With lower birth rates, fewer children per couple are being borne, so these children get more of their parents' inheritance.
+
+
+

data/F24Lec_MD/lec08/macro-fred-api.md

@@ -0,0 +1,313 @@
+---
+title: "macro-fred-api"
+type: lecture-notebook
+week: 8
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec08/macro-fred-api.ipynb"
+---
+
+<table style="width: 100%;" id="nb-header">
+    <tr style="background-color: transparent;"><td>
+        <img src="https://data-88e.github.io/assets/images/blue_text.png" width="250px" style="margin-left: 0;" />
+    </td><td>
+        <p style="text-align: right; font-size: 10pt;"><strong>Economic Models</strong>, EdX<br>
+            Dr. Eric Van Dusen <br>
+            Alan Liang <br> 
+            Umar Maniku <br> 
+            Matthew Yep <br> 
+            Yiyang Chen <br> 
+            Bennett Somerville <br>
+        Akhil Venkatesh <br>
+</table>
+
+# Lecture Notebook 4.3: Macroeconomic Indicators
+
+```python
+import os
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+%matplotlib inline
+```
+
+```python
+# Load our API key from the .env file
+def load_environment_variables(filename):
+    with open(filename) as f:
+        for line in f:
+            (key, value) = line.replace('\n', '').split('=')
+            os.environ[key] = value
+
+load_environment_variables('.env')
+```
+
+**Learning Objectives:**  
+In this notebook, we will download macroeconomic data and examine how the models and theories we discussed in lecture fit with these real life data. This notebook will introduce the basic concept of an API, the way to use it for economic research and study.
+
+## Macroeconomic Data and Fred API
+
+We will start by first download some macroeconomic data from FRED. In this notebook, we will introduce two ways of interacting with online sources of data with API (Application Programming Interface).
+
+**What is an API?**  
+In contrast to a user interface, which connects a computer to a person, an application programming interface (API) connects computers or pieces of software to each other. It is not intended to be used directly by a person (the end user) other than a computer programmer who is incorporating it into the software. An API is often made up of different parts which act as tools or services that are available to the programmer. A program or a programmer that uses one of these parts is said to call that portion of the API. The calls that make up the API are also known as subroutines, methods, requests, or endpoints. An API specification defines these calls, meaning that it explains how to use or implement them. 
+
+In basic terms, APIs just allow applications to communicate with one another. For the APIs we are concerned right now--web based APIs that return data in response to a request made by us--**they allow us to get data from outside sources by sending an API a request detailing the information we want. Then the API will "respond" with the requested data to us.**
+
+![What is an API](what_is_an_API.png)
+Source: Perry Eising, "What exactly is an API?"
+
+### General Way of Interacting with an API
+
+First, we will use the most common way to access the data through an API without using any packages other may have already built for a particular site. Usually this is the way you would interact with an API.
+
+#### Step 1: Get the API Key
+**In most cases, you will need to get an API key in order to access an API.** For many resources, it involves some paperwork to apply and/or limited free usage, so it is good practice to keep your API keys private as long as it is possible. In this lecture notebook, we will use macroeconomic data from FRED, which is one of the most famous and convenient sources of economic data. For FRED, the process of getting an API key is simple. Request the API key [here](https://fred.stlouisfed.org/docs/api/api_key.html).
+
+```python
+# Because API keys are private, we store our API key in the .env file in this directory, which is not published on GitHub.
+api_key = os.environ['API_KEY']
+```
+
+#### Step 2: Learn to use the API
+Using an API is like ordering food at a restaurant with a menu. To have a delicious meal, we have to know what food the restaurant offers, and any other additional information (for example, how would you like your steak). Similarly, it is very important for us to know what requests an API take through the API documentation. **The API documentation will inform us about how we can use specific instructions to obtain the data that we want, and what the returned data would look like.** Look up the Fred API's documentation [here](https://fred.stlouisfed.org/docs/api/fred/series_observations.html).
+
+<div class="alert alert-info">
+<b> Example: "api.stlouisfed.org/fred/series/observations?series_id=GNPCA&api_key=abcdefghijklmnopqrstuvwxyz123456" <br>  
+  
+Endpoint: "api.stlouisfed.org/fred/series/observations"  <br>
+Parameters: series_id=GNPCA, api_key=abcdefghijklmnopqrstuvwxyz123456
+</div>
+
+Try the following link, replacing REDACTED with your API key to see what the API will return!   
+
+https://api.stlouisfed.org/fred/series/observations?series_id=GNPCA&api_key=REDACTED&file_type=json
+
+#### Step 3: Make the fetch
+Now we are ready to start writing code to fetch the data we want through the API.
+
+```python
+import requests
+from urllib.parse import urlencode
+endpoint = "https://api.stlouisfed.org/fred/series/observations"
+```
+
+Parameters that we would like to include in our query (these can be found in the FRED API documentations!):  
+- `series_id`: The Economic data series we want (e.g. GDP)
+- `observation_start`: The earliest date we want our data to include
+- `observation_end`: The latest date we want our data to include
+- `frequency`: The frequency of observations (e.g. Annually, Quarterly, Monthly)
+- `units`: The units of observations (e.g. plain numbers, percentage change from a year ago, etc.)
+- `api_key`: The API key
+- `file_type`: The file data that will returned from FRED (e.g. json, xml)
+
+```python
+def fetch(series_id, unit="lin"):
+    # specifies parameters
+    params = {"series_id": series_id, 
+              "observation_start": "1958-01-01", 
+              "observation_end": "2023-10-01",
+              "frequency": "q", # quarterly
+              "units": unit,
+              "api_key": api_key, 
+              "file_type": "json"
+             }
+    
+    # forms API request
+    url_params = urlencode(params)
+    url = f"{endpoint}?{url_params}"
+    
+    # fires off the request
+    res = requests.get(url)
+    
+    # checks if the request encounters an error
+    if res.status_code not in range(200, 299):
+        raise Exception(f'Fetch request for "{series_id}" failed (Error: {res.status_code})')
+    
+    # return the content of the response
+    return res.json()
+```
+
+Let's try downloading the real GDP data from Fred now.
+
+```python
+res_json_GDP = fetch("GDPC1")
+
+# process the response
+gdp = pd.DataFrame(res_json_GDP["observations"])[["date", "value"]]
+gdp.rename(columns={"value": "GDP"}, inplace=True)
+gdp['date'] = pd.to_datetime(gdp['date'], format='%Y-%m-%d')
+gdp['GDP'] = pd.to_numeric(gdp['GDP'])
+gdp
+```
+
+```python
+plt.plot(gdp['date'], gdp['GDP'])
+```
+
+**Congratulations! We have just made our first request to Fred API and obtain some useful data.**
+
+Now let's try download more macroeconomic indicators.
+
+```python
+# this function allows us to fetch and process the data together
+def fetch_and_process(series_id, unit="lin"):
+    res_json = fetch(series_id, unit)
+    return pd.DataFrame(res_json["observations"])[["date", "value"]].rename(columns={"date":"DATE", "value": f"{series_id}_{unit}"})
+```
+
+```python
+gdp = fetch_and_process("GDPC1")
+gdp_growth = fetch_and_process("GDPC1", "pc1")
+inflation = fetch_and_process("CPIAUCSL", "pc1")
+unemployment = fetch_and_process("UNRATE")
+ffr = fetch_and_process("DFF")
+nrou = fetch_and_process("NROU")
+core_inflation = fetch_and_process("CPILFESL", "pc1")
+potential_gdp = fetch_and_process("GDPPOT")
+
+gdp_growth
+```
+
+### Site-Specific Prebuilt Packages
+
+Now we will switch gears to use some prebuilt packages to access FRED API. Notice that the prebuilt packages are not necessarily available for every API. But here we will use the "FredAPI" package developed by Mortada Mehyar. Documentation [here](https://github.com/mortada/fredapi).
+
+```python
+# may need to install the package and its dependencies
+!pip install fredapi
+from fredapi import Fred
+fred = Fred(api_key=api_key)
+GDP_fredapi = pd.DataFrame(fred.get_series('GDP'))
+GDP_fredapi
+```
+
+You will get more practice with FREDAPI package in the lab!
+
+## Macroeconomic Indicators and Data
+
+**Now we're off to use the data we have just got!**
+
+```python
+# merge all macroeconomic data we have got!
+macroeconomics = gdp.merge(gdp_growth)\
+                    .merge(inflation)\
+                    .merge(unemployment)\
+                    .merge(ffr)\
+                    .merge(core_inflation)\
+                    .merge(nrou)\
+                    .merge(potential_gdp)\
+
+
+macroeconomics = macroeconomics.set_index("DATE").apply(pd.to_numeric).reset_index("DATE")
+
+potential_gdp = potential_gdp[potential_gdp["DATE"] <= max(macroeconomics["DATE"])]
+```
+
+```python
+macroeconomics.head()
+```
+
+---
+
+### Macroeconomics Indicators and their Time Series
+In this section, we will see how the value of each macroeconomic indicator varied from 1958 to present.
+
+```python
+series_names = {"GDPC1_lin": "GDP", 
+               "GDPC1_pc1": "GDP Growth", 
+               "CPIAUCSL_pc1": "Inflation", 
+               "UNRATE_lin": "Unemployment Rate", 
+               "DFF_lin": "Fed Funds Rate", 
+               "CPILFESL_pc1": "Core Inflation Rate", 
+               "NROU_lin": "Noncyclical Rate of Unemployment" # aka NAIRU, Natural Rate of Unemployment (Long-term)
+              }
+
+# generate a time series plot for "series"
+def plot_time_series(data, series, title="1958 to present", figsize=(14, 8)):
+    
+    plt.figure(figsize=figsize)
+    
+    plt.plot(data["DATE"], data[series])
+    
+    # plot a horizontal line at zero if the variable is in percent
+    if ("pc1" in series):
+        plt.axhline(y=0, color='black', linestyle='-.')
+    
+    plt.xticks(data.index[np.arange(0, data.shape[0], 16)], rotation=45)
+    plt.grid(visible=True)
+    
+    plt.xlabel("DATE")
+    plt.ylabel(series)
+    plt.title(f"{series_names[series]}: {title}", fontsize=16)
+```
+
+#### GDP
+
+```python
+plot_time_series(macroeconomics, "GDPC1_lin")
+```
+
+#### GDP Growth
+
+```python
+plot_time_series(macroeconomics, "GDPC1_pc1")
+```
+
+#### Inflation Rate
+
+```python
+plot_time_series(macroeconomics, "CPIAUCSL_pc1")
+```
+
+#### Core Inflation Rate
+
+```python
+plot_time_series(macroeconomics, "CPILFESL_pc1")
+```
+
+#### Unemployment Rate
+
+```python
+plot_time_series(macroeconomics, "UNRATE_lin")
+```
+
+#### Fed Funds Rate
+
+```python
+plot_time_series(macroeconomics, "DFF_lin")
+```
+
+#### Noncyclical Rate of Unemployment
+
+```python
+plot_time_series(macroeconomics, "NROU_lin")
+```
+
+What interesting pattern do you notice?
+
+## Making an empirical Phillips curve
+
+The above plots are interesting, but they can be found on the FRED website. Let's take the FRED data and do some data science with it.
+
+```python
+plt.scatter(macroeconomics['UNRATE_lin'], macroeconomics['CPILFESL_pc1'])
+plt.title('Empirical Phillips Curve')
+plt.xlabel('Unemployment Rate')
+plt.ylabel('Inflation');
+```
+
+We can see a somewhat negative relationship, but it's not as strong as the relationship we saw during lecture, which used pre-WWI data. In the lab for this week, you'll use the FRED API to dive deeper into the relationship between the unemployment rate and inflation and see how it has changed over time.
+
+```python
+plt.scatter(macroeconomics['UNRATE_lin'], macroeconomics['GDPC1_lin'])
+plt.title('Okun\'s Law With Emprirical Data')
+plt.xlabel('Unemployment Rate')
+plt.ylabel('Output (GDP)');
+```
+
+```python
+plt.scatter(macroeconomics['DFF_lin'], macroeconomics['GDPC1_lin'])
+plt.title('Empirical IS Curve')
+plt.xlabel('Real Interest Rate')
+plt.ylabel('Output (GDP)');
+```
+

data/F24Lec_MD/lec09/lecNB-prisoners-dilemma.md

@@ -0,0 +1,88 @@
+---
+title: "lecNB-prisoners-dilemma"
+type: lecture-notebook
+week: 9
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec09/lecNB-prisoners-dilemma.ipynb"
+---
+
+<table style="width: 100%;" id="nb-header">
+    <tr style="background-color: transparent;"><td>
+        <img src="https://data-88e.github.io/assets/images/blue_text.png" width="250px" style="margin-left: 0;" />
+    </td><td>
+        <p style="text-align: right; font-size: 10pt;"><strong>Economic Models</strong>, EdX<br>
+            Dr. Eric Van Dusen <br>
+            Chris Pyles <br>
+        Akhil Venkatesh <br>
+</table>
+
+```python
+from players import *
+```
+
+# Lecture Notebook: Iterated Prisoner's Dilemma
+
+## Iterated Prisoner's Dilemma
+
+```python
+def human_play(self, opponent):
+    if len(opponent.history):
+        print(f"Your opponents last move: {'D' if opponent.history.item(-1) else 'C'}")
+    move = input("Your move: (d/c) ").strip().upper()
+    assert move in ["D", "C"], f"invalid move: {move}"
+    return move == "D"
+
+Human = create_player_class("Human", human_play)
+```
+
+```python
+n_rounds = input("How many rounds would you like to play? [10] ")
+if n_rounds:
+    n_rounds = int(n_rounds)
+else:
+    n_rounds = 10
+
+show_opponent = input("Show opponent? (y/n) [n] ").strip().upper() == "Y"
+
+human = Human()
+opponent = np.random.choice(make_array(
+    Alternator(), Backstabber(), Bully(), Desperate(), FoolMeOnce(), Forgiver(), 
+    Grudger(), OnceBitten()
+))
+
+if show_opponent:
+    print(f"Your opponent is: {opponent}")
+
+winner = run_match(human, opponent, n_rounds)
+if winner == Human():
+    winner = "you!"
+print(f"The winner is: {winner}")
+```
+
+### Using `create_player_class`
+
+**From the project:**
+
+In this project, we will be creating some custom Python classes to represent different playing strategies. We'll be using the `create_player_class` function (provided) to create these classes for us. Here are a few important things to know about the classes:
+
+Consider a player class instance `player = Player()`. 
+* `player.play()` is a method that represents a single move. It returns `True` if the player **defects** and `False` if they cooperate.
+* `player.history` is an array of the previous moves of the player instance. `player.history.item(-1)`, for example, is the most recent move (the last element of the array).
+
+Don't worry about the other methods that are defined for players; these are there for the code below to work but you don't need to concern yourself with them. Here's how the `create_player_class` function works:
+
+1. Define a function, `f`, that takes two arguments: `self` and `opponent` (more about these later), and returns `True` if the player defects and `False` otherwise.
+2. Call `create_player_class` with two arguments: a string for the class name, e.g. `"Player"`, and the play method `f`.
+
+Let's illustrate this by creating `Defector`, a player that always defects. The `defector_play` function below always returns `True`, since the player always defects. We then create `Defector` using `create_player_class`.
+
+**Example:** Defector
+
+```python
+def defector_play(self, opponent):
+    return True
+
+Defector = create_player_class("Defector", defector_play)
+```
+
+
+