Problem 1: Fun with APIs, continued (30 points)¶
Remember problem 3 from the previous pset? I'd like you to go back and use the Caselaw Access Project API again, only, this time, I'd like you to plot line charts of the following two time series, on the same chart:
The total number of the uses of the words "pork," "pig," "pigs," "hog," or "hogs" in the Iowa state courts within the CAP dataset, and
The total number of the uses of the words "corn," "sweetcorn," "maize," or "ethanol" in the same courts.
In other words, I'd like you to produce a chart with two lines: one is the number of uses of the pork words, the other is the number of uses of the corn words. On the y axis is number of uses of words; on the x axis is year.
Hint: Check out the last example chart for the 'plottyprint' library, which I have released. You may feel free to use this library, or to borrow some of the code from it.
Answer¶
This is another use of the ngrams endpoint, but this time, we have to combine a bunch of data from different words and then plot it. Let's start by getting the data and combining it. In order to do that, we'll use a bunch of helper functions.
import requests
def extract_counts(api_result, word): # the api results are messy, so I'd like to clean them up.
# going to label them by word just to make sure that everything is nice and clear when we move on.
return {"year": api_result["year"], "count": api_result["count"][0], "word": word}
def get_counts_by_year(word):
endpoint = f'https://api.case.law/v1/ngrams/?q={word}&jurisdiction=iowa'
result = requests.get(endpoint).json()['results'][word]['iowa']
return [extract_counts(x, word) for x in result]
pork_words = ["pork", "pig", "pigs", "hog", "hogs"]
corn_words = ["corn", "maize", "ethanol"]
# I'm leaving off "sweetcorn" here because I happen to know, from having gotten
# no results when I ran the query before, that it doesn't produce anything.
pork_results = []
corn_results = []
for word in pork_words:
pork_results.append(get_counts_by_year(word))
for word in corn_words:
corn_results.append(get_counts_by_year(word))
Ok, now we have two lists of lists dicts, where each top-level list has one inner list for each word in its category, and then, in the inner lists, one dict for every year. Observe:
print(corn_results)
We need to combine them, so that we have associated each year with the total number of words in its category. The easiest way to do that is probably to make one big dict for each group, with the key being the year and the value being the count. We can create that as follows:
def combine_inner_lists(biglist):
out = {}
for innerlist in biglist:
for entry in innerlist:
year = entry["year"]
count = entry["count"] # this is totally unnecessary and verbose, but makes it a little clearer
current_count = out.get(year, 0) # returns zero if there isn't anything for the year.
out[year] = current_count + count
return out
porkcounts = combine_inner_lists(pork_results)
corncounts = combine_inner_lists(corn_results)
Eyeballing the list that I printed out above, it looks like 2015 had all three corn words, 5 uses of the word "corn," 1 use of the word "maize," and 12 uses of the word "ethanol," so we can look at that result of our combination to get a quick check on whether the code was correct.
print(corncounts["2015"])
Looks good to me! Now we have to graph them. We have effectively two choices: use my "plottyprint" library or use seaborn. I'll show you both.
import plottyprint
For plottyprint, we're going to need a list of datetime objects and a corresponding list of each of the counts for that year. This means a little bit more data manipulation, but that's ok.
from datetime import datetime
all_years = sorted(list(set(corncounts.keys()).union(set(porkcounts.keys()))))
print(all_years)
# good examples on how to convert strings to dates: https://chrisalbon.com/python/basics/strings_to_datetime/
years_as_dt = [datetime.strptime(x, '%Y') for x in all_years]
print(years_as_dt[0:10])
# now we will get the appropriate count from each category for each year, or 0 if nothing.
porknums = []
cornnums = []
for year in all_years:
porknums.append(porkcounts.get(year, 0))
cornnums.append(corncounts.get(year, 0))
# now our data is in the right format, we can plot it!
plottyprint.timeseries(years_as_dt, [porknums, cornnums], ["pork", "corn"])
I'm not totally sure why it printed twice---the way that matplotlib (the underlying plotting library) plays with jupyter notebooks isn't exactly transparent. But that doesn't really matter. The job is done!
It's also kind of interesting. It doesn't look like there are any particular trends with respect to pork and corn--- I would have expected that there would be an increase over time in pork relative to corn, but apparently not! There's also something really weird going on around the great depression and the period of the two world wars...
Ok, now let's do seaborn. That'll look better anyway, since my plottyprint library is designed for greyscale for print, and with a dense chart like this greyscale isn't the best idea. It'll be easiest to use seaborn if we start with a Pandas DataFrame, so let's do that.
import seaborn as sns
import pandas as pd
df = pd.DataFrame({"date": years_as_dt, "pork": porknums, "corn": cornnums})
df = df.set_index(df.date)
df.head()
Because this is actually a little difficult to get right in seaborn (one reason I wrote my own library for this), we'll build up to it. First we'll make just a pair of single-line plots.
sns.lineplot(data=df, x="date", y="pork")
sns.lineplot(data=df, x="date", y="corn")
Ok, now the annoying thing. To get a multiple-line lineplot, you have to change your data from "wide" to "long" format using the pandas "melt" function. This is a dumb design decision on seaborn's part, but, so it goes. Here's an explanation. Let's look at what long format looks like, first.
df_long = pd.melt(df, ['date'])
df_long.head()
print(len(df))
print(len(df_long))
We see that we have doubled the length of our dataset, because each year now has two rows: one row for the pork value, and one row for the corn value. With that in hand, we can make seaborn do what we want it to:
sns.lineplot(data=df_long, x="date", y="value", hue="variable")
And we're done!
Problem 2: The Inexpert Witness (70 points)¶
Harriet Hawkeye, the owner of a sports fan apparel store in Iowa City, is being prosecuted by the State of Iowa for sales tax fraud. The key piece of evidence is that the sales figures that Harriet reported to the state did not reliably increase on home football game days. There were 5 home games that year (note to students: I don't actually know or care how many football games there are, don't fight the hypo), and Harriet's sales didn't increase beyond her average range on any of them.
The prosecution calls Dr. Carl Cyclone, a professor of Economics at Iowa State, to testify, and Carl testifies as follows:
Based on his research, the average sales of sports fan apparel in Iowa increased substantially in almost every store in the state on home game days. Of 1000 store-homegame pairs in the state in the last year other than at Harriet's store (i.e., 1000 is the product of the number of stores and the number of home games per store, so 3 stores that each had 3 home games in their town would be 9 store-homegame pairs), 800 of them had a substantial increase in sales over the store in question's daily average.
Therefore, there's a 80% change that sales on any given day will increase substantially if there's a home game.
The probability of Harriet not experiencing an increase in sales for all five days is thus $0.2^5 = 0.00032$, which is so vanishingly small that, in his expert opinion, Harriet must have actually had more sales than she reported on at least one home game day.
You represent Harriet.
Subquestion 1 (20 points): Describe in words what problematic mistake or assumption Carl makes.
Subquestion 2 (20 points): What kind of evidence could you look for to undermine Carl's argument?
Answer to subquestions 1 and 2¶
There are a few things that could potentially be wrong here. The key is to think about how Carl is making assumptions about the world and then translate it to math. Probably the low-hanging fruit answer here is that Carl is assuming that each day of sales is independent of one another. But that might not be true. There might be some way that harriet's sales on early days affect her sales on later days (for example, if she uses past sales to project future sales in order to determine how many hours she should be open).
Or, for an even simpler kind of assumption Carl makes, that doesn't even particularly rely on talk about independence (though it could be translated into those terms), he assumes that there isn't anything about Harriet's store that makes it particularly less likely to increase on home game days. For example, suppose her store is really far away from the stadium, and suppose that distance to stadium is strongly associated with increase in sales on home game days? Carl doesn't look at that factor, but as a lawyer, it's something you should think about. This is one of those pitfalls of observational data that we've been talking about (and which we'll learn to manage when we look at linear regression): there's always something that might screw up out observed association between cause (here, having a home game) and effect (here, increase in sales).
Again, there are any number of things that you could say here, I'll accept lots of different answers, but the key is to be able to move back and forth between math and world.
For subquestion 2, then, it'll depend on what you have to say. If you talk about independence, you'd want to develop some kind of testimony from Harriet about what affects her sales, as well as what affects her decisions about things such as hours, prices, etc. If you talk about location or anything like that, you'd want to have your own expert dig into Carl's data and figure out if his results change, for example, if we limit it to stores a certain distance from the stadium. And so on, and so forth. Just think like a litigator.
Subquestion 3 (20 points): Write a simulation to illustrate the effects of correcting the problem that you identified in subquestion 1. I know that this subquestion is a little ambigious and open-ended, so here's all I can really say as a hint without giving away the answer: there is at least one, and possible several, parameter(s) that you could plausibly vary, which would change the ultimate probability calculation that Carl made. Your simulation should vary that parameter/those parameters and see what outcomes come out.
Subquestion 4 (10 points): Use an appropriate data visualization to illustrate the simulation you wrote in the previous subquestion.
Answer to subquestions 3 and 4.¶
Again, there's a lot of ways you could do this. I just want you to practice translating assumptions about the world/about math into code. Here, as a demonstration, I'll bang out a quick simulation of the location example. Yours doesn't need to be this complicated.
We're also going to do this in aggressively object-oriented fashion: I'm going to create a shopper class, a store class, etc. etc. Again, this is VERY heavy on the overkill, you don't need to go this hard.
We will also just look at the outcome in the form of a visualization, rather than wasting time trying to interpret our results in numbers.
import random
class Store(object):
def __init__(self, distance = None):
if distance:
self.distance = distance # distance from stadium. we probably won't need to fix this, but just in case
else:
self.distance = random.randint(2, 9) # larger distances are further
self.sales = 0
self.game_day_sales = 0
self.non_game_sales = 0
def sell(self, game_day): # register a sale.
self.sales += 1
if game_day:
self.game_day_sales += 1
else:
self.non_game_sales += 1
def report(self):
return {"total_sales": self.sales,
"game_day_sales": self.game_day_sales,
"non_game_sales": self.non_game_sales,
"distance": self.distance}
class Shopper(object):
def __init__(self, energy = None):
if energy:
self.energy = energy # extent to which shopper is willing to shop further from current location
else:
self.energy = random.randint(10, 20)
def shop(self, list_of_stores, game_day = False):
if game_day: # give every store a random score weighted to prefer closer stores
best_store = {"store": list_of_stores[0], "score": 0}
for current_store in list_of_stores:
current_score = random.randint(0, self.energy - current_store.distance)
if current_score > best_store["score"]:
best_store = {"store": current_store, "score": current_score}
best_store["store"].sell(game_day)
else:
store = random.choice(list_of_stores)
store.sell(game_day)
class Simulation(object):
def __init__(self, days = 100, stores = 100, shoppers = 1000, games = 20, fixed_energy = None):
self.stores = [Store() for x in range(stores)]
self.games = games
self.non_games = days - games
if fixed_energy:
self.shoppers = [Shopper(fixed_energy) for x in range(shoppers)]
else:
self.shoppers = [Shopper() for x in range(shoppers)]
def round(self, game_day=False):
for shopper in self.shoppers:
shopper.shop(self.stores, game_day)
def run(self):
for x in range(self.games):
self.round(game_day = True)
for x in range(self.non_games):
self.round()
return pd.DataFrame([store.report() for store in self.stores])
simple_simulation = Simulation()
simple_output = simple_simulation.run()
simple_output.head()
sns.boxplot(x=simple_output["distance"], y=simple_output["game_day_sales"])
Unsurprisingly, because of the way we wrote the simulation, we see that the game day sales crater once you get too far from the stadium. But writing the simulation also allows us to think about further assumptions that we're making, and which could be tested by evidence. For example: even if we do have evidence that Harriet's store is unusually far from the stadium, do we have evidence about how sensitive people are to stadium distance in Harriet's town? We could tweak that in the code above by adding a fixed_energy argument to our Simulation initializer.
We could also change the code to permit us to tweak any number of the parameters of our model in order to see how the outcomes change. We could also write code to parse our dataset or change what is reported out to more directly represent Carl Cyclone's claim about the unlikelihood of a store having low sales on each of five game days, for example, by having each store report daily sales rather than just total sales. I don't particularly feel like taking the time to write the code to do that, this sample answer is already very long, but you should be able to see how we might do that within our Store class. Again, this is just one of the many, many, ways you might answer this problem.