my-markdown-library 0.1.0

data/F24Lec_MD/lec02/ScannerData_Beer.md

@@ -0,0 +1,171 @@
+---
+title: "ScannerData_Beer"
+type: lecture-notebook
+week: 2
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec02/ScannerData_Beer.ipynb"
+---
+
+```python
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+import plotly.express as px
+%matplotlib inline
+```
+
+```python
+try:
+  import gdown
+except:
+  !pip install gdown
+  import gdown
+```
+
+```python
+#This file is too big and appears to crash the Datahub - could potentially work on a local machine with more RAM
+#!  gdown 1z0XeoE6PYPOUqzzKLagvmiFohdOF3CLJ
+# n_wber.csv = 140M
+```
+
+This is a smaller version of the dataset with half of the data ( approx 2m rows) 
+
+The following command pulls the dataset over from Google Drive
+
+```python
+#https://drive.google.com/file/d/1qZpdbEpvvWQJlZKpzu8rwd53JrrufzdW/view?usp=sharing
+!  gdown 1qZpdbEpvvWQJlZKpzu8rwd53JrrufzdW
+# s_wber.csv = 70M
+```
+
+# A Quick Look on the Inverse Demand Curves for Beer
+
+Start off by pulling in open source data on beer sales from [The University of Chicago Booth School of Business](https://www.chicagobooth.edu/research/kilts/datasets/dominicks).
+
+```python
+df = pd.read_csv('s_wber.csv')
+df
+```
+
+Can you tell what each instance (row) and the features (columns) represent?
+
+```python
+df.describe()
+```
+
+One way that I like to approach a dataset where I don't know the specific details of it is to first summarize the whole table, then delve deeper into each feature. Here's a quick example of my approach:
+
+```python
+len(df['UPC'].unique()) # Number of Unique beers?
+```
+
+```python
+len(df['STORE'].unique()) # Number of unique stores
+```
+
+```python
+len(df['WEEK'].unique()) # Number of unique weeks
+```
+
+```python
+df['PRICE'].mean() # Average beer price
+```
+
+```python
+df['PRICE'].max() # most expensive beer
+```
+
+```python
+df['PRICE'].min() # FREE BEER?!
+```
+
+```python
+df['QTY'].mean() # avg beers bought ?
+```
+
+```python
+df['MOVE'].mean() # avg beers bought ?
+```
+
+Can you tell what this plot is showing below? I'm not sure if I can!
+
+```python
+df[['MOVE','PRICE']].plot();
+```
+
+```python
+df['QUANTITY'] = df['MOVE'] # Interestingly enough, quantity is not denoted as QTY, by 'MOVE'.
+```
+
+By now, we should be aware that we're looking at a dataset of beer sales, where the respective price and quantities for each transaction is represented. Let's filter out all the free beer - although it would be very nice to keep that!
+
+```python
+g = df[['QUANTITY','PRICE']]
+g = g[g['PRICE']>0]
+g
+```
+
+To create the demand curve itself, we need to remember that we're looking for quantity demanded at each given price. Hence, we group by price and 'ask' for the sum at the given price. Then, flip that around (just trick), and do the cumulative sum (since a demand curve is cumulative), and then flip it around one last time (since we're looking at the inverse demand curve).
+
+```python
+demand = np.flip(np.cumsum(np.flip(g.groupby('PRICE')['QUANTITY'].sum())))
+demand = demand.to_frame().reset_index()
+demand
+```
+
+Now, let's use Plotly Express' [Scatterplot function](https://plotly.com/python-api-reference/generated/plotly.express.scatter.html) to visualize the inverse demand curve for all beers!
+
+```python
+px.scatter(demand,x='QUANTITY', y='PRICE', trendline='ols', title='Inverse Demand Curve for all Beers')
+```
+
+This is pretty cool! Hover over the line to see the Ordinary Least Squares approximation of the inverse demand curve. What does it tell you?
+
+Now, do you expect the price elasticity of demand to differ for different prices? Yes! Usually, a more expensive good (luxury beers?) tend to have a higher PED. Could we visualize this?
+
+```python
+demand.describe()
+```
+
+Let's plot multiple demand curves for different price segments of beer. We could start with all beers above the mean. Let's call them expensive.
+
+```python
+demand['EXPENSIVE'] = demand['PRICE']>demand['PRICE'].mean()
+demand.head(5)
+```
+
+Before you plot, think about how this curve might differ from the previous one. Then, check if your intuition was right!
+
+```python
+px.scatter(demand,x='QUANTITY', y='PRICE', trendline='ols', color='EXPENSIVE',title='Inverse Demand Curve for Expensive and Cheaper Beer')
+```
+
+Did your economic intuition help you? Now, what's happening with the really expensive beer?
+
+```python
+demand['REALLY EXPENSIVE'] = demand['PRICE']>10.5 #75th Percentile of Price
+demand.head(5)
+```
+
+```python
+px.scatter(demand,x='QUANTITY', y='PRICE', trendline='ols', color='REALLY EXPENSIVE',title='Inverse Demand Curve for Really Expensive Beer')
+```
+
+And the really, really expensive beer?
+
+```python
+demand['REALLY, REALLY EXPENSIVE'] = demand['PRICE']>15
+demand.head(5)
+```
+
+```python
+px.scatter(demand,x='QUANTITY', y='PRICE', trendline='ols', color='REALLY, REALLY EXPENSIVE',title='Inverse Demand Curve for Really, Really Expensive Beer is almost Vertical!')
+```
+
+This notebook should have given you the data science skills to plot up simple, but powerful inverse demand curves. It should have also gotten you thinking about how demand curves differ for different price segments for the same goods.
+
+Made by Peter F. Grinde-Hollevik.
+
+```python
+
+```
+

data/F24Lec_MD/lec02/demand-curve-Fa24.md

@@ -0,0 +1,213 @@
+---
+title: "demand-curve-Fa24"
+type: lecture-notebook
+week: 2
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec02/demand-curve-Fa24.ipynb"
+---
+
+# Creating a Demand Curve
+
+```python
+import pandas as pd
+import os
+import json
+import numpy as np
+from datascience import *
+from ipywidgets import interact, interactive, fixed, interact_manual
+import ipywidgets as widgets
+%matplotlib inline
+import matplotlib.pyplot as plt
+import warnings
+warnings.filterwarnings("ignore")
+```
+
+We will create a few demand curves based on the class. Start by filling in the form at https://forms.gle/KhCjC4nwwhtRDjSJ9 or https://tinyurl.com/data-88e-demand!
+
+```python
+sheet_id = "1jzgX74fgWo91Dyv7SbD4AmSFvUN5APc79BaOENpsyv8"
+sheet_name = "Form1"
+url = f"https://docs.google.com/spreadsheets/d/{sheet_id}/gviz/tq?tqx=out:csv&sheet={sheet_name}"
+```
+
+```python
+pd.read_csv(url)
+```
+
+```python
+df_demand=pd.read_csv(url)
+```
+
+```python
+demand_table = Table.from_df(df_demand)
+demand_table = demand_table.drop('Timestamp')
+demand_table
+```
+
+Let's try graphing all our different responses!
+
+```python
+for i in demand_table.labels:
+    demand_table.hist(i);
+```
+
+Let's start by looking at the demand for masks. How many people would buy masks at a given price? Let's assume that a person would be willing to buy the good at a price less than their bid price.
+
+```python
+# This is a column of bid values for masks that you've all inputted. 
+masks = demand_table.select('Masks')
+masks
+```
+
+```python
+# This cell does some python magic. You do not need to worry about what's going on. 
+prices = pd.DataFrame({'price':[0.25, 0.5, 0.75, 1.00, 1.25, 1.5,1.75,2]})
+MasksByPrice = masks.group("Masks")
+mbp = MasksByPrice.to_df()
+mask = (
+    prices
+    .merge(mbp, left_on='price', how='left', right_on='Masks')
+    .fillna(0).drop('Masks', axis=1)
+)
+masks_table = Table.from_df(mask)
+Q_demand = np.flip(np.cumsum(np.flip(masks_table.group("price", sum).column(1))))
+masks_demand = Table().with_columns(
+    'price', prices.price, 
+    'quantity', Q_demand
+)
+masks_demand
+```
+
+```python
+# Let's graph our results
+masks_demand.scatter("quantity", "price")
+plt.xlabel('Quantity')
+plt.ylabel('Price')
+plt.title('Demand for a pack of surgical masks');
+```
+
+Now let's find the slope and intercept of the line of best fit. The cell below defines some functions that you'll learn about in the later portions of Data 8.
+
+```python
+std_units = lambda a: (a - np.mean(a)) / np.std(a)
+corr = lambda x, y: np.mean(std_units(x) * std_units(y))
+slope = lambda x, y: corr(x, y) * np.std(y) / np.std(x)
+intercept = lambda x, y: np.mean(y) - slope(x, y) * np.mean(x)
+```
+
+```python
+slope(masks_demand["quantity"], masks_demand["price"])
+```
+
+```python
+intercept(masks_demand["quantity"], masks_demand["price"])
+```
+
+We can use the same code as above to create demand curves for our other products as well!
+
+```python
+#Gourmet Burrito
+prices_burrito = pd.DataFrame({'price':[2.50, 5, 7.50, 10, 12.5, 15,17.5,20]})
+
+burritos = demand_table.select('Burrito')
+burritosByPrice = burritos.group("Burrito")
+bbp = burritosByPrice.to_df()
+gb = (
+    prices_burrito
+    .merge(bbp, left_on='price', how='left', right_on='Burrito')
+    .fillna(0).drop('Burrito', axis=1)
+)
+
+burritos_table = Table.from_df(gb)
+Q_demand_burrito = np.flip(np.cumsum(np.flip(burritos_table.group("price", sum).column(1))))
+
+gb_demand = Table().with_columns(
+    'price', prices_burrito.price, 
+    'quantity', Q_demand_burrito
+)
+
+burrito_slope = slope(gb_demand["quantity"], gb_demand["price"])
+burrito_intercept = intercept(gb_demand["quantity"], gb_demand["price"])
+print("Slope: " + str(burrito_slope))
+print("Intercept: " +  str(burrito_intercept))
+```
+
+```python
+#Greek Theatre Tickets
+prices_tickets = pd.DataFrame({'price':[25, 50, 75, 100, 125, 150,175,200]})
+
+tickets = demand_table.select('GreekTix')
+ticketsByPrice = tickets.group("GreekTix")
+tbp = ticketsByPrice.to_df()
+gt = (
+    prices_tickets
+    .merge(tbp, left_on='price', how='left', right_on='GreekTix')
+    .fillna(0).drop('GreekTix', axis=1)
+)
+
+tickets_table = Table.from_df(gt)
+Q_demand_tickets = np.flip(np.cumsum(np.flip(tickets_table.group("price", sum).column(1))))
+
+gt_demand = Table().with_columns(
+    'price', prices_tickets.price, 
+    'quantity', Q_demand_tickets
+)
+
+tickets_slope = slope(gt_demand["quantity"], gt_demand["price"])
+tickets_intercept = intercept(gt_demand["quantity"], gt_demand["price"])
+print("Slope: " + str(tickets_slope))
+print("Intercept: " +  str(tickets_intercept))
+```
+
+```python
+#Iphone 14
+prices_iphone = pd.DataFrame({'price':[250, 500, 750, 1000, 1250, 1500,1750,2000, 2250, 2500, 2750, 3000]})
+
+iphones = demand_table.select('iPhone')
+iphonesByPrice = iphones.group("iPhone")
+ibp = iphonesByPrice.to_df()
+iphone14 = (
+    prices_iphone
+    .merge(ibp, left_on='price', how='left', right_on="iPhone")
+    .fillna(0).drop("iPhone", axis=1)
+)
+
+iphones_table = Table.from_df(iphone14)
+Q_demand_iphones = np.flip(np.cumsum(np.flip(iphones_table.group("price", sum).column(1))))
+
+iphone14_demand = Table().with_columns(
+    'price', prices_iphone.price, 
+    'quantity', Q_demand_iphones
+)
+
+iphones_slope = slope(iphone14_demand["quantity"], iphone14_demand["price"])
+iphones_intercept = intercept(iphone14_demand["quantity"], iphone14_demand["price"])
+print("Slope: " + str(iphones_slope))
+print("Intercept: " +  str(iphones_intercept))
+```
+
+Comparing the demand curves for our four products, what similarities or differences do you notice? In particular, think about what the slopes of the curves might reveal to us about consumer preferences.
+
+```python
+masks_demand.scatter("quantity", "price")
+plt.xlabel('Quantity')
+plt.ylabel('Price')
+plt.title('Demand for a pack of surgical masks');
+
+gb_demand.scatter("quantity", "price")
+plt.xlabel('Quantity')
+plt.ylabel('Price')
+plt.title('Demand for Gourmet Burritos');
+
+gt_demand.scatter("quantity", "price")
+plt.xlabel('Quantity')
+plt.ylabel('Price')
+plt.title('Demand for Greek Theatre Tickets');
+
+iphone14_demand.scatter("quantity", "price")
+plt.xlabel('Quantity')
+plt.ylabel('Price')
+plt.title('Demand for iPhone14');
+```
+
+
+

data/F24Lec_MD/lec03/3.0-CubicCostCurve.md

@@ -0,0 +1,239 @@
+---
+title: "3.0-CubicCostCurve"
+type: lecture-notebook
+week: 3
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec03/3.0-CubicCostCurve.ipynb"
+---
+
+<table style="width: 100%;">
+    <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>, Fall 2024<br>
+            Dr. Eric Van Dusen <br>
+        Shashank Dalmia, Ergun Acikoz</p></td></tr>
+</table>
+
+```python
+try: 
+    from csaps import csaps
+except:
+    !pip install csaps
+    from csaps import csaps
+```
+
+```python
+import sympy as sp
+import matplotlib.pyplot as plt
+import numpy as np
+from ipywidgets import interact, widgets
+from datascience import *
+%matplotlib inline
+from csaps import csaps
+```
+
+# Cubic Cost Functions
+
+The cubic cost function is one that is commonly used to model a cost function within a firm.  
+
+This notebook uses parameters from a recent article  with some parameters for the cubic cost function, in a journal on Teaching Applied Economics
+
+>"Tractable Cubic Cost Functions for Teaching Microeconomics"
+>June 21,2023; Applied Economics Teaching Resources (AETR);
+>Scott M. Swinton and Hanzhe Zhang
+
+https://www.aaea.org/UserFiles/file/AETR_2021_003RProofFinal.pdf
+
+- d=3600
+- c=177
+- b=-15
+- a=0.5
+
+Let's use these as starting values but then use widgets to allow us to play with the parameters!
+
+```python
+# Define the variables and parameters
+q = sp.symbols('q')  # Quantity of goods produced
+
+# Define the cubic cost function
+a = widgets.FloatSlider(value=0.5, min=0, max=1, step=0.01, description='a')
+b = widgets.FloatSlider(value=-15, min=-30, max=30, step=1, description='b')
+c = widgets.FloatSlider(value=177.0, min=0, max=250, step=5, description='c')
+d = widgets.FloatSlider(value=3600, min=0, max=10000, step=100, description='d')
+
+def plot_cubic_cost_function(a, b, c, d):
+    cost_function = a * q**3 + b * q**2 + c * q + d
+
+    cost_function_np = sp.lambdify(q, cost_function, 'numpy')
+
+    quantity_values = np.linspace(0, 25, 100)
+    cost_values = cost_function_np(quantity_values)
+
+    plt.figure(figsize=(8, 6))
+    plt.plot(quantity_values, cost_values, label='Cost Function', color='blue')
+    plt.xlabel('Quantity Produced')
+    plt.ylabel('Cost')
+    plt.title('Cubic Cost Function')
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+
+interact(plot_cubic_cost_function, a=a, b=b, c=c, d=d)
+```
+
+##  Great - we can make a cost function that displays the model characteristics that we want 
+**Now let's go ahead and make an table from the Function**
+
+We can use Sympy and get a Numpy version of the equation as well
+
+```python
+q = sp.symbols('q') 
+cost_function = a * q**3 + b * q**2 + c * q + d
+
+
+# You dont know how to do this but we can also convert the SymPy expression to a numpy function
+cost_function_np = sp.lambdify(q, cost_function, 'numpy')
+```
+
+Le'ts make the model  by specifying those cubic parameters that we did in the last section
+
+```python
+d=2000
+c=177
+b=-15
+a=0.5
+```
+
+```python
+quantity_values = np.linspace(0, 30, 16)  # Levels of Q from 0 to 20
+quantity_values
+```
+
+```python
+total_costs = cost_function_np(quantity_values)
+```
+
+```python
+
+cost_table = Table().with_columns(
+    'Quantity-Q', quantity_values,
+    'Fixed Costs-FC', d,
+    'Total Costs-TC', total_costs
+)
+cost_table
+```
+
+```python
+total_variable_cost = cost_table.column("Total Costs-TC") - cost_table.column('Fixed Costs-FC')
+total_variable_cost
+```
+
+```python
+cost_table = cost_table.with_column("Total Variable Cost-TVC", total_variable_cost)
+cost_table
+```
+
+```python
+average_total_cost = cost_table.column("Total Costs-TC") / cost_table.column("Quantity-Q")
+average_total_cost[0] = 0
+average_total_cost
+```
+
+```python
+cost_table = cost_table.with_column("Average Total Cost-ATC", average_total_cost)
+cost_table
+```
+
+```python
+average_variable_cost = cost_table.column("Total Variable Cost-TVC") / cost_table.column("Quantity-Q")
+average_variable_cost[0] = 0
+
+cost_table = cost_table.with_column("Average Variable Cost-AVC", average_variable_cost)
+cost_table
+```
+
+```python
+average_fixed_cost = cost_table.column("Fixed Costs-FC") / cost_table.column("Quantity-Q")
+average_fixed_cost[0] = 0
+
+cost_table = cost_table.with_column("Average Fixed Cost-AFC", average_fixed_cost)
+cost_table
+```
+
+## And Finally Marginal Costs
+
+```python
+marginal_cost = np.diff(total_costs)
+marginal_cost = np.append(make_array(0), marginal_cost)
+marginal_cost
+```
+
+```python
+cost_table = cost_table.with_column("Marginal Cost", marginal_cost)
+cost_table
+```
+
+```python
+
+```
+
+```python
+plt.plot(cost_table.column("Quantity-Q"), cost_table.column("Fixed Costs-FC"), marker='o')
+plt.plot(cost_table.column("Quantity-Q"), cost_table.column("Total Variable Cost-TVC"), marker='o')
+plt.plot(cost_table.column("Quantity-Q"), cost_table.column("Total Costs-TC"), marker='o')
+plt.xlabel('Quantity')
+plt.ylabel('Cost')
+plt.title('TFC, TVC and TC')
+plt.legend(make_array("Total Fixed Cost","Total Variable Cost","Total Cost"))
+
+plt.show()
+```
+
+```python
+plt.plot(cost_table.column("Quantity-Q")[1:], cost_table.column("Average Fixed Cost-AFC")[1:], marker='o')
+plt.plot(cost_table.column("Quantity-Q")[1:], cost_table.column("Average Variable Cost-AVC")[1:], marker='o')
+plt.plot(cost_table.column("Quantity-Q")[1:], cost_table.column("Average Total Cost-ATC")[1:], marker='o')
+plt.xlabel('Quantity')
+plt.ylabel('Cost')
+plt.title('AFC, AVC and ATC')
+plt.legend(make_array("Average Fixed Cost","Average Variable Cost","Average Total Cost"))
+
+plt.show()
+```
+
+```python
+# You do not need to understand what the code below is doing. 
+output = cost_table.column("Quantity-Q")[1:]
+mc = cost_table.column("Marginal Cost")[1:]
+avc = cost_table.column("Average Variable Cost-AVC")[1:]
+atc = cost_table.column("Average Total Cost-ATC")[1:]
+
+sp_mc = csaps(output, mc, smooth=0.85)
+sp_avc = csaps(output, avc, smooth=0.85)
+sp_atc = csaps(output, atc, smooth=0.85)
+
+output_s = np.linspace(output.min(), output.max(), 150)
+mc_s = sp_mc(output_s)
+avc_s = sp_avc(output_s)
+atc_s = sp_atc(output_s)
+
+plt.plot(output, mc, marker = 'o', color = 'tab:blue')
+plt.plot(output_s, mc_s, alpha=0.7, lw = 2, label='_nolegend_', color = 'tab:blue')
+plt.plot(output, avc, marker = 'o', color = 'tab:green')
+plt.plot(output_s, avc_s, alpha=0.7, lw = 2, label='_nolegend_', color = 'tab:green')
+plt.plot(output, atc, marker = 'o', color = 'tab:orange')
+plt.plot(output_s, atc_s, alpha=0.7, lw = 2, label='_nolegend_', color = 'tab:orange')
+plt.hlines(y=min(avc), xmin = 11.5, xmax = 13, lw=3, color='r', zorder = 10)
+plt.hlines(y=min(atc), xmin = 16, xmax = 18, lw=3, color='r', zorder = 10)
+plt.xlabel('Quantity')
+plt.ylabel('Cost')
+plt.title('MC, AVC and ATC')
+plt.legend(make_array("Marginal Cost","Average Variable Cost","Average Total Cost"))
+
+plt.show()
+```
+
+```python
+
+```
+