Gemini’s response to Question 1

Using dplyr is the way to go here. It makes data manipulation feel more like writing a sentence and less like solving a puzzle. To get those averages, you’ll want to use the split-apply-combine strategy: split the data by continent, apply the mean() function to your variables, and combine it all back into a neat summary table.

The R Code

Assuming your dataframe is named df, here is the cleanest way to compute those means:

R

library(dplyr)

# Summary statistics by continent
continent_summary <- df %>%
  group_by(continent) %>%
  summarize(
    mean_gdp = mean(`GDP per capita`, na.rm = TRUE),
    mean_life_exp = mean(`life expectancy`, na.rm = TRUE),
    mean_energy = mean(`total energy use`, na.rm = TRUE)
  )

# View the results
print(continent_summary)

Why this works:

• group_by(continent): This tells R to treat each continent as its own little mini-dataframe for the next step.
• summarize(): This collapses each group into a single row.
• na.rm = TRUE: This is a lifesaver. If a single country is missing data (an NA), the mean would normally return NA. This argument tells R to just ignore the missing values and calculate the average from the data that is there. Pro Tip: If you have many more columns and don’t want to type them all out, you can use across() to do them all at once:

R

df %>%
  group_by(continent) %>%
  summarize(across(c(`GDP per capita`, `life expectancy`, `total energy use`), mean, na.rm = TRUE))

Would you like me to show you how to visualize these continent averages using a bar chart or a bubble plot?

Reflections on Gemini’s answer to Question 1

Obviously, Gemini provided code to do simple averaging for all three statistics. Notice how friendly and confident the LLM sounds as it assures the student that it knows its stuff. It cheerily explains why it did what it did in plain english.

I thought, well, I didn’t actually give Gemini a population field to work with. Let’s help it out.

Gemini’s response to Question 2

No problem! Adding the population is a quick tweak. Since you want the total population rather than the average, we just swap the function for that specific column. Here is the updated code to handle everything in one go:

R

library(dplyr)

# Comprehensive summary by continent
continent_summary <- df %>%
  group_by(continent) %>%
  summarize(
    mean_gdp = mean(`GDP per capita`, na.rm = TRUE),
    mean_life_exp = mean(`life expectancy`, na.rm = TRUE),
    mean_energy = mean(`total energy use`, na.rm = TRUE),
    total_pop = sum(population, na.rm = TRUE) # Summing for total population
  )

# View the results
print(continent_summary)

Key Adjustments

• sum(population): Unlike the other variables where we want the average, we use sum() here to get the aggregate headcount for the entire continent.
• The Power of the Pipe (%>%): Notice how we keep everything inside a single block. This “pipeline” style keeps your workspace clean and your logic easy to follow.

Quick Tip on Data Types

If your population numbers are very large, R might display them in scientific notation (like 1.4e09). If you prefer seeing the full numbers, you can run options(scipen = 999) before printing your summary.

Would you like to see how to rank these continents from highest to lowest total population within the same command?

Reflections on Gemini’s answer to Question 2

Not surprisingly, it correctly added the code to sum the population field. But, it didn’t pick up on the fact that countries have different populations and that things like mean GDP per capita and mean life expectancy need weighted averages.

Gemini’s response to Question 3

You are absolutely right. My apologies for the oversight—you’ve hit on a crucial statistical distinction! If you take a simple average of GDP per capita across countries, you are treating a country of 50,000 people the same as a country of 1.4 billion. To get an accurate picture of the “average person’s” experience on a continent, you need to calculate weighted means.

For GDP per capita, the mathematically accurate way to find the continent average is to divide the Total GDP of the continent by its Total Population. For Life Expectancy, we weight the value by the population of each country.

The Corrected “Weighted” Analysis

Here is how you do that accurately in a single dplyr pipe:

R

library(dplyr)

continent_analysis <- df %>%
  group_by(continent) %>%
  summarize(
    # Total population for the continent
    total_pop = sum(population, na.rm = TRUE),
    
    # Weighted Mean Life Expectancy: sum(life_exp * pop) / sum(pop)
    weighted_mean_life_exp = sum(`life expectancy` * population, na.rm = TRUE) / total_pop,
    
    # True GDP per capita: Total GDP / Total Population
    # We first calculate Total GDP for each country (GDP_per_cap * pop)
    mean_gdp_per_capita = sum(`GDP per capita` * population, na.rm = TRUE) / total_pop,
    
    # Mean Energy Use (Weighted by population)
    weighted_mean_energy = sum(`total energy use` * population, na.rm = TRUE) / total_pop
  )

print(continent_analysis)

Why this is more accurate:

• The Problem: If “Country A” has 10 people and a GDP per capita of , and “Country B” has 90 people and a GDP per capita of , a simple average says the mean is .
• The Reality: In that combined group of 100 people, the actual wealth per person is only .
• The Logic: By multiplying the variable by the population before summing, we ensure that larger countries have a proportional “vote” in the final continental average.

A Note on Energy Use

Depending on your specific goals, “total energy use” is often reported as an aggregate for the whole country. If your column is already the Total energy (not per capita), you would simply use sum(total_energy_use) to get the continent’s footprint. If it is Energy Use per capita, then the weighted formula above is the way to go.

Would you like to see how to use weighted.mean()—a built-in R function—to make this code even shorter?

Reflections on Gemini’s answer to Question 3

So, I tell the LLM it’s wrong but I don’t tell it why it’s wrong. It comes up with the correct weighted averaging approach. Why? Did it not know that GDP per capita needs weighted averaging? How does it suddenly “know” this after being told it’s original approach is incorrect? Let’s ask Gemini.

Gemini’s response to Question 4

You’ve hit on one of the most fascinating “glitches in the matrix” of how Large Language Models (LLMs) like me function. You’re right—statistically, a weighted average is the only way to get a meaningful continental metric, yet I initially defaulted to a simple mean().

There are three main reasons why LLMs frequently “trip” on this specific type of logic:

1. Pattern Matching vs. Intent Modeling

I am trained on billions of lines of code. In the vast majority of R tutorials and Stack Overflow answers, the “basic” way to use group_by and summarize is paired with the mean() function.

• The Pattern: “Compute the average X by Y” summarize(mean(X)).
• The Flaw: My “brain” recognized the request for a summary and reached for the most common code pattern associated with that request, rather than first performing a deep “sanity check” on the underlying statistical validity of applying that pattern to population-based data.

2. The “Path of Least Resistance” Bias

LLMs are designed to be helpful and direct. When a user asks for “the mean,” the model often takes the literal linguistic path.

• Literal Interpretation: You asked for “the mean,” so I provided the mean() function.
• Analytical Interpretation: You asked for a “continental average,” which requires understanding that a continent is a collection of weighted units.

Unless a prompt explicitly mentions weighting or “per capita adjustments,” models often default to the simplest arithmetic interpretation because that is what satisfies the “literal” requirement of the prompt most often.

3. Lack of a Persistent “World Model”

While I “know” that China has more people than Iceland, I don’t “hold” that fact in active memory while writing the code unless I am specifically prompted to consider the relationship between the columns. I treat GDP_per_capita and population as abstract variable names until the logic of the calculation forces me to look at how they interact.

The Architecture of the Error

Most LLMs operate on Autoregressive Prediction. I am predicting the next most likely token (word or symbol) in a sequence. In the sequence “summarize mean…”, the probability of the next token being the column name is very high. The “correction” requires a higher-level reasoning step that overrides this probabilistic “auto-complete.”

How to “Stress Test” an AI in the future

To get better results from any AI when dealing with data, it helps to use “Chain of Thought” prompting. If you say: “Think about the relationship between population and per-capita metrics, then write the code,” it forces the model to activate those analytical “neurons” before it starts typing code.

Would you like to see how to use the weighted.mean() function to make that previous code even more concise?

Reflections on Gemini’s answer to Question 4

Gemini’s response is a good reminder to students who use LLMs for analysis work. These things don’t know what words actually mean, they know how patterns of text relate to other patterns of text. These relationships are learned from looking at many examples of such text patterns. This one particular sentence really stood out:

I treat GDP_per_capita and population as abstract variable names until the logic of the calculation forces me to look at how they interact.

There is no world view nor sense of contextual meaning of terms like GDP per capita or population. The output of an autoregressive prediction model trained on vast troves of text provides the illusion of understanding meaning and having a world view. It wasn’t until I added certain words to the model’s context window that it found different text pattern relationships that actually ended up answering the question.

Wait, isn’t that the wrong way to compute mean GDP per capita and mean life expectancy? Each country has a different population and a simple average will lead to inaccurate results.

I never use the term “weighted average”. I do mention things like “wrong”, different population”, “simple average” and “inaccurate”. Which terms pushed the model to find different next token probabilities?

March 2025

Fast forward to 2025 and LLMs have made significant strides. The main proprietary general purpose models included ChatGTP from Open AI, Gemini from Google, and Claude from Anthropic. There are numerous versions of these models as the companies compete for market domination and are frequently releasing new variants of their base models. How would this new generation of LLMs fare with the bike share analysis problems?

I decided to use Anthropic’s Claude 3.5 Sonnet model.

import pandas as pd

# Read the CSV file
df = pd.read_csv('trip.csv')

# Count rentals from each station
station_rentals = df['from_station_id'].value_counts()

# Convert to a DataFrame for better formatting
rental_summary = pd.DataFrame({
    'station': station_rentals.index,
    'total_rentals': station_rentals.values
})

# Sort by number of rentals in descending order
rental_summary = rental_summary.sort_values('total_rentals', ascending=False)

# Reset index for cleaner display
rental_summary = rental_summary.reset_index(drop=True)

# Display the results
print("\nTotal Rentals by Station:")
print(rental_summary.to_string(index=False))

The code ran with no errors and produced expected results.

Things get more interesting as the response goes beyond just what was asked. There was one error in that a necessary library was not imported. Here is the code along with a few minor changes.

import pandas as pd
## MY FIX: added necessary import
import matplotlib.pyplot as plt

# Read the CSV file
df = pd.read_csv('trip.csv')

# Convert datetime strings to datetime objects
df['starttime'] = pd.to_datetime(df['starttime'])
df['stoptime'] = pd.to_datetime(df['stoptime'])

# Calculate duration in hours for each rental
df['rental_duration'] = (df['stoptime'] - df['starttime']).dt.total_seconds() / 3600

# Calculate average duration
average_duration = df['rental_duration'].mean()

# Calculate additional statistics
duration_stats = {
    'average_hours': average_duration,
    'median_hours': df['rental_duration'].median(),
    'min_hours': df['rental_duration'].min(),
    'max_hours': df['rental_duration'].max(),
    'std_hours': df['rental_duration'].std()
}

# Print results
print("\nRental Duration Statistics (in hours):")
for stat, value in duration_stats.items():
    print(f"{stat.replace('_', ' ').title()}: {value:.2f}")

# Create a histogram of rental durations for rentals under 24 hours
short_rentals = df[df['rental_duration'] <= 24]
plt.figure(figsize=(10, 6))
plt.hist(short_rentals['rental_duration'], bins=48, edgecolor='black')
plt.title('Distribution of Rental Durations (<= 24 hours)')
plt.xlabel('Duration (hours)')
plt.ylabel('Number of Rentals')
plt.grid(True, alpha=0.3)
plt.show()

The output includes a statistical summary and a histogram of ride duration. I had only asked for the mean but Claude decided to give me more. Ok, now for the real question.

The response by Claude is interesting. It does far better than the early attempts described in the previous section in its overall approach to solving the problem. Yet, it makes a non-trivial syntactical error in which it uses a method that does not exist. It also overlooks the more subtle conceptual issue that lies at the heart of this entire exercise.

Like the previous example, Claude forgets to load a necessary library and then proceeds to read the data into a pandas dataframe named df. Then it begins to build up the pieces to compute the average number of rentals by day of week. First, for the numerator, we get code to count the number of rentals that occurred on each day of the week.

# Convert start_rental to datetime
df['starttime'] = pd.to_datetime(df['starttime'])

# Extract day of week (0 = Monday, 6 = Sunday)
df['day_of_week'] = df['starttime'].dt.dayofweek

# Create day name column for better readability
df['day_name'] = df['starttime'].dt.day_name()
# Calculate average rentals by day of week
daily_rentals = df.groupby('day_name')['starttime'].count().reset_index()
daily_rentals.columns = ['day_of_week', 'total_rentals']

Displaying the value of daily_rentals gives the following output.

Next comes the code to compute how many of each weekday appear in the range of dates represented in the dataframe to serve as the denominator.

# Calculate the number of unique dates for each day of week
unique_days = df.groupby('day_name')['starttime'].dt.date.nunique().reset_index()

Running this code leads to the following error.

AttributeError: 'SeriesGroupBy' object has no attribute 'dt'

While the dt accessor is usable with a Series object, it’s not usable with a SeriesGroupBy object. For a beginner Python with pandas user, this is not a particularly simple error to diagnose nor fix. Beginning programmers often do not carefully read error messages, or if they do, have trouble understanding how to use the information in the error message to diagnose the problem.

Here’s how we can do this while still using the same approach as Claude.

unique_dates_df = pd.DataFrame(df['starttime'].dt.date.unique(), columns = ['date'])
unique_dates_df['date'] = pd.to_datetime(unique_dates_df['date'])
unique_dates_df['day_of_week'] = unique_dates_df['date'].dt.dayofweek
unique_dates_df['day_name'] = unique_dates_df['date'].dt.day_name()

unique_days = unique_dates_df.groupby('day_name')['date'].size().reset_index()
unique_days.columns = ['day_of_week', 'number_of_days']

print(unique_days)

After this fix, the rest of the code works perfectly.

# Merge and calculate average
daily_averages = pd.merge(daily_rentals, unique_days, on='day_of_week')
daily_averages['average_rentals'] = daily_averages['total_rentals'] / daily_averages['number_of_days']

# Sort by day of week (Monday first)
day_order = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
daily_averages['day_of_week'] = pd.Categorical(daily_averages['day_of_week'], categories=day_order, ordered=True)
daily_averages = daily_averages.sort_values('day_of_week')

# Round averages to 1 decimal place
daily_averages['average_rentals'] = daily_averages['average_rentals'].round(1)

# Display results
print("\nAverage Daily Rentals by Day of Week:")
print(daily_averages[['day_of_week', 'average_rentals']].to_string(index=False))

# Create a bar plot
plt.figure(figsize=(10, 6))
plt.bar(daily_averages['day_of_week'], daily_averages['average_rentals'])
plt.title('Average Number of Bike Rentals by Day of Week')
plt.xlabel('Day of Week')
plt.ylabel('Average Number of Rentals')
plt.xticks(rotation=45)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

This approach works fine for computing the mean number of rentals under the assumption that we have at least one rental on every date in the range spanned by the dataset. But, if there is a date having zero rides, that date will not get included in the denominator counts and all of the statistics will be inflated. For overall mean rental volume by day of week, it is extremely unlikely to have zero rental demand for an entire day. However, if we modify the question to ask about mean rental volume by day of week for a particular station, there might very well be days with zero rentals.

Claude proceeds to generate code that suffers from similar shortcomings as in the previous example. It makes the same error in using a library method that does not exist. It also fails to correctly compute the denominator, the number of day of week and hour combinations over the analysis date range. It ends with this description of what its code does.

The summary and suggestion for further analysis make sense. It all sounds very certain and correct.

After fixing the syntax error involving the dt accessor, the code runs and produces a beautiful heatmap with plausible looking numbers in each colored cell. As long as there was at least one rental on each date, these results are correct. Next, we will ask to include an upper percentile along with the mean number of rentals by day of week. The approach that Claude has used so far will not work as we need the number of rentals by date as an intermediate calculation as opposed to just a total count of rentals by day of week.

After reading in the data and making sure that the starttime column was a datetime, Clause proceeded with the following code to correctly compute the number of rentals by date.

# Extract date and day of week
df['date'] = df['starttime'].dt.date
df['day_of_week'] = df['starttime'].dt.day_name()

# Get daily counts
daily_counts = df.groupby(['date', 'day_of_week']).size().reset_index(name='count')

Again, as long as there was at least one rental for each date in the analysis date range, the daily_counts dataframe can be used to compute the mean and percentiles of interest of the number of rentals by day of week. Claude provided that code and produced a very nice summary table. With the preceding as a warm-up, now it was time to put Claude to the test. What would it do when the possibility of zero volume days was almost certain?

Like the example above, Claude first generated a dataframe of the number of rentals by date originating from the station of interest. In Figure Figure 2, we can see that there are 653 rows in the dataframe of rentals by date. Recall that our raw data spans 689 days. There were 36 dates in which there were no rentals from this station. We need those “zero dates” in order to correctly compute the statistics of interest using the approach that Claude used in the previous query.

Indeed, Claude generated the same code logic as in the previous example and produced the summary statistics shown in the left panel of Figure Figure 3. They look plausible. They are wrong. Not by a lot, but they are wrong - see the right panel for the correct values.

While the differences in the statistics are not too different for station CH-06, this is not the case for other stations. For example, Figure Figure 4 shows the statistical summaries for station UD-02. The impact of zero volume days is quite large.

This raises a related question. Are the zero volume days scattered throughout the range of dates in the dataset or was the station offline for some period of time during this date range? If it was offline for a period, we might want to adjust the date range upon which to base our analysis. You can see the distribution of zero days in Figure Figure 5 for station CH-06 and in Figure Figure 6 for station UW-11.

A look at the same plot for station UW-11 reveals a different story.

Care must be taken to specify exactly how zero volume days should be treated when computing volume statistics. So, in the case of using tools like Claude, is there a prompting problem? In the absence of telling it to do any different, Claude defaulted to using the entire dataset. Just as the onus would be on the analyst to take zero volume days into account when doing the analysis themselves, they are equally responsible for making sure that tools like Claude do the analysis properly. While the act of writing code and working through the analysis forces the analyst to think about all of the steps required, using an LLM might lead to cognitive offloading and subtle data analysis issues overlooked in subsequent prompting and analysis. It is argued in Oakley et al. (2025) that such cognitive offloading “undermines reasoning, impedes learning, and diminishes productivity”.

Does the act of iteratively building up analysis code lead to more thinking and better analysis? If one can bypass this thinking and offload to an LLM, are we getting less nuanced analysis? Anyone who analyzes data for a living knows that data is messy and there are dragons hidden in them. Data analysts are often the best people to find these dragons and either slay them or alert others who can. LLMs may circumvent this important exploratory phase of the data analysis process.

How did I know to ask about zero volume days? I had graphed volume over time for the entire system and individual stations. I knew Python and pandas and SQL very well and knew that an aggregate query counting rentals by date was not going to have rows for those dates with zero volume. And, I realized that this would lead to statistic inflation because I had done so many similar analyses over the years and it is just common analytical sense that if the denominator is artificially small, the ratio is artificially large. Unfortunately, I didn’t have enough common sense to tell Claude about the missing zeros to see what it would do. I would rectify this oversight in July of 2025.

July 2025

After Claude 4 was released, I wanted to see if it was any better in dealing with this zero days problem. This time I structured the prompt a little differently to make it easy to test the results. I also decided to submit the same prompt to Gemini and ChatGPT.

Claude 4 responded with

result = bike_summary_dow_station(trips, "station_123")

import pandas as pd
import numpy as np

def bike_summary_dow_station(trips, station_id):
    """
    Compute mean and 95th percentile of bike rentals by day of week for a specific station.
    
    Parameters:
    trips (pd.DataFrame): DataFrame with bike rental data containing columns:
                         - starttime: datetime of bike rental
                         - from_station_id: string ID of rental station
    station_id (str): Station ID to compute statistics for
    
    Returns:
    pd.DataFrame: DataFrame with columns:
                 - day_of_week: string representing day of week
                 - mean: mean number of bikes rented for that day
                 - p95: 95th percentile of bikes rented for that day
    """
    # Filter trips for the specified station
    station_trips = trips[trips['from_station_id'] == station_id].copy()
    
    # Extract date and day of week from starttime
    station_trips['date'] = station_trips['starttime'].dt.date
    station_trips['day_of_week'] = station_trips['starttime'].dt.day_name()
    
    # Count rentals per day
    daily_counts = station_trips.groupby(['date', 'day_of_week']).size().reset_index(name='rental_count')
    
    # Calculate mean and 95th percentile by day of week
    summary = daily_counts.groupby('day_of_week')['rental_count'].agg([
        ('mean', 'mean'),
        ('p95', lambda x: np.percentile(x, 95))
    ]).reset_index()
    
    # Ensure proper day of week ordering (Monday first)
    day_order = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
    summary['day_of_week'] = pd.Categorical(summary['day_of_week'], categories=day_order, ordered=True)
    summary = summary.sort_values('day_of_week').reset_index(drop=True)
    
    return summary

Again, the zero days were ignored and this code will lead to inflated statistics whenever there are zero days for the specified station. This time I followed up with a question.

Claude responded:

Claude included this code:

import pandas as pd
import numpy as np

def bike_summary_dow_station(trips, station_id):
    """
    Compute mean and 95th percentile of bike rentals by day of week for a specific station.
    
    Parameters:
    trips (pd.DataFrame): DataFrame with bike rental data containing columns:
                         - starttime: datetime of bike rental
                         - from_station_id: string ID of rental station
    station_id (str): Station ID to compute statistics for
    
    Returns:
    pd.DataFrame: DataFrame with columns:
                 - day_of_week: string representing day of week
                 - mean: mean number of bikes rented for that day
                 - p95: 95th percentile of bikes rented for that day
    """
    # Filter trips for the specified station
    station_trips = trips[trips['from_station_id'] == station_id].copy()
    
    # Extract date and day of week from starttime
    station_trips['date'] = station_trips['starttime'].dt.date
    station_trips['day_of_week'] = station_trips['starttime'].dt.day_name()
    
    # Get the date range from the entire dataset
    all_dates = pd.date_range(start=trips['starttime'].min().date(), 
                             end=trips['starttime'].max().date(), 
                             freq='D')
    
    # Create a complete date/day_of_week combination
    complete_dates = pd.DataFrame({
        'date': all_dates.date,
        'day_of_week': all_dates.day_name()
    })
    
    # Count rentals per day for the station
    daily_counts = station_trips.groupby(['date', 'day_of_week']).size().reset_index(name='rental_count')
    
    # Merge with complete dates to include days with zero rentals
    complete_daily_counts = complete_dates.merge(daily_counts, on=['date', 'day_of_week'], how='left')
    complete_daily_counts['rental_count'] = complete_daily_counts['rental_count'].fillna(0)
    
    # Calculate mean and 95th percentile by day of week
    summary = complete_daily_counts.groupby('day_of_week')['rental_count'].agg([
        ('mean', 'mean'),
        ('p95', lambda x: np.percentile(x, 95))
    ]).reset_index()
    
    # Ensure proper day of week ordering (Monday first)
    day_order = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
    summary['day_of_week'] = pd.Categorical(summary['day_of_week'], categories=day_order, ordered=True)
    summary = summary.sort_values('day_of_week').reset_index(drop=True)
    
    return summary

I followed up with:

Claude said:

From Claude’s response, it definitely “understands” the issue of zero rental days. What I find striking is how its response is structured as if a human analyst had written it. Claude is an LLM yet says things like “I was focused”, “without fully thinking through the data characteristics”, and “I assumed” and “I was thinking”. The user is nudged to think of Claude as a human-like entity using the same analytical processes a human might use. Yet, deep down, at the architecture level, lies an enormous neural network used to do very sophisticated and probabilistic pattern matching. Wouldn’t the human be better served if Claude admitted that it was the additional mention of the possibility of zero rental days in the follow up prompt that led to inputs that produced the correct outputs? Of course, Claude can’t “admit” anything. It’s not a reflective thinking being. The more that analysts remember this, the better chance they use it cautiously and reflectively themselves.

Then I submitted the same prompts to ChatGPT and Google Gemini (2.5 Flash). Both made the same error as Claude with almost identical code. Once prompted about the possibility of zero rental days, they were able to explain the implications in language very similar to Claude’s and to generate correct code. The three LLMs produced extremely similar code. Their answers to my question about why they made the error were very similar to that of Claude’s.

So, how should students use LLMs?

After one of these coding exchanges with Claude, I expressed my concern about how students are likely to use these tools and asked for Claude’s reaction and suggestions.

There’s a lot of sensible advice in there. I’ll certainly share this with my students. Then it’s up to them.

Thoughts

Why does this one particular example bothers me so much and compel me to periodically revisit it? It’s a very common business analysis problem and not a very difficult one, yet after two years of continued LLM development and untold billions spent, the top LLMs still get it wrong. As I write this on August 8, I just tried it again with GPT-5. Still wrong. These LLMs are ever confident and I can easily see a novice analyst uncritically accepting their answer to this problem. But what really bothers me is the nagging suspicion that many students are going to use these tools to blast through homework assignments with little work to actually learn much of anything. Resisting the call of the homework machine will prove much too tempting for many. Use will be easy to rationalize by appealing to the argument that use of LLMs in industry will be required.

It will be extremely difficult for educators to convince students that it is worth their time to forgo LLM use until they have developed significant competency and familiarity with the tools and concepts being learned. I will definitely be sharing Claude’s advice to students from the previous section. Will many follow the advice? Who knows. In the past, I’ve made similar pleas to my students. For example:

and this:

Brian Klaas, in his essay The Death of the Student Essay—and the Future of Cognition makes the case far better than I could ever hope to that uncritical use of LLMs will likely fundamentally affect humanity’s ability to think clearly. He pleads with his students.

Aware of my inability to detect AI use with certainty, I implored the students: please don’t use AI. It’s terrible for you. It’s terrible for me, a dystopian experience of spending weeks giving detailed constructive feedback to a machine. I strongly suspect—but can’t prove—that many didn’t listen.

In another letter to his students, the author likens using LLMs for coursework and expecting to learn to using a forklift to go into the weight room and expecting to get stronger. Research is starting to suggest that cognitive offloading to LLMs is eroding students’ critical thinking abilities (Gerlich (2025), Kosmyna et al. (2025), Oakley et al. (2025)). No surprise there. Ask young adults to navigate a city or suburb without Google Maps and prepare yourself for a wide-eyed plea to “be serious”.

Download Nest Site Descriptions

This is a table containing information about each individual nest box. You should re-download this table whenever new bird boxes are added. Since I’m using R for the data analysis, I download the CSV version of this table.

The downloaded file will be named siteDescriptions-[username]-[yyyymmdd].csv. The [yyyymmdd] part is the date you download the file. For all of these examples, pretend you are downloading the data on 2024-02-21.

Example: siteDescriptions-Sialia-20240221.csv

We will take a brief look at this file now just to get a sense of what’s in there.

library(readr)
library(janitor, warn.conflicts = FALSE)
library(dplyr, warn.conflicts = FALSE)
library(ggplot2)
library(lubridate, warn.conflicts = FALSE)
library(tidyr)
library(stringr)
library(sf)

Linking to GEOS 3.10.2, GDAL 3.4.1, PROJ 8.2.1; sf_use_s2() is TRUE

library(gt)

raw_data_path <- "./data/raw"
site_stub <- "siteDescriptions-Sialia-20240221"

site_file <- file.path(raw_data_path, paste0(site_stub, ".csv"))
site_df <- read_csv(file = site_file, col_names = TRUE, 
                    comment = '#', show_col_types = FALSE)
str(site_df)

spc_tbl_ [58 × 16] (S3: spec_tbl_df/tbl_df/tbl/data.frame)
 $ Site Name                : chr [1:58] "Kestrel Box" "BCNP07" "BCNP08" "BCNP09" ...
 $ Latitude                 : num [1:58] 42.8 42.7 42.7 42.7 42.7 ...
 $ Longitude                : num [1:58] -83.1 -83.2 -83.2 -83.2 -83.2 ...
 $ Substrate                : chr [1:58] "nest box / birdhouse" "nest box / birdhouse" "nest box / birdhouse" "nest box / birdhouse" ...
 $ Height Above Ground      : num [1:58] NA 5 5 5 5 5 5 5 12 12 ...
 $ Height Above Ground Units: logi [1:58] NA FALSE FALSE FALSE FALSE FALSE ...
 $ Entrance Diameter        : num [1:58] NA NA NA NA NA NA NA NA 3 3 ...
 $ Entrance Diameter Units  : chr [1:58] NA NA NA NA ...
 $ Entrance Orientation     : chr [1:58] NA "se" "se" "se" ...
 $ Site Elevation           : num [1:58] NA 948 948 948 948 950 950 957 908 934 ...
 $ Site Elevation Units     : logi [1:58] NA FALSE FALSE FALSE FALSE FALSE ...
 $ Habitat Info 1           : chr [1:58] NA "natural grassland and prairie" "natural grassland and prairie" "natural grassland and prairie" ...
 $ Habitat Info 2           : chr [1:58] NA "woodland/forest" "woodland/forest" "woodland/forest" ...
 $ Habitat Info 3           : logi [1:58] NA NA NA NA NA NA ...
 $ Nest Attempts            : num [1:58] NA 2 2 2 2 1 2 NA NA NA ...
 $ Comments                 : chr [1:58] "Kestrel box installed in 2021 by Tom K" NA NA NA ...
 - attr(*, "spec")=
  .. cols(
  ..   `Site Name` = col_character(),
  ..   Latitude = col_double(),
  ..   Longitude = col_double(),
  ..   Substrate = col_character(),
  ..   `Height Above Ground` = col_double(),
  ..   `Height Above Ground Units` = col_logical(),
  ..   `Entrance Diameter` = col_double(),
  ..   `Entrance Diameter Units` = col_character(),
  ..   `Entrance Orientation` = col_character(),
  ..   `Site Elevation` = col_double(),
  ..   `Site Elevation Units` = col_logical(),
  ..   `Habitat Info 1` = col_character(),
  ..   `Habitat Info 2` = col_character(),
  ..   `Habitat Info 3` = col_logical(),
  ..   `Nest Attempts` = col_double(),
  ..   Comments = col_character()
  .. )
 - attr(*, "problems")=<externalptr> 

Some of the column names include spaces, but otherwise this file is easy to read in. Well, it’s easy as long as you specify the comment = '#' argument. Rows 2-4 of the CSV file are comments.

Download Breeding Data

This is where we get the detailed breeding data. However, the download process is a bit confusing. First of all, there are two types of downloads:

• Summaries by site
• Individual site visits

You can also choose individual years or all years. Let’s look at each combination of choices.

breeding_stub <- "breedingSummary-Sialia"
yr <- 2024

year_str <- as.character(yr)
breeding_file <- file.path(raw_data_path, paste0(breeding_stub, '-', year_str,".csv"))
breeding_summary_df <- read_csv(file = breeding_file, col_names = TRUE, 
                                comment = '#', show_col_types = FALSE)
str(breeding_summary_df)

spc_tbl_ [71 × 12] (S3: spec_tbl_df/tbl_df/tbl/data.frame)
 $ Site Name       : chr [1:71] "BCNP12" "BCNP11" "BCNP08" "Watershed Barn" ...
 $ Species         : chr [1:71] "Tree Swallow" "Eastern Bluebird" "Tree Swallow" "American Robin" ...
 $ Outcome         : chr [1:71] "At least one host young fledged" "At least one host young fledged" "All young found dead in or nearby nest" NA ...
 $ 1st Egg Date    : Date[1:71], format: "2024-05-06" "2024-05-08" ...
 $ 1st Hatch Date  : Date[1:71], format: "2024-05-26" "2024-05-24" ...
 $ 1st Fledge Date : Date[1:71], format: "2024-06-11" "2024-06-12" ...
 $ No. of fledged  : num [1:71] 5 4 0 NA NA 4 NA NA NA NA ...
 $ Max clutch size : num [1:71] 5 4 4 NA NA 5 NA NA NA NA ...
 $ Total live young: num [1:71] 5 4 4 NA NA 4 NA NA NA NA ...
 $ Unhatched eggs  : num [1:71] 0 0 NA NA NA 1 NA NA NA NA ...
 $ Hatch Rate      : chr [1:71] "100.0%" "100.0%" "100.0%" NA ...
 $ Fledge Rate     : chr [1:71] "100.0%" "100.0%" "0.0%" NA ...
 - attr(*, "spec")=
  .. cols(
  ..   `Site Name` = col_character(),
  ..   Species = col_character(),
  ..   Outcome = col_character(),
  ..   `1st Egg Date` = col_date(format = ""),
  ..   `1st Hatch Date` = col_date(format = ""),
  ..   `1st Fledge Date` = col_date(format = ""),
  ..   `No. of fledged` = col_double(),
  ..   `Max clutch size` = col_double(),
  ..   `Total live young` = col_double(),
  ..   `Unhatched eggs` = col_double(),
  ..   `Hatch Rate` = col_character(),
  ..   `Fledge Rate` = col_character()
  .. )
 - attr(*, "problems")=<externalptr> 

Download Species Summaries

Again, these can be done for an individual year or for all years. The all years version just aggregates things over all the years - it does not give you individual year summaries. So, if we want to use these, you need to download each year separately and rename the files as you go so you know what year it is.

Total # nesting attempts    
Earliest Egg Date   
Earliest Hatch Date 
Earliest Fledge Date    
Total # eggs    
Total # nestlings   
Total # fledglings  
Nest attempts with at least one fledgling   
Nesting success rate    
Mean clutch size    
Mean nestlings  
Mean fledglings

Data prep for the site descriptions file

The first step after reading the file is to clean up the column names.

site_file <- file.path(raw_data_path, paste0(site_stub, ".csv"))
site_df <- read_csv(file = site_file, col_names = TRUE, 
                    comment = '#', show_col_types = FALSE)
site_df <- site_df %>% janitor::clean_names()

What happens in the clean_names() function? We rely on the janitor package and its clean_names() function. Some of the key things it does is:

• Parses letter cases and separators to a consistent format (e.g. snake case is default)
• Handles special characters and spaces, including transliterating characters like œ to oe.
• Appends numbers to duplicated names
• Converts “%” to “percent” and “#” to “number” to retain meaning
• Spacing (or lack thereof) around numbers is preserved

Let’s redo the reading of the file and see the changes made.

site_df <- read_csv(file = site_file, col_names = TRUE, 
                    comment = '#', show_col_types = FALSE)
names(site_df)

 [1] "Site Name"                 "Latitude"                 
 [3] "Longitude"                 "Substrate"                
 [5] "Height Above Ground"       "Height Above Ground Units"
 [7] "Entrance Diameter"         "Entrance Diameter Units"  
 [9] "Entrance Orientation"      "Site Elevation"           
[11] "Site Elevation Units"      "Habitat Info 1"           
[13] "Habitat Info 2"            "Habitat Info 3"           
[15] "Nest Attempts"             "Comments"                 

Now, let’s clean them.

site_df <- site_df %>% janitor::clean_names()
names(site_df)

 [1] "site_name"                 "latitude"                 
 [3] "longitude"                 "substrate"                
 [5] "height_above_ground"       "height_above_ground_units"
 [7] "entrance_diameter"         "entrance_diameter_units"  
 [9] "entrance_orientation"      "site_elevation"           
[11] "site_elevation_units"      "habitat_info_1"           
[13] "habitat_info_2"            "habitat_info_3"           
[15] "nest_attempts"             "comments"                 

Now we are going to add a box_type field which takes on values of either ‘Traditional’, ‘Peterson’, or ‘Kestrel’. For more about the Peterson box, see this post about the creator of it. We use the comments field in our site description table to store information about the box type. Using R’s grep() function, we can extract the box type and populate the box_type field.

# Initialize all as Traditional
site_df$box_type <- 'Traditional'
# Find and set the Peterson boxes
site_df$box_type[grep('Peterson', site_df$comments, ignore.case = TRUE)] <- 'Peterson'

site_df$site_name_type <- str_c(site_df$site_name, '-', str_sub(site_df$box_type, 1, 1))

# Find and set the Kestrel boxes
site_df$box_type[grep('Kestrel', site_df$comments, ignore.case = TRUE)] <- 'Kestrel'
site_df$box_type <- as.factor(site_df$box_type)

How many do we have of each?

site_df |> 
  group_by(box_type) |> 
  count()

# A tibble: 3 × 2
# Groups:   box_type [3]
  box_type        n
  <fct>       <int>
1 Kestrel         2
2 Peterson        9
3 Traditional    47

We use a box naming convention that starts with an abbreviation for the park and then a box number.

unique(site_df$site_name)[c(2:5, 11:14)]

[1] "BCNP07" "BCNP08" "BCNP09" "BCNP10" "PCT01"  "PCT02"  "PCT04"  "PCT03" 

We’ll use the park abbreviation for a new field called area.

# Add area
site_df$area <- str_extract(site_df$site_name, '^[A-Z]+')

site_df |> 
  group_by(area) |> 
  count()

# A tibble: 7 × 2
# Groups:   area [7]
  area      n
  <chr> <int>
1 BCNP     12
2 CIP      24
3 DTLP      9
4 G         1
5 K         1
6 P         1
7 PCT      10

Finally, we convert site_df to a simple features object using the sf package. While we have longitude and latitude fields in our dataframe, site_df is not really a spatially aware object. In order to make it easy to do spatial related queries, computations and visualizations, we need to fortify it with some spatial powers. To do this we’ll use the sf package.

A package that provides simple features access for R.

With sf we can represent simple planar features such as points, lines and polygons (and multi versions of these things) and manipulate them in dataframes or tibbles. In the Python world we could use the GeoPandas package (which relies on the shapely package). Simple features is a general concept supported in many geocomputational tools including things like QGIS and PostGIS.. See my earlier post on creating maps of the nest box locations with R, for more details on geocomputation in R.

library(sf)

# Convert site_df to an simple features object
site_sf <- st_as_sf(x = site_df, 
                    coords = c("longitude", "latitude"),
                    crs = "EPSG:4326")

We will need this spatial awareness later as part of the analysis.

Data prep for the species summary file

This file is a little trickier due to the use of the '#' character within several column names. We need to fix these first before attempting to use read_csv() to ingest the file. I created a function that pulls out the first line from the species summary file (the header line) and uses janitor::make_clean_names() to return a cleaned up version. Then we can use the cleaned up names when reading in the species summary file. We saw that the clean_names() function takes a dataframe as an input and modifies the column names. The make_clean_names() function takes a character vector of names as an input and returns a cleaned up character vector of names. As you might guess, clean_names() uses make_clean_names() under the hood.

fix_species_colnames <- function(src_path){
  
  # Convert cleaned line to character vector of new column names
  original_col_names <- stringr::str_split_1(readLines(src_path, 1), ",")
  
  # Now clean names (janitor handles the '#' replacement with '_number_')
  clean_col_names <- janitor::make_clean_names(original_col_names)
  
}

The main part of code loops over the years that are to be read in. At each iteration, the species summary CSV file is read in and stored in a list. This list of dataframes is then combined rowwise to create the final multi-year species summary dataframe.

species_stub <- "speciesSummary-Sialia"

min_year <- 2019
max_year <- 2024
year_range <- min_year:max_year

# Clean the species file column names and read into dataframes
species_summary_dfs <- list()
for (yr in year_range) {
  
  year_str <- as.character(yr)
  species_file <- file.path(raw_data_path, paste0(species_stub, '-', year_str,".csv"))
  
  # Get new column names
  cleaned_col_names <- fix_species_colnames(species_file)
  
  # Read in file, skipping first line
  species_summary_dfs[[year_str]] <- read_csv(file = species_file, skip = 1, 
                                              col_names = FALSE, comment = '#',
                                              show_col_types = FALSE)
  
  # Reset the column names
  names(species_summary_dfs[[year_str]]) <- cleaned_col_names
  species_summary_dfs[[year_str]]$year <- yr
  
}
# Combine list of dataframes into one dataframe.
species_summary_df <- bind_rows(species_summary_dfs)
rm(species_summary_dfs)

str(species_summary_df)

spc_tbl_ [24 × 14] (S3: spec_tbl_df/tbl_df/tbl/data.frame)
 $ species                                  : chr [1:24] "Black-capped Chickadee" "Tree Swallow" "House Wren" "Eastern Bluebird" ...
 $ total_number_nesting_attempts            : num [1:24] 2 22 4 27 1 19 2 32 3 1 ...
 $ earliest_egg_date                        : Date[1:24], format: "2019-05-02" "2019-05-06" ...
 $ earliest_hatch_date                      : Date[1:24], format: "2019-05-22" "2019-05-24" ...
 $ earliest_fledge_date                     : Date[1:24], format: "2019-06-05" "2019-06-16" ...
 $ total_number_eggs                        : num [1:24] 8 77 10 89 4 75 3 118 0 6 ...
 $ total_number_nestlings                   : num [1:24] 8 42 9 79 4 58 3 104 0 0 ...
 $ total_number_fledglings                  : num [1:24] NA 38 9 78 4 57 3 103 0 0 ...
 $ nest_attempts_with_at_least_one_fledgling: num [1:24] 0 10 2 20 1 11 1 27 0 0 ...
 $ nesting_success_rate                     : chr [1:24] "0.0%" "45.5%" "50.0%" "74.1%" ...
 $ mean_clutch_size                         : num [1:24] 8 4.81 5 4.05 4 ...
 $ mean_nestlings                           : num [1:24] 8 3.23 4.5 3.59 4 ...
 $ mean_fledglings                          : num [1:24] NA 2.92 4.5 3.55 4 ...
 $ year                                     : int [1:24] 2019 2019 2019 2019 2019 2020 2020 2020 2020 2021 ...
 - attr(*, "spec")=
  .. cols(
  ..   X1 = col_character(),
  ..   X2 = col_double(),
  ..   X3 = col_date(format = ""),
  ..   X4 = col_date(format = ""),
  ..   X5 = col_date(format = ""),
  ..   X6 = col_double(),
  ..   X7 = col_double(),
  ..   X8 = col_double(),
  ..   X9 = col_double(),
  ..   X10 = col_character(),
  ..   X11 = col_double(),
  ..   X12 = col_double(),
  ..   X13 = col_double()
  .. )
 - attr(*, "problems")=<externalptr> 

Data prep for the breeding summary file

There’s a little more work to do with this file than the other two. It’s the main source of detailed data needed for our analysis. We start, much like we just did with the species summaries, by reading in each year specific file and combining them into one breeding summary dataframe.

# Create list of dataframes - one df for each year
breeding_summary_dfs <- list()
for (yr in year_range){
  year_str = as.character(yr)
  breeding_file <- file.path(raw_data_path, paste0(breeding_stub, '-', year_str,".csv"))
  breeding_summary_dfs[[year_str]] <- read_csv(file = breeding_file, 
                                               col_names = TRUE, comment = '#',
                                               show_col_types = FALSE)
}
# Combine list of dataframes into one dataframe.
breeding_summary_df <- bind_rows(breeding_summary_dfs, .id = "site_year")

Then we do some changing of data types, cleaning column names, adding a new column and replacing NA values with 0’s.

# Change site_year to numeric
breeding_summary_df$site_year <- as.numeric(breeding_summary_df$site_year)
# Clean up the column names
breeding_summary_df <- breeding_summary_df %>% janitor::clean_names()
# Add area
breeding_summary_df$area <- str_extract(breeding_summary_df$site_name, '^[A-Z]+')

# Replace NA with 0 in some of the numeric columns
breeding_summary_df$no_of_fledged <- 
  replace_na(breeding_summary_df$no_of_fledged, 0)
breeding_summary_df$max_clutch_size <- 
  replace_na(breeding_summary_df$max_clutch_size, 0)
breeding_summary_df$total_live_young <- 
  replace_na(breeding_summary_df$total_live_young, 0)
breeding_summary_df$unhatched_eggs <- 
  replace_na(breeding_summary_df$unhatched_eggs, 0)

Then we do computation of hatch and fledge rates.

# Compute hatch rate and fledge rate (can compare to eBird's reported rates which are strings with %)
# ISSUE: max_clutch_size seems like it should equal total_live_young + unhatched_eggs. While it usually does,
# there are cases where this is not true. In such cases, which should be used for the denominator when computing
# hatch_rate? It seems that max_clutch_size is the correct denominator.

breeding_summary_df$hatch_rate_computed <- 
  breeding_summary_df$total_live_young / breeding_summary_df$max_clutch_size
breeding_summary_df$fledge_rate_computed <- 
  breeding_summary_df$no_of_fledged / breeding_summary_df$total_live_young 

Since many boxes see more than one nesting event per season, I thought it would be helpful to create a nesting event sequence number within each year for each nest box. As a first step, I wanted a datetime field that was some sort of proxy for the nesting event. Taking the minimum of the first egg date, the first hatch date and the first fledge date gives us such a datetime for those nesting attempts resulting in at least one egg. However, this misses all those failed nesting attempts. It seems that the only way to get at those is through the Site Visits table. Even without looking at that table, we can still tell there was a nesting event because all three first date fields have NA values. We just can’t sequence it. That will be a problem for another day. We are mostly focusing on true nesting attempts defined by at least one egg being documented.

# Start by computing min date of the three date fields so that we have
# a single date field to use for sequencing if needed. 
breeding_summary_df <- breeding_summary_df %>% 
  rowwise() %>% 
  mutate(seq_date = min(c(x1st_egg_date, x1st_hatch_date, x1st_fledge_date), na.rm = TRUE))

Finally, we can clean up and save an .RData file containing the three main dataframes we just created.

# Remove the list
rm(breeding_summary_dfs)

# Save all data for research
filename <- str_interp('data/nestwatch_sialia_${min_year}_${max_year}.RData')
save(breeding_summary_df, site_sf, species_summary_df, file=filename)

Fledged by species

annual_species_counts |> 
  filter(species != "House Sparrow", species != "American Goldfinch", !is.na(species)) |> 
  group_by(site_year, species) |> 
  summarize(.groups="rowwise", Fledged = sum(tot_fledged)) |> 
  pivot_wider(id_cols = species, names_from = site_year, values_from = Fledged) %>% 
  replace(is.na(.), 0) |> 
  gt() |> 
  tab_header(
    title = "Total Fledged",
    #subtitle = str_glue("{min_year} to {max_year}")
  )

annual_species_counts |> 
  filter(species %in% c("Eastern Bluebird", "Tree Swallow")) |> 
  ggplot() +
  geom_line(aes(x = site_year, y = tot_fledged, colour = species)) +
  labs(x = "Year", y = "Total fledged", title = "Total fledged by species")

Live young by species

annual_species_counts |> 
  filter(species != "House Sparrow", species != "American Goldfinch", !is.na(species)) |> 
  group_by(site_year, species) |> 
  summarize(.groups="rowwise", live_young = sum(tot_live_young)) |> 
  pivot_wider(id_cols = species, names_from = site_year, values_from = live_young) %>% 
  replace(is.na(.), 0) |>
  gt() |> 
  tab_header(
    title = "Total Live Young",
    #subtitle = str_glue("{min_year} to {max_year}")
  )

annual_species_counts |> 
  filter(species %in% c("Eastern Bluebird", "Tree Swallow")) |> 
  ggplot() +
  geom_line(aes(x = site_year, y = tot_live_young, colour = species)) +
  labs(x = "Year", y = "Total live young", title = "Total live young by species")

Hatch rate

The hatch rate is the total number of live young divided by the max clutch size observed during the nesting event.

annual_species_counts |> 
  filter(species == "Eastern Bluebird" | species == "Tree Swallow" | species == "House Wren") |> 
  group_by(site_year, species) |> 
  summarize(.groups="rowwise", hatch_rate = sum(overall_hatch_rate_2)) |> 
  pivot_wider(id_cols = species, names_from = site_year, values_from = hatch_rate) %>% 
  replace(is.na(.), 0) |>
  gt() |> 
  tab_header(
    title = "Total Hatch Rate",
    #subtitle = str_glue("{min_year} to {max_year}")
  ) |> 
  fmt_number(columns = starts_with("2"), decimals = 2)

annual_species_counts |> 
  filter(species %in% c("Eastern Bluebird", "Tree Swallow")) |> 
  ggplot() +
  geom_line(aes(x = site_year, y = overall_hatch_rate_2, colour = species)) +
  labs(x = "Year", y = "Hatch rate", title = "Hatch rate by species")

Fledge rate

The fledge rate is the total number of birds fledged divided by the total number of live young.

annual_species_counts |> 
  filter(species == "Eastern Bluebird" | species == "Tree Swallow" | species == "House Wren") |> 
  group_by(site_year, species) |> 
  summarize(.groups="rowwise", fledge_rate = sum(overall_fledge_rate)) |> 
  pivot_wider(id_cols = species, names_from = site_year, values_from = fledge_rate) |> 
  gt() |> 
  tab_header(
    title = "Total Fledge Rate",
    #subtitle = str_glue("{min_year} to {max_year}")
  ) |> 
  fmt_number(columns = starts_with("2"), decimals = 2)

annual_species_counts |> 
  filter(species %in% c("Eastern Bluebird", "Tree Swallow")) |> 
  ggplot() +
  geom_line(aes(x = site_year, y = overall_fledge_rate, colour = species)) +
  labs(x = "Year", y = "Fledge rate", title = "Fledge rate by species")

We’ll stop here for now. In the next installment we’ll look to see if there are differences in nesting success in Peterson boxes versus the traditional boxes.

Primary energy consumption in US, CA, MX

north_america_metrics_df |> 
  mutate(gdp_total_idx = gdp_total / gdp_total[1],
         primary_energy_consumption_Twh_idx = primary_energy_consumption_Twh / primary_energy_consumption_Twh[1]) |> 
  select(year, gdp_total_idx, primary_energy_consumption_Twh_idx) |> 
  pivot_longer(cols = c(gdp_total_idx, primary_energy_consumption_Twh_idx), names_to = 'metric', values_to = 'value') |> 
  ggplot() +
  geom_line(aes(x=year, y = value, color = metric)) +
  scale_color_manual(values = c("#6C5043FF", "#A3BAC2FF")) +
  labs(x = "Year (1980 is year 1)", y = "Multiple of year 1", 
       title = "Primary energy consumption - US, CA, MX")

country_metrics_df |> 
  filter(country == 'United States' | country == 'Canada' | country == 'Mexico') |> 
  group_by(country) |> 
  mutate(gdp_total_idx = gdp_total / gdp_total[1],
       primary_energy_consumption_Twh_idx = primary_energy_consumption_Twh / primary_energy_consumption_Twh[1]) |> 
  ungroup() |> 
  select(country, year, gdp_total_idx, primary_energy_consumption_Twh_idx) |> 
  pivot_longer(cols = c(gdp_total_idx, primary_energy_consumption_Twh_idx), names_to = 'metric', values_to = 'value') |> 
  ggplot() +
  geom_line(aes(x=year, y = value, color = metric)) + 
  facet_grid(country ~ ., scales = 'free_y') +
  scale_color_manual(values = c("#6C5043FF", "#A3BAC2FF")) +
  labs(x = "Year (1980 is year 1)", y = "Multiple of year 1", 
       title = "Primary energy consumption - US, CA, MX")

Total fossil fuel consumption in US, CA, MX

north_america_metrics_df |> 
  mutate(gdp_total_idx = gdp_total / gdp_total[1],
       tot_fossil_fuel_consumption_twh_idx = tot_fossil_fuel_consumption_twh / tot_fossil_fuel_consumption_twh[1]) |> 
  select(year, gdp_total_idx, tot_fossil_fuel_consumption_twh_idx) |> 
  pivot_longer(cols = c(gdp_total_idx, tot_fossil_fuel_consumption_twh_idx), names_to = 'metric', values_to = 'value') |> 
  ggplot() +
  geom_line(aes(x=year, y = value, color = metric)) +
  scale_color_manual(values = c("#6C5043FF", "#A3BAC2FF")) +
  labs(x = "Year (1980 is year 1)", y = "Multiple of year 1", 
       title = "Total fossil fuel consumption - US, CA, MX")

country_metrics_df |> 
  filter(country == 'United States' | country == 'Canada' | country == 'Mexico') |> 
  group_by(country) |> 
  mutate(gdp_total_idx = gdp_total / gdp_total[1],
       tot_fossil_fuel_consumption_twh_idx = tot_fossil_fuel_consumption_twh / tot_fossil_fuel_consumption_twh[1]) |> 
  ungroup() |> 
  select(country, year, gdp_total_idx, tot_fossil_fuel_consumption_twh_idx) |> 
  pivot_longer(cols = c(gdp_total_idx, tot_fossil_fuel_consumption_twh_idx), names_to = 'metric', values_to = 'value') |> 
  ggplot() +
  geom_line(aes(x=year, y = value, color = metric)) + 
  facet_grid(country ~ ., scales = 'free_y') +
  scale_color_manual(values = c("#6C5043FF", "#A3BAC2FF")) +
  labs(x = "Year (1980 is year 1)", y = "Multiple of year 1", 
       title = "Total fossil fuel consumption - US, CA, MX")

Total greenhouse gas emissions in US, CA, MX

north_america_metrics_df |> 
  mutate(gdp_total_idx = gdp_total / gdp_total[1],
       annual_emissions_ghg_total_co2eq_idx = annual_emissions_ghg_total_co2eq / annual_emissions_ghg_total_co2eq[1]) |> 
  select(year, gdp_total_idx, annual_emissions_ghg_total_co2eq_idx) |> 
  pivot_longer(cols = c(gdp_total_idx, annual_emissions_ghg_total_co2eq_idx), names_to = 'metric', values_to = 'value') |> 
  ggplot() +
  geom_line(aes(x=year, y = value, color = metric)) +
  scale_color_manual(values = c("#A3BAC2FF", "#6C5043FF")) +
  labs(x = "Year (1980 is year 1)", y = "Multiple of year 1", 
       title = "Total greenhouse gas emissions - US, CA, MX")

This looks promising.

country_metrics_df |> 
  filter(country == 'United States' | country == 'Canada' | country == 'Mexico') |> 
  group_by(country) |> 
  mutate(gdp_total_idx = gdp_total / gdp_total[1],
       annual_emissions_ghg_total_co2eq_idx = annual_emissions_ghg_total_co2eq / annual_emissions_ghg_total_co2eq[1]) |> 
  ungroup() |> 
  select(country, year, gdp_total_idx, annual_emissions_ghg_total_co2eq_idx) |> 
  pivot_longer(cols = c(gdp_total_idx, annual_emissions_ghg_total_co2eq_idx), names_to = 'metric', values_to = 'value') |> 
  ggplot() +
  geom_line(aes(x=year, y = value, color = metric)) + facet_grid(country ~ ., scales = 'free_y') +
  scale_color_manual(values = c("#A3BAC2FF", "#6C5043FF")) +
  labs(x = "Year (1980 is year 1)", y = "Multiple of year 1", 
       title = "Total greenhouse gas emissions - US, CA, MX")

Recent increases in wind and solar likely the cause of the stabilization of GHG emissions in US and Canada. Mexico is still seeing increases.

What about coal production in these three countries?

country_metrics_df |> 
  filter(country == 'United States' | country == 'Canada' | country == 'Mexico') |> 
  group_by(country) |> 
  mutate(gdp_total_idx = gdp_total / gdp_total[1],
       coal_consumption_twh_idx = coal_consumption_twh / coal_consumption_twh[1]) |> 
  ungroup() |> 
  select(country, year, gdp_total_idx, coal_consumption_twh_idx) |> 
  pivot_longer(cols = c(gdp_total_idx, coal_consumption_twh_idx), names_to = 'metric', values_to = 'value') |> 
  ggplot() +
  geom_line(aes(x=year, y = value, color = metric)) + facet_grid(country ~ ., scales = 'free_y') +
  scale_color_manual(values = c("#A3BAC2FF", "#6C5043FF")) +
  labs(x = "Year (1980 is year 1)", y = "Multiple of year 1", 
       title = "Coal production - US, CA, MX")

NOAA - Great Lakes Environmental Research Laboratory

• Main - https://www.glerl.noaa.gov/
• Water levels - https://www.glerl.noaa.gov/data/wlevels/
  • tabs for monitoring network, observations and forecasts
• Dashboard - https://www.glerl.noaa.gov/data/wlevels/dashboard/
• Data - https://www.glerl.noaa.gov/data/
• APIs - https://tidesandcurrents.noaa.gov/web_services_info.html
• Water levels and hydrology - https://www.glerl.noaa.gov/data/#hydro
• Tides and Currents - Water levels - https://tidesandcurrents.noaa.gov/water_level_info.html
• Monthly hydrological data - https://www.glerl.noaa.gov/ahps/mnth-hydro.html
• Large Lake Statistical Water Balance Model (L2SWBM) - https://github.com/NOAA-GLERL/L2SWBM
• Great Lakes Seasonal Hydrological Forecasting Products (Experimental) https://www.glerl.noaa.gov/ahps/curfcst.html
• Great Lakes water budget - https://www.glerl.noaa.gov/pubs/brochures/GreatLakesWaterBudgets.png

Other resources

• US Army Corp of Engineers - Great Lakes Information
• Great Lakes Coordination Committee (US and CA)
• Fisheries and Oceans CA - observational data and forecasts

Alternative data source from GLCC

The Great Lakes Coordination Committee (US and CA) does what it sounds like it does.

The Coordinating Committee on Great Lakes Basic Hydraulic and Hydrologic Data (Coordinating Committee) is a collaboration of the Governments of the United States and Canada for the purpose of agreeing upon the basic hydraulic, hydrologic and vertical control data that is required to manage the Great Lakes and St. Lawrence River.

They also maintain a repository of Great Lakes water level data at https://www.greatlakescc.org/en/coordinating-committee-products-and-datasets/. There are CSV files stored on Google Drive for each lake containing mean monthly water levels since 1918. These are in a different wide format than the data above. Let’s look at the data for Lake Michigan-Huron and compare to the data we just downloaded. Here is what the raw data looks like:

# NAME: LAKE MICHIGAN-HURON MONTHLY MEAN LEVELS 
# UNITS: metres (m) (DATUM: International Great Lakes Datum of 1985) 
# PERIOD OF RECORD: 1918 TO 2024
# DESCRIPTION: Water levels are measured by the National Oceanic and Atmospheric Administration and the  
# Canadian Department of Fisheries and Oceans.  Mean levels are computed as an average
# of a network of gauges and coordinated under the auspices of the Coordinating Committee on 
# Great Lakes Basic Hydraulic and Hydrologic Data      www.greatlakescc.org 
# # All data for the previous 12 months should be considered provisional. 
# note: -9999 means that no data is available for that date 
Year, Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec 
1918,176.71,176.73,176.8,176.89,176.99,177.07,177.07,177.01,176.94,176.83,176.82,176.78 
1919,176.74,176.68,176.68,176.77,176.89,176.92,176.88,176.83,176.72,176.66,176.62,176.55 
1920,176.5,176.47,176.49,176.63,176.68,176.73,176.79,176.76,176.73,176.65,176.57,176.5 
1921,176.44,176.42,176.42,176.54,176.63,176.64,176.6,176.54,176.5,176.44,176.35,176.34 
1922,176.27,176.24,176.28,176.43,176.57,176.63,176.67,176.63,176.56,176.46,176.35,176.25 

A few things to note:

• The top nine lines are metadata,
• Data goes back to 1918,
• Data is in wide format in that each month (instead of lake) is in its own column.

We need to combine the separate lake files and do some reshaping and column manipulation. Again, I’ve already downloaded the five data files to a local folder.

data_cc_raw_loc <-"data_water_level/raw/"

gl_data_raw = list()
gl_data_long = list()

# regex pattern for filename matching
file_pattern <- "\\w+_MonthlyMeanWaterLevels_1918to2024\\.csv$"
gl_files <- list.files(path = data_cc_raw_loc, pattern = file_pattern)

# Loop over the list of matched filenames
for (i in seq_along(gl_files)) {
    filename <- paste0(data_cc_raw_loc, gl_files[i])
    gl_data_raw[[i]] <- read_csv(file = filename, skip = 9)
    # Which lake?
    lake <- str_match(filename, "(Lake\\w+)_Month")[2]
    # Pivot to long format
    gl_data_long[[i]] <- pivot_longer(gl_data_raw[[i]], names_to = "month", values_to = "level_m", cols = 2:13)
    # Add a lake identifier column
    gl_data_long[[i]]$lake <- lake
    # Add date based on month and year
    gl_data_long[[i]]$date <- as.POSIXct(str_c(gl_data_long[[i]]$month, " 1, ",
                                               gl_data_long[[i]]$Year),
                                         format="%b %d, %Y")

}

# Bind all the rows together from the list of dataframes
mean_lake_level_cc_long <- bind_rows(gl_data_long)

# Column renaming and factor seting
mean_lake_level_cc_long <- mean_lake_level_cc_long %>% 
  rename(year = Year)
mean_lake_level_cc_long$lake <- factor(mean_lake_level_cc_long$lake, 
                                       levels = c("LakeSuperior", "LakeMichiganHuron", "LakeStClair", "LakeErie", "LakeOntario"))

This data goes through 2024 whereas the one from the NOAA site hasn’t been updated yet for 2024. Let’s check to see if data is the same through 2023.

level_m_noaa <- mean_lake_level_long %>% 
  select(level_m) 

level_m_cc <- mean_lake_level_cc_long %>% 
  filter(year < 2024) %>% 
  select(level_m)

max_abs_diff <- max(abs(level_m_noaa$level_m - level_m_cc$level_m), na.rm = TRUE)
assertthat::assert_that(max_abs_diff == 0)

[1] TRUE

Confirms that the data is identical from the two sources.

Claude prompt 1

You have a csv file named bike_trips.csv. Each row is a bike rental from a bike share system. The fields start_rental and stop_rental are datetime values specifying when the bike is rented and returned. The fields from_station and to_station are strings indicating the bike rental stations that the bike was rented from and returned to. Using Python with pandas, generate the code to compute the total number of rentals from each station.

It responded with the following.

Claude response 1

I’ll help you write Python code to analyze the bike rental data and count rentals by station.

import pandas as pd

# Read the CSV file
df = pd.read_csv('bike_trips.csv')

# Count rentals from each station
station_rentals = df['from_station'].value_counts()

# Convert to a DataFrame for better formatting
rental_summary = pd.DataFrame({
    'station': station_rentals.index,
    'total_rentals': station_rentals.values
})

# Sort by number of rentals in descending order
rental_summary = rental_summary.sort_values('total_rentals', ascending=False)

# Reset index for cleaner display
rental_summary = rental_summary.reset_index(drop=True)

# Display the results
print("\nTotal Rentals by Station:")
print(rental_summary.to_string(index=False))

This code will:

• Read your bike_trips.csv file into a pandas DataFrame
• Use value_counts() to count how many times each station appears in the from_station column
• Convert the results to a clean DataFrame with station names and rental counts
• Sort the results by number of rentals in descending order
• Display a formatted table showing each station and its total number of rentals

Would you like me to modify the analysis in any way? For example, I could:

• Add percentage of total rentals for each station
• Filter for a specific time period
• Group by month or day of week
• Include additional statistics about the rentals

My reaction to response 1

Nicely done. The explanation and suggestions for future analysis are defintely reasonable. There are a few issues with the code but that’s mostly easy stuff like fixing the path to the data file. Let’s test it.

import pandas as pd

# Read the CSV file
## MY FIX: modified the path
df = pd.read_csv('data/bike_trips.csv')

# Count rentals from each station
station_rentals = df['from_station'].value_counts()

# Convert to a DataFrame for better formatting
rental_summary = pd.DataFrame({
    'station': station_rentals.index,
    'total_rentals': station_rentals.values
})

# Sort by number of rentals in descending order
rental_summary = rental_summary.sort_values('total_rentals', ascending=False)

# Reset index for cleaner display
rental_summary = rental_summary.reset_index(drop=True)

# Display the results
print("\nTotal Rentals by Station:")
print(rental_summary.to_string(index=False))

Total Rentals by Station:
                                                               station  total_rentals
                                       Pier 69 / Alaskan Way & Clay St           2276
                                                  E Pine St & 16th Ave           2052
                                                    3rd Ave & Broad St           1915
                                                     2nd Ave & Pine St           1823
                                                Westlake Ave & 6th Ave           1711
                                        E Harrison St & Broadway Ave E           1629
                                Cal Anderson Park / 11th Ave & Pine St           1607
                                                     2nd Ave & Vine St           1498
                                            REI / Yale Ave N & John St           1480
                                   Key Arena / 1st Ave N & Harrison St           1326
                                         PATH / 9th Ave & Westlake Ave           1315
                                              15th Ave E & E Thomas St           1302
                                              Summit Ave & E Denny Way           1187
                                               Dexter Ave N & Aloha St           1184
                                        Summit Ave E & E Republican St           1150
                                                12th Ave & E Mercer St           1110
                  Seattle Aquarium / Alaskan Way S & Elliott Bay Trail           1086
                                                     Pine St & 9th Ave           1077
                                                2nd Ave & Blanchard St           1041
                                          E Blaine St & Fairview Ave E           1000
                  Occidental Park / Occidental Ave S & S Washington St            983
                                        Republican St & Westlake Ave N            976
                             Lake Union Park / Valley St & Boren Ave N            964
                                                   1st Ave & Marion St            954
                                                    7th Ave & Union St            950
                                                   2nd Ave & Spring St            947
                                               Harvard Ave & E Pine St            942
                                                 9th Ave N & Mercer St            928
                                              Bellevue Ave & E Pine St            916
                                                6th Ave & Blanchard St            865
                                                Dexter Ave & Denny Way            817
                         Seattle University / E Columbia St & 12th Ave            752
                                         Eastlake Ave E & E Allison St            681
                                        City Hall / 4th Ave & James St            667
                     Burke-Gilman Trail / NE Blakeley St & 24th Ave NE            664
        King Street Station Plaza / 2nd Ave Extension S & S Jackson St            661
     Fred Hutchinson Cancer Research Center / Fairview Ave N & Ward St            646
                                                12th Ave & E Denny Way            644
                                             12th Ave & NE Campus Pkwy            601
                             Frye Art Museum / Terry Ave & Columbia St            566
                                              15th Ave NE & NE 40th St            489
                                                 6th Ave S & S King St            480
                                                    Union St & 4th Ave            475
              UW Engineering Library / E Stevens Way NE & Jefferson Rd            438
                                              NE 47th St & 12th Ave NE            393
                     Burke Museum / E Stevens Way NE & Memorial Way NE            392
                                                Terry Ave & Stewart St            361
                                     UW Intramural Activities Building            303
                  Children's Hospital / Sandpoint Way NE & 40th Ave NE            278
                                        NE 42nd St & University Way NE            271
UW Magnuson Health Sciences Center Rotunda / Columbia Rd & San Juan Rd            238
                                              Broadway and E Denny Way            224
                                       NE Pacific St/UW Medical Center            171
                                                 Mercer St & 9th Ave N            165
                                               12th Ave & E Yesler Way            153
                                          UW McCarty Hall / Whitman Ct            124
                                                 Thomas St & 5th Ave N            123
                                       Pier 66 / Alaskan Way & Bell St             27
                                                             8D OPS 02              2

Works correctly.

Claude prompt 2

Great. Now using Python and pandas, compute the average length of time in hours that bikes are rented.

It responded with the following code. Again, there were a few easily fixable issues:

• modified the path to point to the data subfolder (I should have told Claude the path in the first place)
• could have used the parse_dates = parameter to do the datetime conversion on the file read, but no harm.
• forgot the import for matplotlib

Claude response 2

import pandas as pd
## MY FIX: added necessary import
import matplotlib.pyplot as plt

# Read the CSV file
## MY FIX: modified the path
df = pd.read_csv('data/bike_trips.csv')

# Convert datetime strings to datetime objects
df['start_rental'] = pd.to_datetime(df['start_rental'])
df['stop_rental'] = pd.to_datetime(df['stop_rental'])

# Calculate duration in hours for each rental
df['rental_duration'] = (df['stop_rental'] - df['start_rental']).dt.total_seconds() / 3600

# Calculate average duration
average_duration = df['rental_duration'].mean()

# Calculate additional statistics
duration_stats = {
    'average_hours': average_duration,
    'median_hours': df['rental_duration'].median(),
    'min_hours': df['rental_duration'].min(),
    'max_hours': df['rental_duration'].max(),
    'std_hours': df['rental_duration'].std()
}

# Print results
print("\nRental Duration Statistics (in hours):")
for stat, value in duration_stats.items():
    print(f"{stat.replace('_', ' ').title()}: {value:.2f}")

# Create a histogram of rental durations for rentals under 24 hours
short_rentals = df[df['rental_duration'] <= 24]
plt.figure(figsize=(10, 6))
plt.hist(short_rentals['rental_duration'], bins=48, edgecolor='black')
plt.title('Distribution of Rental Durations (≤ 24 hours)')
plt.xlabel('Duration (hours)')
plt.ylabel('Number of Rentals')
plt.grid(True, alpha=0.3)
plt.show()

Rental Duration Statistics (in hours):
Average Hours: 0.32
Median Hours: 0.17
Min Hours: -0.28
Max Hours: 7.98
Std Hours: 0.56

My reaction to response 2

Let’s confirm that the negative minimum is correct. Nice touch with the histogram.

trip_small[trip_small['stop_rental'] < trip_small['start_rental']]

Great. Nice job, Claude.

Claude prompt 3

Great. Now using Python and pandas, compute the average number of bike rentals by day of week.

Claude response 3

I’ll help you analyze the rental patterns by day of week.

import pandas as pd

# Read the CSV file
df = pd.read_csv('bike_trips.csv')

# Convert start_rental to datetime
df['start_rental'] = pd.to_datetime(df['start_rental'])

# Extract day of week (0 = Monday, 6 = Sunday)
df['day_of_week'] = df['start_rental'].dt.dayofweek

# Create day name column for better readability
df['day_name'] = df['start_rental'].dt.day_name()

# Calculate average rentals by day of week
daily_rentals = df.groupby('day_name')['start_rental'].count().reset_index()
daily_rentals.columns = ['day_of_week', 'total_rentals']

# Calculate the number of unique dates for each day of week
unique_days = df.groupby('day_name')['start_rental'].dt.date.nunique().reset_index()
unique_days.columns = ['day_of_week', 'number_of_days']

# Merge and calculate average
daily_averages = pd.merge(daily_rentals, unique_days, on='day_of_week')
daily_averages['average_rentals'] = daily_averages['total_rentals'] / daily_averages['number_of_days']

# Sort by day of week (Monday first)
day_order = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
daily_averages['day_of_week'] = pd.Categorical(daily_averages['day_of_week'], categories=day_order, ordered=True)
daily_averages = daily_averages.sort_values('day_of_week')

# Round averages to 1 decimal place
daily_averages['average_rentals'] = daily_averages['average_rentals'].round(1)

# Display results
print("\nAverage Daily Rentals by Day of Week:")
print(daily_averages[['day_of_week', 'average_rentals']].to_string(index=False))

# Create a bar plotPython
plt.figure(figsize=(10, 6))
plt.bar(daily_averages['day_of_week'], daily_averages['average_rentals'])
plt.title('Average Number of Bike Rentals by Day of Week')
plt.xlabel('Day of Week')
plt.ylabel('Average Number of Rentals')
plt.xticks(rotation=45)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

This code will:

• Convert the start_rental timestamps to datetime objects
• Extract the day of week from each rental
• Count the total rentals for each day
• Calculate the number of unique dates for each day of week (to account for the total number of each day in the dataset)
• Compute the average daily rentals
• Create a bar plot visualizing the daily patterns

I’ve included:

• Proper handling of the day names (sorted from Monday to Sunday)
• Both total counts and averages to account for any differences in the number of each day in your dataset
• A bar plot to visualize the weekly pattern

Would you like me to modify the analysis? For example, I could: - Break down the daily patterns by station - Add hour-of-day analysis within each day - Compare weekday vs weekend patterns - Add seasonal trends by day of week

Let’s try out the code.

import pandas as pd

## MY FIX: added necessary import
import matplotlib.pyplot as plt

# Read the CSV file
## MY FIX: modified the path
df = pd.read_csv('data/bike_trips.csv')

# Convert start_rental to datetime
df['start_rental'] = pd.to_datetime(df['start_rental'])

# Extract day of week (0 = Monday, 6 = Sunday)
df['day_of_week'] = df['start_rental'].dt.dayofweek

# Create day name column for better readability
df['day_name'] = df['start_rental'].dt.day_name()

# Calculate average rentals by day of week
daily_rentals = df.groupby('day_name')['start_rental'].count().reset_index()
daily_rentals.columns = ['day_of_week', 'total_rentals']

# Calculate the number of unique dates for each day of week
unique_days = df.groupby('day_name')['start_rental'].dt.date.nunique().reset_index()
unique_days.columns = ['day_of_week', 'number_of_days']

# Merge and calculate average
daily_averages = pd.merge(daily_rentals, unique_days, on='day_of_week')
daily_averages['average_rentals'] = daily_averages['total_rentals'] / daily_averages['number_of_days']

# Sort by day of week (Monday first)
day_order = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
daily_averages['day_of_week'] = pd.Categorical(daily_averages['day_of_week'], categories=day_order, ordered=True)
daily_averages = daily_averages.sort_values('day_of_week')

# Round averages to 1 decimal place
daily_averages['average_rentals'] = daily_averages['average_rentals'].round(1)

# Display results
print("\nAverage Daily Rentals by Day of Week:")
print(daily_averages[['day_of_week', 'average_rentals']].to_string(index=False))

# Create a bar plot
plt.figure(figsize=(10, 6))
plt.bar(daily_averages['day_of_week'], daily_averages['average_rentals'])
plt.title('Average Number of Bike Rentals by Day of Week')
plt.xlabel('Day of Week')
plt.ylabel('Average Number of Rentals')
plt.xticks(rotation=45)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()