Introduction

The Los Angeles Dodgers once again dominated the headlines in January 2026, securing superstar outfielder Kyle Tucker with a massive four-year, $240 million contract. After a brief but productive stint with the Chicago Cubs in 2025, Tucker joins a Dodgers lineup that is already arguably the most feared in baseball. The Dodgers starting lineup can look like: 1. Ohtani, 2. Betts, 3. Freeman, 4. Smith, 5. Tucker. Having a lineup with such high OBP and power potential will be a nightmare for opposing pitchers.

2025 Review: A Cub in Transition

Following his trade from the Houston Astros in late 2024, Tucker adapted quickly to the Friendly Confines of Wrigley Field. While 2025 was a year of adjustment, his Statcast metrics remained elite, suggesting that his move to Los Angeles comes right as he is hitting his peak.

Statcast Analysis: 2025 Performance

The following analysis was performed on Tucker’s 2025 Statcast data to derive the metrics used in this article.

Code

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
sns.set_theme(style="whitegrid", palette="deep")
pd.set_option('display.max_columns', None)

# Load the 2025 Statcast data
df = pd.read_csv('tucker-data.csv')

# Calculate core metrics
ev_la_df = df.dropna(subset=['EV (MPH)', 'LA'])
avg_ev = ev_la_df['EV (MPH)'].mean()
avg_la = ev_la_df['LA'].mean()
hard_hit_rate = (ev_la_df['EV (MPH)'] >= 95).sum() / len(ev_la_df) * 100

from IPython.display import Markdown, display
from tabulate import tabulate

# Summary Metrics Table
summary_data = [
    ["Avg EV", f"{avg_ev:.2f} MPH"],
    ["Hard Hit Rate", f"{hard_hit_rate:.2f}%"],
    ["Avg Launch Angle", f"{avg_la:.2f}"]
]

# Pitch Performance Analysis
pitch_ev_summary = ev_la_df.groupby('Pitch Type')['EV (MPH)'].mean().reset_index().sort_values('EV (MPH)', ascending=False).head(5)

display(Markdown(tabulate(summary_data, headers=["Metric", "Value"], tablefmt="github")))
display(Markdown("\n**Top Pitch Performance (Avg EV):**"))
display(Markdown(tabulate(pitch_ev_summary, headers=["Pitch Type", "Avg EV (MPH)"], tablefmt="github", showindex=False)))

Metric	Value
Avg EV	89.69 MPH
Hard Hit Rate	39.95%
Avg Launch Angle	16.75

Top Pitch Performance (Avg EV):

Pitch Type	Avg EV (MPH)
Other	105.7
Knuckle Curve	93.5833
4-Seam Fastball	93.4658
Cutter	90.6436
Sinker	90.1813

Analyzing the 2025 at-bat data reveals a hitter who remains fundamentally sound with high-end power potential.

• Average Exit Velocity: 87.48 MPH
• Hard-Hit Rate (95+ MPH): 32.71%
• Average Launch Angle: 10.99
• Home Runs: 5 (in this specific data slice)
• Plate Discipline: 18 Walks vs. 30 Strikeouts across 157 plate appearances.

Performance by Pitch Type

Tucker continues to be a terror against fastballs, which bodes well for his transition to the NL West’s high-velocity environments.

Pitch Type	Frequency	Avg Exit Velocity (MPH)
4-Seam Fastball	60	91.72
Sinker	25	85.64
Slider	21	82.28
Changeup	17	89.09
Cutter	9	91.27

The 91.72 MPH average exit velocity against the four-seamer stands out as his primary weapon. Even against breaking stuff like the Slider and Sweeper, Tucker maintained competitive contact, though his highest damage was clearly reserved for the heater.

Visualizing Trends: Rolling Average EV

To better understand Tucker’s consistency, we can look at the rolling average of his exit velocity across the 2025 season.

Code

import matplotlib.pyplot as plt
import seaborn as sns

# Ensure data is sorted chronologically
ev_la_df["Game Date"] = pd.to_datetime(ev_la_df["Game Date"])
ev_la_df = ev_la_df.sort_values("Game Date")

# Calculate rolling average
ev_la_df['Rolling EV'] = ev_la_df['EV (MPH)'].rolling(window=15).mean()

plt.figure(figsize=(6, 4))

# Plotting raw data as points to highlight the density/gaps
sns.scatterplot(data=ev_la_df, x='Game Date', y='EV (MPH)', alpha=0.2, color='gray', label='Individual BBE')
sns.lineplot(data=ev_la_df, x='Game Date', y='Rolling EV', color='tab:blue', linewidth=2.5, label='15-BBE Rolling Avg')

# The gap between August and October represents a period with no recorded plate appearances (likely an IL stint)
plt.title('Kyle Tucker 2025 Rolling Exit Velocity (Season Timeline)')
plt.xlabel('Date')
plt.ylabel('Exit Velocity (MPH)')
plt.xticks(rotation=45)
plt.grid(True, linestyle='--', alpha=0.6)
plt.legend()
plt.tight_layout()
plt.show()

Forecasting for 2026: ARIMA Model

Using an ARIMA (AutoRegressive Integrated Moving Average) model, we can attempt to forecast the trend of Tucker’s exit velocity as he enters the 2026 season. Let’s first explain what an ARIMA model is. Time series analysis is a statistical method that uses historical data to make predictions about future values. ARIMA models are a type of time series model that can be used to forecast the trend of a time series.

An ARIMA model, denoted as , is a class of statistical models that captures temporal structures in time series data. Formally, for a stochastic process , the model is defined by the equation:

Where:

• is the lag (backshift) operator, defined such that .

• (Integrated) is the degree of differencing required to achieve stationarity. The term represents the -th order difference operator.

• (AutoRegressive) is a polynomial of order : . This captures the linear dependence of on its own previous values.

• (Moving Average) is a polynomial of order : . This represents the relationship between the observation and the previous white noise error terms.

• is a white noise process with mean zero and variance .

The model assumes that the -th difference of the series follows a stationary ARMA process, allowing us to model non-stationary data that exhibits a stochastic trend. Individual parameters are typically estimated via Maximum Likelihood Estimation (MLE) or least squares.

So how do we find , , and ? Well, we can use the autocorrelation function (ACF) and partial autocorrelation function (PACF) to help us determine the values of and . The ACF measures the correlation between the time series and its lagged values, while the PACF measures the correlation between the time series and its lagged values after removing the effects of the intermediate lags.

Code

from statsmodels.tsa.arima.model import ARIMA
import numpy as np
from statsmodels.tsa.stattools import adfuller
import matplotlib.dates as mdates

ev_series = ev_la_df['EV (MPH)'].values

# Perform Augmented Dickey-Fuller test
adf_result = adfuller(ev_series)
print(f'ADF Statistic: {adf_result[0]}')
print(f'p-value: {adf_result[1]}')
print(f'Critical Values: {adf_result[4]}')

# plot the partial autocorrelation function
from statsmodels.graphics.tsaplots import plot_pacf
plot_pacf(ev_series)
plt.show()

ADF Statistic: -19.88895111266658
p-value: 0.0
Critical Values: {'1%': -3.4454029241336483, '5%': -2.8681766097362087, '10%': -2.570305075326362}

The PACF shows a significant correlation at lag 1, indicating that the time series is non-stationary and requires differencing. The ACF shows a significant correlation at lag 1, indicating that the time series is non-stationary and requires differencing. We’ll use . Note that we also ran the Augmented Dickey-Fuller test to confirm that the time series is non-stationary. The p-value is less than 0.05, indicating that the time series is non-stationary. Hence, .

Below we show the ACF for the time series.

Code

# plot the autocorrelation function
from statsmodels.graphics.tsaplots import plot_acf
plot_acf(ev_series)
plt.show()

Similar to the PACF, the ACF shows a significant correlation at lag 1, indicating that the time series is non-stationary and requires differencing. We’ll use .

Finally, we’ll fit the ARIMA model and forecast the next 20 BBE.

Code

# Fit ARIMA model (p,d,q) - using (1,0,1) as a starting point
model = ARIMA(ev_series, order=(1, 0, 1))
model_fit = model.fit()

# Forecast the next 20 bbe
forecast_steps = 20
forecast = model_fit.forecast(steps=forecast_steps)
history_size = len(ev_series)
forecast_obj = model_fit.get_forecast(steps=forecast_steps)
forecast_df = forecast_obj.summary_frame()

# 2. Extract values
forecast_mean = forecast_df['mean']
conf_int_lower = forecast_df['mean_ci_lower']
conf_int_upper = forecast_df['mean_ci_upper']

# 3. Plotting
plt.figure(figsize=(8, 4))

# Plot history
sns.lineplot(x=np.arange(history_size), y=ev_series, label='Observed EV (2025)', color='tab:blue')

# Plot forecast mean
forecast_idx = np.arange(history_size, history_size + forecast_steps)
sns.lineplot(x=forecast_idx, y=forecast_mean, color='red', label='Forecasted EV (2026)', linestyle='--')

# Plot accurate Confidence Intervals from the model
plt.fill_between(forecast_idx, conf_int_lower, conf_int_upper, color='pink', alpha=0.3, label='95% Confidence Inter val')

plt.title('Kyle Tucker Exit Velocity Forecast (ARIMA)')
plt.xlabel('At-Bat Number (Sequential)')
plt.ylabel('Exit Velocity (MPH)')
plt.legend()
plt.show()

The ARIMA model indicates Tucker’s exit velocity is not dependent on the previous exit velocity. This is not unexpected given the small sample size of 2025. In other words, forecasting Tucker’s exit velocity is only as good as taking the mean of the exit velocity in 2025.

The model’s coefficients are shown below.

Code

from IPython.display import Markdown
from tabulate import tabulate
import pandas as pd

# Extract the coefficients table from the ARIMA model summary
summary_table = model_fit.summary().tables[1]
summary_df = pd.DataFrame(summary_table.data[1:], columns=summary_table.data[0])

# Display the summary table in Markdown format
Markdown(tabulate(summary_df, headers='keys', tablefmt='pipe'))

		coef	std err	z	P>	z
0	const	89.6849	0.8	112.174	0	88.118	91.252
1	ar.L1	-0.0897	1.149	-0.078	0.938	-2.342	2.163
2	ma.L1	0.1414	1.14	0.124	0.901	-2.094	2.376
3	sigma2	164.441	10.693	15.379	0	143.483	185.399

The p-values for ar.L1 and ma.L1 are both greater than 0.05, indicating that the coefficients are not significantly different from zero.

1. Querying Data

First things first, let’s write a simple SQL query to retrieve data from the sample database. SQL (Structured Query Language) is the standard language for managing and manipulating relational databases. For this example, let’s look at tutorial.flights, which contains information about flights, including departure and arrival times, delays, and distances.

Suppose we want to find the average arrival delay for flights grouped by flight distance categories (short haul, medium haul, long haul). We can define these categories as follows:

SELECT 
  CASE
    WHEN distance < 500 THEN 'Short Haul'
    WHEN distance >= 500 AND distance <= 1500 THEN 'Medium Haul'
    WHEN distance > 500 THEN 'Long Haul'
  END AS flight_type,
  COUNT(*) AS total_flights,
  AVG(arrival_delay) AS average_delay
FROM 
  tutorial.flights
GROUP BY 
  flight_type
ORDER BY 
  average_delay

In this query, we use a CASE statement to categorize flights based on their distance. We then count the total number of flights and calculate the average arrival delay for each category. The results are grouped by flight_type and ordered by average_delay. By convention, SQL keywords are written in uppercase to distinguish them from column names and other identifiers.

As a result, we get a table showing the average arrival delay for short haul, medium haul, and long haul flights.

2. Visualizing Data

Now that we have our data, let’s visualize it using Mode’s built-in charting capabilities. Visualizations help us understand data patterns and trends more intuitively.

Beneath the SQL editor, Mode provides a charting interface where we can create various types of visualizations, such as bar charts, line charts, scatter plots, and more. For our flight delay data, let’s create a bar chart to visualize the average arrival delay for each flight type.

3. Advanced Analysis with Python

Mode supports python notebooks, allowing us to perform more advanced analyses and visualizations. I’m a fan of this integration because it allows us to leverage the power of Python libraries like Pandas, NumPy, Matplotlib, and Seaborn for data analysis and visualization.

By default, SQL query results are available as a Pandas DataFrame in the Python notebook. Specifically, the variable, datasets contains a list of sql query results as DataFrames. Thus, to index the first query result, you would use datasets[0].

Let’s query the flight data again, this time retrieving arrival and departure delays for individual flights. We can then use Python to analyze the relationship between these two variables.

SELECT arrival_delay, departure_delay 
FROM tutorial.flights
LIMIT 1000

Now we can move to the Python notebook. Import familiar libraries.

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression

Recall that the SQL query results are stored in datasets. This variable stores all query results as a list of DataFrames. Since we only have two queries, we want to access the first index, datasets[1].

# df = datasets[1]
df = pd.read_csv("flight_arrivals_departure_delays.csv")
df = df.dropna(subset=["arrival_delay", "departure_delay"])
X = df[["departure_delay"]]
y = df["arrival_delay"]
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
print(X_train.shape, X_val.shape, y_train.shape, y_val.shape)

pip = Pipeline([
    ('scaler', StandardScaler()),
    ('regressor', LinearRegression())
])
pip.fit(X_train, y_train)
y_pred = pip.predict(X_val)
score = pip.score(X_val, y_val)
print(f"Model R^2 Score: {score:.2f}")
print(f"Model Coefficients: {pip.named_steps['regressor'].coef_}")
print(f"Model Intercept: {pip.named_steps['regressor'].intercept_}")

(799, 1) (200, 1) (799,) (200,)
Model R^2 Score: 0.76
Model Coefficients: [17.15344637]
Model Intercept: -8.27784730913642

A score of 0.76 indicates how well the model explains the variability of the data. The model coefficient is 17.2, meaning for every minute of departure delay, the arrival delay increases by 17.2 minutes on average.

Finally, let’s visualize the relationship between departure delay and arrival delay, along with the regression line from our linear model.

# super impose lm line on scatter plot using seaborn
sns.lmplot(x="departure_delay", y="arrival_delay", data=df, line_kws={'color': 'red'})
plt.title("Arrival Delay vs Departure Delay with Regression Line")
plt.xlabel("Departure Delay (minutes)")
plt.ylabel("Arrival Delay (minutes)")
plt.show()

No surprise here - there is a positive correlation between departure delay and arrival delay. The regression line shows that as departure delays increase, arrival delays tend to increase as well.

Conclusion

In this post, we explored the QVA (Query, Visualize, Analyze) workflow using Mode. We started by querying flight data using SQL, visualized the results with a bar chart, and then performed advanced analysis using Python to build a linear regression model. Mode’s integration of SQL and Python makes it a powerful tool for data analysis and visualization.

How does this work?

The mileage planner uses the Largest Remainder Method to efficiently manage and prioritize daily mileage allocations. It starts by calculating the base mileage for each day, then applies adjustments based on the selected day types (Easy, Workout) and distribution settings. To ensure integer mileages, it rounds down the calculated values and distributes the remaining “remainder” miles to the days with the largest fractional parts, ensuring the total weekly mileage is exactly met while maintaining the intended distribution.

However, we have to account for the long run day, which is set to a fixed percentage of the total weekly mileage. Thus, long run day mileage is calculated first, and the remaining mileage is distributed among the other days using the Largest Remainder Method. Let’s do an example:

1. Set Weekly Mileage: Suppose the total weekly mileage is set to 32 miles and we have no workouts.
2. Calculate Long Run Mileage: If the long run is set to 25% of the total, then the long run mileage is 0.25 * 32 = 8 miles.
3. Distribute Remaining Mileage: The remaining mileage is 32 - 8 = 24 miles, which needs to be distributed over the other 5 days.
4. Base Mileage Calculation: The base mileage for each of the 5 days is 24 / 5 = 4.8 miles.
5. Apply Day Type Adjustments: If we have 4.8 miles per day we must take the floor of that (4 miles) and allocate the remaining 0.8 miles to the days with the largest fractional parts.
6. Final Allocation: The final allocation would be:
   • Long Run: 8 miles
   • Day 1: 5 miles (4 + 1 from remainder)
   • Day 2: 5 miles (4 + 1 from remainder)
   • Day 3: 5 miles (4 + 1 from remainder)
   • Day 4: 5 miles (4 + 1 from remainder)
   • Day 5: 4 miles (4 + 0 from remainder)
7. The Final Schedule:
   • Sunday Long Run: 8 miles
   • Saturday: 0 miles
   • Friday: 4 miles
   • Thursday: 5 miles
   • Wednesday: 5 miles
   • Tuesday: 5 miles
   • Monday: 5 miles

In order to buy runs, you need to buy barrels.

People who run ball clubs, they think in terms of buying players. Your goal shouldn’t be to buy players, your goal should be to buy wins. And in order to buy wins, you need to buy runs. - Peter Brand (Jonah Hill portraying Paul DePodesta), Moneyball (2011)

In order to buy runs, you need to buy barrels. Barrels are a highly sought after batted ball event in baseball, contributing significantly to a team’s offensive success. A barrel is defined as a batted ball with an exit velocity of at least 98 mph and a launch angle between 26 and 30 degrees, or with higher exit velocities for slightly different launch angles. Barrels are known for their high likelihood of resulting in extra-base hits, including home runs.

Code

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
import warnings

from sklearn.impute import SimpleImputer
from sklearn.model_selection import train_test_split
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.metrics import confusion_matrix, log_loss, ConfusionMatrixDisplay, roc_curve, roc_auc_score, RocCurveDisplay
from sklearn.model_selection import KFold, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import RobustScaler

warnings.filterwarnings('ignore')
sns.set_theme(style="whitegrid", palette="deep")
pd.set_option('display.max_columns', None)

df = pd.read_csv("team-games-2023-2025-with-runs.csv")
# convert "Oakland Athletics" to "Athletics"
df["team_name"] = df["team_name"].str.replace("Oakland Athletics", "Athletics")
sns.barplot(data=df, x="barrels_total", y="runs_scored")
plt.xlabel("Total Barrels in Game")
plt.ylabel("Runs Scored in Game")
plt.show()

To visualize their impact, let’s look at the relationship between the total number of barrels in a game and the runs scored in that game from the 2023 to 2025 MLB seasons. Observe Figure 1. In games where teams hit more barrels, they tend to score more runs. At 0 barrels teams average around 2 runs, while at 2 barrels, the average runs scored almost doubles to around 4 runs. This trend continues, with teams scoring even more runs as the number of barrels increases. This visualization underscores the importance of barrels in contributing to a team’s offensive output and ultimately winning games.

In addition to runs scored, barrels indicate overall offensive performance. In Figure 2, we visualize the expected weighted on-base average (xwOBA) based on contact quality: barrels, solid contact, and poor contact. Barrels (in blue) have significantly higher xwOBA values compared to solid contact (in green) and poor contact (in orange). There’s probably some overlap between the three groups because xwOBA includes walks and strikouts, which are not directly related to batted ball quality. However, the distinction is still clear: barrels lead to much better offensive outcomes than other types of contact.

Code

df_barrels = pd.read_csv("barrels-2023-2025.csv")
df_barrels["barrel"] = 1
df_barrels["contact_quality"] = "barrel"

df_weak = pd.read_csv("poor-contact-2023-2025.csv")
df_weak["barrel"] = 0
df_weak["contact_quality"] = "poor"

df_solid = pd.read_csv("solid-contact-2023-2025.csv")
df_solid["barrel"] = 0
df_solid["contact_quality"] = "solid"

df_bbe = pd.concat([df_barrels, df_weak, df_solid], ignore_index=True)
sns.kdeplot(df_bbe, x="estimated_woba_using_speedangle", hue="contact_quality", fill=True, common_norm=False, alpha=0.5)
# rename legend
plt.legend(title="Contact Quality", labels=["Solid Contact", "Poor Contact", "Barrel"])

So this begs the question: how can teams increase their barrel counts? One approach is to analyze the factors that contribute to successful barrel outcomes. By leveraging machine learning techniques, teams can identify key features that influence barrel production and optimize their strategies accordingly.

How to Find Barrels

Statcast defines a barrel as a batted ball with an exit velocity of at least 98 mph and a launch angle between 26 and 30 degrees, or with higher exit velocities for slightly different launch angles. If we want to find barrels, we first need to understand what differentiates them from other types of batted balls. Let’s visualize batted balls based on their launch speed and launch angle, categorized by contact quality: barrels, solid contact, and poor contact. This will help us see how barrels stand out in terms of these two key metrics.

Code

sns.scatterplot(data=df_bbe, x="launch_speed", y="launch_angle", hue="contact_quality", alpha=0.5)

Figure 3 shows a scatter plot of batted balls categorized by contact quality. Barrels (in blue) are clustered in a specific region characterized by high launch speeds and optimal launch angles, while solid contact and poor contact batted balls are more dispersed across the plot. This visualization highlights the distinct characteristics of barrels compared to other types of contact.

To determine barrels, we can use machine learning classification techniques. By training a model on features such as bat speed, attack angle, swing length, and other relevant metrics, we can predict whether a batted ball will be a barrel or not. While outcome statistics like wOBA are useful, they are not directly used in the classification model since they are results of the batted ball rather than predictors.

# batting features only
features = ["bat_speed", "attack_angle", "swing_length", "attack_direction", 
            "swing_path_tilt", "intercept_ball_minus_batter_pos_x_inches",
            "intercept_ball_minus_batter_pos_y_inches", "stand", "age_bat",
            "n_thruorder_pitcher", "inning", "balls", "strikes", "pitch_number"]

dataset = df_bbe[features + ["barrel"]].copy()
dataset["barrel"] = pd.factorize(dataset["barrel"])[0]
dataset["stand"] = pd.factorize(dataset["stand"])[0]
X = dataset[features]
y = dataset["barrel"]
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)

# modeling
pip = Pipeline([
    ("imputer", SimpleImputer()),
    ("scaler", RobustScaler()),
    ("classifier", HistGradientBoostingClassifier(random_state=42, class_weight="balanced"))
])
pip.fit(X_train, y_train)
y_pred = pip.predict(X_val)
score = pip.score(X_val, y_val)
y_proba = pip.predict_proba(X_val)
print(f"Validation score (Accuracy): {score:.4f}")
print(f"Log Loss: {log_loss(y_val, y_proba):.4f}")

kf = KFold(n_splits=5, shuffle=True, random_state=42)
cv_scores = cross_val_score(pip, X_train, y_train, cv=kf, scoring='balanced_accuracy', n_jobs=-1)
print(f"Cross-validation scores: {cv_scores}")
print(f"Mean CV accuracy: {cv_scores.mean()}")

Validation score (Accuracy): 0.6564
Log Loss: 0.6006
Cross-validation scores: [0.66854507 0.67285075 0.67464693 0.66929524 0.6735115 ]
Mean CV accuracy: 0.6717698965985912

Just on batting features alone, we can achieve a validation accuracy of 66%. The average cross-validation accuracy is around 67%. While not perfect, this model provides a better-than-random ability to classify barrels based on batting metrics.

Now it takes two to tango. We should also consider the pitcher’s influence on barrel outcomes. By incorporating pitching features such as pitch type, velocity, spin rate, and movement, we can enhance our model’s ability to predict barrels. Combining both batting and pitching features provides a more comprehensive view of the factors that contribute to barrel production.

# batting and pitching features only
features = ["batter", "pitcher", "bat_speed", "attack_angle", "swing_length", "attack_direction", "swing_path_tilt", "intercept_ball_minus_batter_pos_x_inches",
            "intercept_ball_minus_batter_pos_y_inches", "stand", "age_bat",
            "n_thruorder_pitcher", "inning", "balls", "strikes", "pitch_number", 
            "release_speed", "release_pos_x", "release_pos_z", "p_throws", "zone", "vx0", "vy0", "vz0", "ax", "ay", "az", "release_pos_y", "pitch_type", "pitch_number", "age_pit", "api_break_z_with_gravity", "api_break_x_arm", "api_break_x_batter_in",
            "arm_angle", "zone", "effective_speed", "release_spin_rate", "release_extension"]

dataset = df_bbe[features + ["barrel"]].copy()
dataset["barrel"] = pd.factorize(dataset["barrel"])[0]

categorical_features = ["stand", "p_throws", "pitch_type"]
dataset_one_hot = pd.get_dummies(dataset, columns=categorical_features, drop_first=True)

y = dataset_one_hot["barrel"]
X = dataset_one_hot.drop("barrel", axis=1)
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)

# %% modeling
pip = Pipeline([
    ("imputer", SimpleImputer()),
    ("scaler", RobustScaler()),
    ("classifier", HistGradientBoostingClassifier(random_state=42, class_weight="balanced"))
])
pip.fit(X_train, y_train)
y_pred = pip.predict(X_val)
score = pip.score(X_val, y_val)
y_proba = pip.predict_proba(X_val)
print(f"Validation score (Accuracy): {score:.4f}")
print(f"Log Loss: {log_loss(y_val, y_proba):.4f}")

kf = KFold(n_splits=5, shuffle=True, random_state=42)
cv_scores = cross_val_score(pip, X_train, y_train, cv=kf, scoring='balanced_accuracy', n_jobs=-1)
print(f"Cross-validation scores: {cv_scores}")
print(f"Mean CV accuracy: {cv_scores.mean()}")

Validation score (Accuracy): 0.6737
Log Loss: 0.5821
Cross-validation scores: [0.68336082 0.68811475 0.68566822 0.68072519 0.68566854]
Mean CV accuracy: 0.6847075037611322

With both batting and pitching features, the validation accuracy improves to 67% and the average cross-validation accuracy increases to around 68%. This is effectively a 1% improvement over batting features alone. There is some added value but not a huge leap. What would be interesting is if we could use the entire bat trajectory data to further improve classification, but that is a topic for another day.

Model Evaluation

I would be remiss if I did not include some model evaluation metrics. First, let’s look at the confusion matrix to see how well our model is classifying barrels versus non-barrels.

Code

y_pred = pip.predict(X_val)
cm = confusion_matrix(y_val, y_pred)

cm_display = ConfusionMatrixDisplay(cm).plot()
plt.grid(False)

The majority of predictions are correct. There are a lot of false negatives. This indicates that the model is struggling to identify barrels when they do occur. Although there’s a great deal of data imbalance (many more non-barrels than barrels). In such cases, accuracy alone can be misleading. Therefore, let’s also look at the ROC curve to evaluate the model’s performance across different classification thresholds.

Code

y_score = pip.decision_function(X_val)
fpr, tpr, _ = roc_curve(y_val, y_score, pos_label=pip.classes_[1])
roc_display = RocCurveDisplay(fpr=fpr, tpr=tpr).plot()
# area under the curve
auc = roc_auc_score(y_val, y_score)
plt.title(f"ROC Curve (AUC = {auc:.4f})");

When observing the ROC curve, we see the model performing better than random guessing. The area under the curve (AUC) is a useful metric for summarizing the model’s performance across all classification thresholds. An AUC of 0.75 indicates that the model has a good ability to distinguish between barrels and non-barrels across various thresholds.

Who Should Find Barrels?

Finally, let’s look at which teams are generating the most barrels on average per game. This can provide insights into which teams are effectively leveraging barrels to enhance their offensive performance.

from IPython.display import Markdown
from tabulate import tabulate

tbl = df.groupby("team_name")["barrels_total"].mean().sort_values(ascending=False)
tbl_df = pd.DataFrame(tbl).reset_index()
tbl_df.index += 1
tbl_df.columns = ["Team", "Avg Barrels per Game"]
Markdown(tabulate(tbl_df.round(4), headers="keys"))

When looking at Figure 6, it is apparent why BaseballSavant lists barrels per plate appearance. Calculating average barrels per game is too granular where difference between teams is minimal. However, barrels per game still shows some trends among teams. For example, the Braves, Yankees, and Dodgers being in the top 3 checks out. Additionally, the Guardians, Nationals, and Reds in the bottome 3 also makes sense.

The Guardians are an interesting case study. Despite boasting the lowest barrel rate in 2025, they still found themselves in the playoffs. So how did they do it? Being good at pitching always help. Exceptional fielding also plays a role. But one metric the Guardians excel at is maximize their Pull AIR %. In 2025, 21.6% of their batted balls were pulled and either a fly ball, line drive, or pop up. This was the second highest in MLB, behind the Chicago Cubs.

This strikes me as interesting because a low barrel rate with a high Pull AIR % seems counterintuitive. However, it just goes to show that there are multiple ways to win in baseball. The Guardians found a way that worked for them. They are not sluggers but opportunists.

Take a look at the Guardians’ leverage-based run value by batted ball type in 2025. All batters produced negative run values. But observe the “+/- Due To Leverage” column. For all but 2 players, the leverage adjustment was positive on swings. This means that the Guardians were able to get the most out of their batted balls in high-leverage situations, even if those batted balls were not barrels. By focusing on situational hitting and maximizing the impact of their contact, the Guardians were able to overcome their low barrel rate and still find success.

Introduction

In this article, we chime in on the current discourse surrounding MLB expansion and realignment. Recently, Rob Manfred mentioned the possibility of adding two more teams to the league. Across social media, fans have expressed their opinions on the matter. I want to explore how graph theory can help visualize the current MLB schedule and how it might change with expansion and realignment.

In college, I majored in math and computer science. While my emphasis was on statistics and machine learning, I always had a keen interest in number theory, graph theory, and combinatorics; in fact, my senior thesis was on fast matrix multiplication. One course I missed out on during my undergrad was a graph theory course that was offered at Harvey Mudd College. Given that this blog serves as a platform for me to explore my interests, I thought it would be fun to apply graph theory concepts to MLB scheduling.

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    while queue:
        vertex = queue.popleft()
        if vertex not in visited:
            print("Visiting:", vertex)
            visited.add(vertex)
            for neighbor in graph[vertex]:
                if neighbor not in visited:
                    queue.append(neighbor)

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    if start not in visited:
        print("Visiting:", start)
        visited.add(start)
        for neighbor in graph[start]:
            if neighbor not in visited:
                dfs(graph, neighbor, visited)
    return visited

MLB Schedule Represented as a Graph

The MLB schedule can be represented as a graph where each team is a node and each game played between two teams is an edge connecting those nodes. This representation allows us to analyze the schedule using graph algorithms.

Based on Wikipedia, the 2025 MLB schedule consists of 162 games per team, with the following breakdown: - 13 games against each of the 4 divisional opponents (52 games) - 6 or 7 games against each of the 10 other league opponents (62 games) - 6 games against one “geographic” interleague opponent (6 games) - 3 games against the remaining 14 interleague opponents (42 games) Series range from 2 to 4 games, with 3-game series being the most common.

The visualization below shows the graph representation of the MLB schedule. I used NetworkX to create the graph and Matplotlib to visualize it. The nodes are aligned such that they form a circle. They are longitudinally arranged based on their geographical locations. There really is not much to take away from this visualization other than the fact that it shows the complex web of matchups between teams. Consider this an artistic expression.

import pandas as pd
from collections import Counter, defaultdict
import networkx as nx
import matplotlib.pyplot as plt
import plotly.graph_objects as go
import plotly.express as px
import numpy as np
import itertools

team_name_map = {
    'ANA': 'LAA', 'ARI': 'ARI', 'ATL': 'ATL', 'BAL': 'BAL', 'BOS': 'BOS',
    'CHA': 'CWS', 'CHN': 'CHC', 'CIN': 'CIN', 'CLE': 'CLE', 'COL': 'COL',
    'DET': 'DET', 'HOU': 'HOU', 'KCA': 'KC', 'LAN': 'LAD', 'MIA': 'MIA',
    'MIL': 'MIL', 'MIN': 'MIN', 'NYA': 'NYY', 'NYN': 'NYM', 'ATH': 'ATH',
    'PHI': 'PHI', 'PIT': 'PIT', 'SDN': 'SD', 'SEA': 'SEA', 'SFN': 'SF',
    'SLN': 'STL', 'TBA': 'TB', 'TEX': 'TEX', 'TOR': 'TOR', 'WAS': 'WSH'
}

team_logos = {
    'ARI': 'https://upload.wikimedia.org/wikipedia/commons/thumb/a/ac/Arizona_Diamondbacks_logo_teal.svg/330px-Arizona_Diamondbacks_logo_teal.svg.png',
    'ATL': 'https://upload.wikimedia.org/wikipedia/en/f/f2/Atlanta_Braves.svg',
    'BAL': 'https://upload.wikimedia.org/wikipedia/commons/e/e9/Baltimore_Orioles_Script.svg',
    'BOS': 'https://upload.wikimedia.org/wikipedia/en/6/6d/RedSoxPrimary_HangingSocks.svg',
    'CHC': 'https://upload.wikimedia.org/wikipedia/commons/8/80/Chicago_Cubs_logo.svg',
    'CWS': 'https://upload.wikimedia.org/wikipedia/commons/c/c1/Chicago_White_Sox.svg',
    'CIN': 'https://upload.wikimedia.org/wikipedia/commons/0/01/Cincinnati_Reds_Logo.svg',
    'CLE': 'https://upload.wikimedia.org/wikipedia/en/a/a9/Guardians_winged_%22G%22.svg',
    'COL': 'https://upload.wikimedia.org/wikipedia/en/c/c0/Colorado_Rockies_full_logo.svg',
    'DET': 'https://upload.wikimedia.org/wikipedia/commons/e/e3/Detroit_Tigers_logo.svg',
    'HOU': 'https://upload.wikimedia.org/wikipedia/commons/6/6b/Houston-Astros-Logo.svg',
    'KC': 'https://upload.wikimedia.org/wikipedia/commons/7/78/Kansas_City_Royals_Primary_Logo.svg',
    'LAA': 'https://upload.wikimedia.org/wikipedia/commons/8/8b/Los_Angeles_Angels_of_Anaheim.svg',
    'LAD': 'https://upload.wikimedia.org/wikipedia/commons/0/0e/Los_Angeles_Dodgers_Logo.svg',
    'MIA': 'https://upload.wikimedia.org/wikipedia/en/f/fd/Marlins_team_logo.svg',
    'MIL': 'https://upload.wikimedia.org/wikipedia/en/b/b8/Milwaukee_Brewers_logo.svg',
    'MIN': 'https://upload.wikimedia.org/wikipedia/commons/thumb/1/17/Minnesota_Twins_New_Logo.svg/250px-Minnesota_Twins_New_Logo.svg.png',
    'NYM': 'https://upload.wikimedia.org/wikipedia/en/thumb/7/7b/New_York_Mets.svg/250px-New_York_Mets.svg.png',
    'NYY': 'https://upload.wikimedia.org/wikipedia/commons/f/fe/New_York_Yankees_Primary_Logo.svg',
    'ATH': 'https://upload.wikimedia.org/wikipedia/commons/thumb/b/b8/Athletics_logo.svg/330px-Athletics_logo.svg.png',
    'PHI': 'https://upload.wikimedia.org/wikipedia/en/f/f0/Philadelphia_Phillies_%282019%29_logo.svg',
    'PIT': 'https://upload.wikimedia.org/wikipedia/commons/8/81/Pittsburgh_Pirates_logo_2014.svg',
    'SD': 'https://upload.wikimedia.org/wikipedia/commons/thumb/e/e2/SD_Logo_Brown.svg/250px-SD_Logo_Brown.svg.png',
    'SF': 'https://upload.wikimedia.org/wikipedia/en/5/58/San_Francisco_Giants_Logo.svg',
    'SEA': 'https://upload.wikimedia.org/wikipedia/en/6/6d/Seattle_Mariners_logo_%28low_res%29.svg',
    'STL': 'https://upload.wikimedia.org/wikipedia/en/9/9d/St._Louis_Cardinals_logo.svg',
    'TB': 'https://upload.wikimedia.org/wikipedia/commons/5/55/Tampa_Bay_Rays_Logo.svg',
    'TEX': 'https://upload.wikimedia.org/wikipedia/commons/c/c7/Texas_Rangers_logo.svg',
    'TOR': 'https://upload.wikimedia.org/wikipedia/en/c/cc/Toronto_Blue_Jay_Primary_Logo.svg',
    'WSH': 'https://upload.wikimedia.org/wikipedia/commons/a/a3/Washington_Nationals_logo.svg',
    'POR': 'https://upload.wikimedia.org/wikipedia/commons/a/a6/Major_League_Baseball_logo.svg',
    'NSH': 'https://upload.wikimedia.org/wikipedia/commons/a/a6/Major_League_Baseball_logo.svg',
}


# Load the schedule data
df = pd.read_csv("2025schedule.csv")
df['Visitor'] = df['Visitor'].map(team_name_map)
df['Home'] = df['Home'].map(team_name_map)
df.dropna(subset=['Visitor', 'Home'], inplace=True)
games_from_df = df[['Visitor', 'Home']].values.tolist()
teams = list(pd.concat([df['Visitor'], df['Home']]).unique())

# Make a graph where teams are nodes and games are edges
G = nx.Graph()

# Use the canonical team names from team_name_map values
team_longitudes = {
    "BOS": -71.0589, "NYY": -73.92, "NYM": -73.84, "PHI": -75.16, "BAL": -76.61,
    "WSH": -77.03, "PIT": -79.99, "TOR": -79.38, "TB": -82.65, "MIA": -80.19,
    "ATL": -84.38, "CLE": -81.69, "CIN": -84.51, "DET": -83.04, "CWS": -87.62,
    "CHC": -87.62, "STL": -90.19, "MIL": -87.90, "MIN": -93.26, "KC": -94.48,
    "HOU": -95.36, "TEX": -96.79, "COL": -104.99, "ARI": -112.07, "LAD": -118.24,
    "LAA": -117.88, "SD": -117.16, "SF": -122.38, "ATH": -122.27, "SEA": -122.33
}

# Sort teams by longitude (East to West)
sorted_teams = sorted(teams, key=lambda team: team_longitudes[team])

# Create a graph
G = nx.Graph()

# Assign circular positions based on the sorted geographical order
team_positions = {}
num_teams = len(sorted_teams)
angle_step = 2 * np.pi / num_teams

for i, team in enumerate(sorted_teams):
    # Calculate angle and position
    angle = i * angle_step
    x = np.cos(angle)
    y = np.sin(angle)
    team_positions[team] = (x, y)
    # Add node with its calculated position
    G.add_node(team, pos=(x, y))

# Add edges
game_counts = Counter(tuple(sorted(game)) for game in games_from_df)
for (team1, team2), count in game_counts.items():
    if team1 in G.nodes and team2 in G.nodes:
        G.add_edge(team1, team2, weight=count)

# Draw the graph
# --- Visualization ---
plt.figure(figsize=(8, 8))
ax = plt.gca()
ax.set_title("MLB Team Matchups (Geographically Ordered Circle)", fontsize=16)

# Extract positions for drawing
pos = nx.get_node_attributes(G, 'pos')
# pos = nx.spring_layout(G, weight='weight', iterations=50, seed=47)

# Draw the graph
nx.draw_networkx_nodes(G, pos, node_color='skyblue', node_size=750, alpha=0.8)
nx.draw_networkx_edges(G, pos, edge_color='gray', width=1.0, alpha=0.6)
nx.draw_networkx_labels(G, pos, font_size=10, font_weight='bold')

# Remove axes for a cleaner look
ax.margins(0.1)
plt.axis("off")
plt.tight_layout()
plt.show()

pos = nx.spring_layout(G, weight='weight', iterations=10000, seed=47)

# Set the calculated positions as a node attribute
nx.set_node_attributes(G, pos, 'pos')

# --- Visualization with Plotly ---
fig_data = []

# --- Create Edge Traces by Color with Hover Text ---
# Group edges by weight (number of games) to color them
edges_by_weight = defaultdict(lambda: {'x': [], 'y': [], 'text': []})
for edge in G.edges(data=True):
    weight = edge[2].get('weight', 1)
    x0, y0 = G.nodes[edge[0]]['pos']
    x1, y1 = G.nodes[edge[1]]['pos']
    edges_by_weight[weight]['x'].extend([x0, x1, None])
    edges_by_weight[weight]['y'].extend([y0, y1, None])

# Define a colorscale
# Define a colorscale for the edges
min_weight = min(edges_by_weight.keys()) if edges_by_weight else 1
max_weight = max(edges_by_weight.keys()) if edges_by_weight else 1
base_colorscale = px.colors.sequential.Blues

# Create a discrete color map
unique_weights = sorted(list(edges_by_weight.keys()))
num_unique_weights = len(unique_weights)
if num_unique_weights > 1:
    color_map = {weight: base_colorscale[int(i * (len(base_colorscale) - 1) / (num_unique_weights - 1))] for i, weight in enumerate(unique_weights)}
else:
    color_map = {unique_weights[0]: base_colorscale[5]} if unique_weights else {}

for weight, a in sorted(edges_by_weight.items()):
    color = color_map.get(weight, '#888888') # Default color if weight not in map
    edge_trace = go.Scatter(x=a['x'], y=a['y'], line=dict(width=2, color=color), hoverinfo='none', mode='lines')
    fig_data.append(edge_trace)

edge_hover_x = []
edge_hover_y = []
edge_hover_text = []

for edge in G.edges(data=True):
    x0, y0 = G.nodes[edge[0]]['pos']
    x1, y1 = G.nodes[edge[1]]['pos']
    weight = edge[2].get('weight', 1)
    # Position the hover point at the midpoint of the edge
    edge_hover_x.append((x0 + x1) / 2)
    edge_hover_y.append((y0 + y1) / 2)
    edge_hover_text.append(f'{edge[0]} vs {edge[1]}: {weight} games')

# This trace holds the hover text and has invisible markers
edge_hover_trace = go.Scatter(
    x=edge_hover_x,
    y=edge_hover_y,
    mode='markers',
    hoverinfo='text',
    text=edge_hover_text,
    marker=dict(size=20, color='rgba(0,0,0,0)') # Invisible markers with a larger hover area
)
fig_data.append(edge_hover_trace)

discrete_colorscale_for_bar = []
if num_unique_weights > 0:
    for i, weight in enumerate(unique_weights):
        color = color_map.get(weight, '#888888')
        # Define start and end points for this color's block in the bar (on a 0-1 scale)
        start_norm = i / num_unique_weights
        end_norm = (i + 1) / num_unique_weights
        discrete_colorscale_for_bar.append([start_norm, color])
        discrete_colorscale_for_bar.append([end_norm, color])

# The colorbar needs to map values to this new 0-1 scale.
# We'll place the tick labels for our unique_weights in the center of each color block.
tickvals_for_bar = [ (i + 0.5) / num_unique_weights for i in range(num_unique_weights) ]
ticktext_for_bar = [str(w) for w in unique_weights]

colorbar_trace = go.Scatter(x=[None], y=[None], mode='markers', marker=dict(
    # The dummy `color` value is irrelevant because we control the scale with cmin/cmax
    color=[0.5],
    # Here is our custom discrete colorscale
    colorscale=discrete_colorscale_for_bar,
    # We are now working in a normalized 0-1 space for the colorbar
    cmin=0,
    cmax=1,
    showscale=True,
    colorbar=dict(
        thickness=15,
        title='Games Played',
        xanchor='left',
        # Place tick labels at the center of each color block
        tickvals=tickvals_for_bar,
        ticktext=ticktext_for_bar,
        # This makes the color bar look more like distinct bins
        outlinewidth=0
    )),
    hoverinfo='none'
)
fig_data.append(colorbar_trace)
# --- Create Node Trace ---
node_x = []
node_y = []
for node in G.nodes():
    x, y = G.nodes[node]['pos']
    node_x.append(x)
    node_y.append(y)
    

node_adjacencies = []
node_text = []
for node, adjacencies in G.adjacency():
    num_connections = len(adjacencies)
    node_adjacencies.append(num_connections)
    node_text.append(f'Team: {node}')

node_trace = go.Scatter(
    x=node_x, y=node_y,
    mode='markers',
    hoverinfo='text',
    hovertext=node_text,
    marker=dict(
        size=35, # Make the hover area large
        color='rgba(255, 255, 255, 1)' # Make the markers invisible
    )
)
fig_data.append(node_trace)

layout_images = []
# Calculate the range of coordinates to dynamically size logos
x_range = max(node_x) - min(node_x) if node_x else 1
y_range = max(node_y) - min(node_y) if node_y else 1
logo_size_x = x_range * 0.08  # Adjust the multiplier as needed
logo_size_y = y_range * 0.08

for node in G.nodes():
    x, y = G.nodes[node]['pos']
    logo_url = team_logos.get(node)
    if logo_url:
        layout_images.append(dict(source=logo_url, xref="x", yref="y", x=x, y=y, sizex=logo_size_x, sizey=logo_size_y, xanchor="center", yanchor="middle", layer="above"))

# --- Create the Figure ---
fig = go.Figure(
    data=fig_data,
    layout=go.Layout(
        title='<br>MLB 2025 Schedule Matchups',
        showlegend=False,
        hovermode='closest',
        margin=dict(b=20,l=5,r=5,t=60),
        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
        height=600, width=800,
        images=layout_images,
    ),
)
fig.show()

# --- Team Data ---
# A dictionary to map old abbreviations to modern ones
team_name_map = {
    'ANA': 'LAA', 'ARI': 'ARI', 'ATL': 'ATL', 'BAL': 'BAL', 'BOS': 'BOS',
    'CHA': 'CWS', 'CHN': 'CHC', 'CIN': 'CIN', 'CLE': 'CLE', 'COL': 'COL',
    'DET': 'DET', 'HOU': 'HOU', 'KCA': 'KC', 'LAN': 'LAD', 'MIA': 'MIA',
    'MIL': 'MIL', 'MIN': 'MIN', 'NYA': 'NYY', 'NYN': 'NYM', 'ATH': 'OAK',
    'PHI': 'PHI', 'PIT': 'PIT', 'SDN': 'SD', 'SEA': 'SEA', 'SFN': 'SF',
    'SLN': 'STL', 'TBA': 'TB', 'TEX': 'TEX', 'TOR': 'TOR', 'WAS': 'WSH'
}

# Longitudes for geographical sorting (East to West)
team_longitudes = {
    "BOS": -71.0589, "NYY": -73.92, "NYM": -73.84, "PHI": -75.16, "BAL": -76.61,
    "WSH": -77.03, "PIT": -79.99, "TOR": -79.38, "TB": -82.65, "MIA": -80.19,
    "ATL": -84.38, "CLE": -81.69, "CIN": -84.51, "DET": -83.04, "CWS": -87.62,
    "CHC": -87.62, "STL": -90.19, "MIL": -87.90, "MIN": -93.26, "KC": -94.48,
    "HOU": -95.36, "TEX": -96.79, "COL": -104.99, "ARI": -112.07, "LAD": -118.24,
    "LAA": -117.88, "SD": -117.16, "SF": -122.38, "ATH": -122.27, "SEA": -122.33,
    "NSH": -86.78,  # Nashville
    "POR": -122.67 # Portland
}

# --- Simulate 32-Team League with 8 Divisions ---
# 1. Define the new 8-division structure (4 teams per division)
divisions = {
    "AL East": ["BAL", "BOS", "NYY", "WSH"],
    "AL Central": ["CWS", "CLE", "DET", "TOR"],
    "AL South": ["HOU", "KC", "COL", "TEX"],
    "AL West": ["LAA", "ATH", "SEA", "POR"],
    "NL East": ["NYM", "PHI", "CIN", "PIT"],
    "NL Central": ["CHC", "MIL", "STL", "MIN"],
    "NL South": ["MIA", "TB", "NSH", "ATL"],
    "NL West": ["LAD", "SD", "SF", "ARI"]
}

leagues = {
    "AL": divisions["AL East"] + divisions["AL Central"] + divisions["AL South"] + divisions["AL West"],
    "NL": divisions["NL East"] + divisions["NL Central"] + divisions["NL South"] + divisions["NL West"]
}

# 2. Simulate a full schedule based on the new structure
all_games = []
all_teams = leagues["AL"] + leagues["NL"]

# Scheduling formula for 162 games:
# - 14 games vs. 3 divisional opponents (42 games)
# - 6 games vs. 12 other league opponents (72 games)
# - 3 games vs. 16 interleague opponents (48 games)
# Use itertools.combinations to handle each pair only once, which is cleaner
# and avoids the double-counting issue with odd numbers of games.
for team1, team2 in itertools.combinations(all_teams, 2):
    # Determine the relationship between team1 and team2
    team1_league = "AL" if team1 in leagues["AL"] else "NL"
    team2_league = "AL" if team2 in leagues["AL"] else "NL"

    team1_division = next(name for name, teams in divisions.items() if team1 in teams)
    team2_division = next(name for name, teams in divisions.items() if team2 in teams)

    if team1_division == team2_division:
        # Divisional opponents play 14 games
        all_games.extend([(team1, team2)] * 14)
    elif team1_league == team2_league:
        # Other intraleague opponents play 6 games
        all_games.extend([(team1, team2)] * 6)
    else:
        # Interleague opponents play 3 games
        all_games.extend([(team1, team2)] * 3)

# --- Create Graph and Circular Layout ---
sorted_teams = sorted(all_teams, key=lambda team: team_longitudes[team])

G = nx.Graph()
num_teams = len(sorted_teams)
angle_step = 2 * np.pi / num_teams

for i, team in enumerate(sorted_teams):
    angle = i * angle_step
    x, y = np.cos(angle), np.sin(angle)
    G.add_node(team, pos=(x, y))

# The game list has duplicates (A vs B and B vs A), so Counter handles it well
game_counts = Counter(tuple(sorted(game)) for game in all_games)
for (team1, team2), count in game_counts.items():
    if G.has_node(team1) and G.has_node(team2):
        G.add_edge(team1, team2, weight=count)

# --- Visualization with Matplotlib ---
plt.figure(figsize=(8, 8))
ax = plt.gca()
ax.set_title("MLB Network with 32 Teams in 8 Divisions (Simulated Schedule)", fontsize=16)

# Extract positions for drawing
pos = nx.get_node_attributes(G, 'pos')

# Draw the graph components
nx.draw_networkx_nodes(G, pos, node_color='skyblue', node_size=750, alpha=0.9)
nx.draw_networkx_edges(G, pos, edge_color='gray', width=1.0, alpha=0.6)
nx.draw_networkx_labels(G, pos, font_size=10, font_weight='bold')

# Remove axes for a cleaner look
plt.axis("off")
plt.tight_layout()
plt.show()

# --- Visualization with Plotly ---
pos = nx.spring_layout(G, weight='weight', iterations=10000, seed=47)

# Set the calculated positions as a node attribute
nx.set_node_attributes(G, pos, 'pos')

fig_data = []

# --- Create Edge Traces by Color with Hover Text ---
edges_by_weight = defaultdict(lambda: {'x': [], 'y': []})
for edge in G.edges(data=True):
    weight = edge[2].get('weight', 1)
    x0, y0 = G.nodes[edge[0]]['pos']
    x1, y1 = G.nodes[edge[1]]['pos']
    edges_by_weight[weight]['x'].extend([x0, x1, None])
    edges_by_weight[weight]['y'].extend([y0, y1, None])

# Define a colorscale for the edges
min_weight = min(edges_by_weight.keys()) if edges_by_weight else 1
max_weight = max(edges_by_weight.keys()) if edges_by_weight else 1
base_colorscale = px.colors.sequential.Blues

# Create a discrete color map
unique_weights = sorted(list(edges_by_weight.keys()))
num_unique_weights = len(unique_weights)
if num_unique_weights > 1:
    color_map = {weight: base_colorscale[int(i * (len(base_colorscale) - 1) / (num_unique_weights - 1))] for i, weight in enumerate(unique_weights)}
else:
    color_map = {unique_weights[0]: base_colorscale[5]} if unique_weights else {}

for weight, a in sorted(edges_by_weight.items()):
    color = color_map.get(weight, '#888888') # Default color if weight not in map
    edge_trace = go.Scatter(x=a['x'], y=a['y'], line=dict(width=2, color=color), hoverinfo='none', mode='lines')
    fig_data.append(edge_trace)

edge_hover_x = []
edge_hover_y = []
edge_hover_text = []

for edge in G.edges(data=True):
    x0, y0 = G.nodes[edge[0]]['pos']
    x1, y1 = G.nodes[edge[1]]['pos']
    weight = edge[2].get('weight', 1)
    # Position the hover point at the midpoint of the edge
    edge_hover_x.append((x0 + x1) / 2)
    edge_hover_y.append((y0 + y1) / 2)
    edge_hover_text.append(f'{edge[0]} vs {edge[1]}: {weight} games')

# This trace holds the hover text and has invisible markers
edge_hover_trace = go.Scatter(
    x=edge_hover_x,
    y=edge_hover_y,
    mode='markers',
    hoverinfo='text',
    text=edge_hover_text,
    marker=dict(size=20, color='rgba(0,0,0,0)') # Invisible markers with a larger hover area
)
fig_data.append(edge_hover_trace)

discrete_colorscale_for_bar = []
if num_unique_weights > 0:
    for i, weight in enumerate(unique_weights):
        color = color_map.get(weight, '#888888')
        # Define start and end points for this color's block in the bar (on a 0-1 scale)
        start_norm = i / num_unique_weights
        end_norm = (i + 1) / num_unique_weights
        discrete_colorscale_for_bar.append([start_norm, color])
        discrete_colorscale_for_bar.append([end_norm, color])

# The colorbar needs to map values to this new 0-1 scale.
# We'll place the tick labels for our unique_weights in the center of each color block.
tickvals_for_bar = [ (i + 0.5) / num_unique_weights for i in range(num_unique_weights) ] if num_unique_weights > 0 else []
ticktext_for_bar = [str(w) for w in unique_weights]

colorbar_trace = go.Scatter(
    x=[None], y=[None], mode='markers', 
    marker=dict(
        color=[0.5],
        colorscale=discrete_colorscale_for_bar,
        cmin=0,
        cmax=1,
        showscale=True,
        colorbar=dict(
            thickness=15,
            title='Games Played',
            xanchor='left',
            tickvals=tickvals_for_bar,
            ticktext=ticktext_for_bar,
            outlinewidth=0
    )),
    hoverinfo='none'
)
fig_data.append(colorbar_trace)

# --- Create Node Trace ---
node_x = []
node_y = []
for node in G.nodes():
    x, y = G.nodes[node]['pos']
    node_x.append(x)
    node_y.append(y)

node_text = []
for node in G.nodes():
    node_text.append(f'Team: {node}')

node_trace = go.Scatter(
    x=node_x, y=node_y,
    mode='markers',
    hoverinfo='text',
    hovertext=node_text,
    marker=dict(
        size=35, # Make the hover area large
        color='rgba(255, 255, 255, 0)' # Make the markers invisible
    )
)
fig_data.append(node_trace)

layout_images = []
# Calculate the range of coordinates to dynamically size logos
x_range = max(node_x) - min(node_x) if node_x else 1
y_range = max(node_y) - min(node_y) if node_y else 1
logo_size_x = x_range * 0.08  # Adjust the multiplier as needed
logo_size_y = y_range * 0.08

for node in G.nodes():
    x, y = G.nodes[node]['pos']
    logo_url = team_logos.get(node)
    if logo_url:
        layout_images.append(dict(source=logo_url, xref="x", yref="y", x=x, y=y, sizex=logo_size_x, sizey=logo_size_y, xanchor="center", yanchor="middle", layer="above"))

# --- Create the Figure ---
fig = go.Figure(
    data=fig_data,
    layout=go.Layout(
        title='<br>MLB 32-Team Expansion Simulation',
        showlegend=False,
        hovermode='closest',
        margin=dict(b=20,l=5,r=5,t=60),
        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
        height=600, width=800,
        images=layout_images,
    ),
)
fig.show()

Conclusion

In the end, what is the Major League Baseball schedule? It’s a historical document, a 162-game compromise cobbled together by tradition, television contracts, and the brute force of geography. It works because it’s always worked. But when you strip away the nostalgia and the seventy-five-dollar parking, when you look at it not as a list of games but as a network, you’re left with a simple mathematical object: a graph.

And like any system, once you see its underlying structure, you can’t help but notice the flaws. They’re no longer just quirks; they’re inefficiencies. The Seattle Mariners’ travel woes aren’t just a logistical headache; on the graph, they’re a grotesquely long edge stretching across half the country, a screamingly obvious point of imbalance. Adding a team in Portland doesn’t just create a fun rivalry; it shortens that edge, creating a tighter, more rational cluster of nodes in the Pacific Northwest. The same goes for Nashville, a move that doesn’t just tap a new market but breaks up the Braves’ regional monopoly, forging new, logical connections in the Southeast.

This is the power of looking at the world through a different lens. It transforms the debate from one of pure opinion—“I think this city deserves a team!”—into a problem of optimization. You’re no longer just adding dots to a map; you’re balancing a network, minimizing the distance between nodes, and engineering more compelling matchups by strengthening local connections. The old men who run baseball can spend the next decade debating expansion in conference rooms, arguing over demographics and media rights. Or they could just run the algorithm. After all, the best path forward is often the shortest one… although Mike Piazza would disagree.

Introduction

Principal component analysis (PCA) applied to Pete Crow-Armstrong. I am willing to bet that every data scientist in an MLB organization has thought of this pun at least once. For good reason: PCA is a powerful tool for dimensionality reduction and feature extraction. In this post, I will walk through the steps of performing PCA on a dataset of Pete Crow-Armstrong’s game-by-game statistics from the 2025 MLB season. Let’s dig into some formalities.

Understanding PCA - the Methodology

To first understand why PCA is useful, we need to understand the curse of dimensionality. Observe Table 1 which shows the exponential growth of possible values with binary variables.

n	Possible Values
1
2
3
…	…
10
20

When , the possible values are 0 or 1. Now, consider a dataset with two binary variables. This dataset can take on four values: (0,0), (0,1), (1,0), and (1,1). As we add more binary variables, the number of possible combinations grows exponentially. For example, with 10 binary variables, there are 1,024 possible combinations. With 20 binary variables, there are 1,048,576 possible combinations. This example illustrates the curse of dimensionality: as the number of dimensions increases, the volume of the space increases so quickly that the available data becomes sparse.

Now consider a dataset with continuous variables for game-by-game statistics. In the statcast era, there are hundreds of statistics available for each player. How do we reduce the number of dimensions while retaining the most important information? PCA transforms the original variables into a new set of variables, called principal components, which are linear combinations of the original variables. The principal components are ordered such that the first component explains the largest amount of variance in the data, the second component explains the second largest amount of variance, and so on. By selecting a subset of the principal components, we can reduce the dimensionality of the data while retaining most of the important information.

Code

import numpy as np
import matplotlib.pyplot as plt

def plot_pca_vectors():
    """
    Generates 2D data, calculates PCA, and plots the data points
    with eigenvectors scaled by eigenvalues overlaid.
    """
    # --- 1. Generate Sample Data ---
    # Use a random seed for reproducibility
    np.random.seed(42)
    
    # Create 200 data points (n=200) with 2 features (p=2)
    # Define a mean to shift the data away from the origin
    mean = [10, 5]
    # Define a covariance matrix that creates a stretched, diagonal cloud of points
    cov = [[5, 4], [4, 5]] 
    X = np.random.multivariate_normal(mean, cov, 200)

    # --- 2. Perform PCA Calculations ---
    
    # Step 2a: Calculate the mean of the data
    data_mean = np.mean(X, axis=0)
    
    # Step 2b: Center the data (though not strictly necessary for covariance calculation with np.cov)
    X_centered = X - data_mean
    
    # Step 2c: Calculate the covariance matrix
    cov_matrix = np.cov(X_centered, rowvar=False)
    
    # Step 2d: Calculate eigenvectors and eigenvalues
    eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)

    # --- 3. Create the Plot ---
    plt.style.use('seaborn-v0_8-whitegrid')
    fig, ax = plt.subplots(figsize=(7, 5))

    # Plot the original data points
    ax.scatter(X[:, 0], X[:, 1], alpha=0.6, label='Data Points')
    
    # Plot the mean of the data
    ax.scatter(data_mean[0], data_mean[1], color='red', s=150, zorder=5, label='Mean')

    # --- 4. Plot the Eigenvectors ---
    # The eigenvectors are the directions.
    # The eigenvalues are the magnitude (variance) in those directions.
    # We scale the vectors by the sqrt of the eigenvalue to represent standard deviation.
    
    print("Eigenvalues:", eigenvalues)
    print("Eigenvectors:\n", eigenvectors)

    # Plot each eigenvector as a vector originating from the mean
    for i in range(len(eigenvalues)):
        eigenvec = eigenvectors[:, i]
        # The vector's components are scaled by the sqrt of the eigenvalue
        scaled_vec = eigenvec * np.sqrt(eigenvalues[i]) * 2 # Multiply by 2 for better visibility
        
        # Use ax.quiver to draw an arrow
        # The arguments are: start_x, start_y, direction_x, direction_y
        ax.quiver(data_mean[0], data_mean[1], scaled_vec[0], scaled_vec[1],
                  color='g' if i == 0 else 'm', # Different colors for PC1 and PC2
                  angles='xy', scale_units='xy', scale=1, 
                  width=0.01,
                  label=f'PC{i+1} (λ={eigenvalues[i]:.2f})')

    # --- 5. Finalize the Plot ---
    ax.set_aspect('equal', adjustable='box') # Ensures vectors that are orthogonal appear at 90 degrees
    ax.set_title('Scatter Plot of Data with PCA Eigenvectors', fontsize=16)
    ax.set_xlabel('Feature 1', fontsize=12)
    ax.set_ylabel('Feature 2', fontsize=12)
    ax.legend()
    ax.grid(True)
    plt.show()

# Run the function
plot_pca_vectors()

Eigenvalues: [0.9302595  8.25726304]
Eigenvectors:
 [[-0.71461768 -0.69951524]
 [ 0.69951524 -0.71461768]]

Let be an data matrix, where is the number of observations and is the number of variables. PCA finds a vector such that the projection of the data onto maximizes the variance; are the principal components. We’re mapping the original data to a new coordinates . So a data point maps to by finding . Since we’re dealing with matrices, we can express this transformation as , resulting in a new matrix which is more compact than . How is found? We use eigendecomposition. Observe Figure 1 which shows the original data and the principal components. We are treading in linear algebra territory, and, admittedly, its been several years since I took linear algebra, so I encourage you all to read the wikipedia page. This is exactly that computer science majors mean when they say “linear algebra is a useful math course”.

Understanding PCA - the Player

Let’s start by looking at the data. We will use Pete Crow-Armstrong’s game-by-game statistics from the 2025 MLB season. The data is sourced from Baseball Savant’s search tool. The query I used grabs traditional statistics, expected statistics, and swing mechanic statistics. This video also serves as good tutorial for understanding how to use PCA (he also uses Pete Crow-Armstrong as an example). Some of my results below are inspired by this video but all code, analysis, and visualizations are my own. We also expand upon his analysis by including statcast metrics.

from pybaseball import statcast_batter
from pybaseball import playerid_lookup
import pandas as pd
import seaborn as sns
sns.set_theme(style="whitegrid", palette="pastel")
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from scipy import stats
from factor_analyzer.rotator import Rotator

df = pd.read_csv("savant_data.csv")
print(f"Number of columns: {len(df.columns.to_list())}")

Number of columns: 78

The original data contains 78 columns. Our goal is to reduce this to fewer than 10 columns. It would be impractical to plot scatter plots for every pair of variables to find correlations. Instead, let’s use a heatmap to visualize the correlations between the variables, as shown in Figure 2.

Code

# select relevant features
features = ["ba", "iso", "slg", "woba", "xwoba", "xba", "hits", "launch_speed", "launch_angle", "velocity", 
            "whiffs", "bat_speed", "swing_length", "singles", "doubles", "triples", "hrs", "so", "bb",
            "obp", "barrels_total", "xobp", "xslg", "attack_angle", "attack_direction", "swing_path_tilt",
            "rate_ideal_attack_angle"]
X = df[features]
X = X.dropna()
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# heatmap
corr = X.corr()
mask = np.triu(np.ones_like(corr, dtype=bool))
f, ax = plt.subplots(figsize=(9, 7))
cmap = sns.diverging_palette(230, 20, as_cmap=True)
sns.heatmap(corr, mask=mask, cmap=cmap, vmax=1.0, center=0,
            square=True, linewidths=.5, cbar_kws={"shrink": .5})

Observe how some variables, such as slg, woba, and xwoba, are highly correlated. Meanwhile, variables like strikeouts and whiffs show weaker or even opposite correlations with these metrics. If we were to plug this entire dataset into a regression model, such as linear regression, we might run into issues with multicollinearity.

from IPython.display import Markdown
from tabulate import tabulate

# Perform PCA with 2 components for exploration
pca = PCA(n_components=2)
pca.fit(X_scaled)

loadings = pca.components_.T * np.sqrt(pca.explained_variance_)
loadings_df = pd.DataFrame(loadings, 
                           columns=[f'PC{i+1}' for i in range(2)], 
                           index=X.columns)

# Create the Communalities table
communalities = pd.DataFrame({
    # The 'Initial' communality is always 1.0 for PCA
    'Initial': 1.0,
    
    # 'Extraction' is the sum of the squared loadings for each variable
    'Extraction': (loadings_df ** 2).sum(axis=1)
})
communalities.index.name = 'Features'

# sort by Extraction value descending
communalities = communalities.sort_values(by='Extraction', ascending=False)
Markdown(tabulate(communalities.round(3), headers='keys'))

Determining the Optimal Number of Components

Similarly to k-means clustering, we can use the elbow method to determine the optimal number of components for PCA. The idea is to fit the PCA model with the number of components equal to the number of features, and then plot the explained variance to see where the “elbow” point is. Figure 3 shows the scree plot. As a general rule of thumb, we want to select eigenvalues greater than 1.0.

Code

pca = PCA()
pca.fit(X_scaled)

# Display explained variance ratio as a table
explained_var_df = pd.DataFrame({
    "Eigenvalue": np.round(pca.explained_variance_, 3),
    "Explained Variance Ratio": np.round(pca.explained_variance_ratio_, 3),
    "Cumulative Explained Variance": np.round(np.cumsum(pca.explained_variance_ratio_), 3),
}, index=[f"{i+1}" for i in range(len(pca.explained_variance_))])
explained_var_df.index.name = "Component"

# Use the 'eigenvalues' from the previous step
eigenvalues = pca.explained_variance_
plt.figure(figsize=(8, 6))
plt.plot(range(1, len(eigenvalues) + 1), eigenvalues, marker='o', linestyle='--')
plt.title('Scree Plot')
plt.xlabel('Number of Components')
plt.ylabel('Eigenvalue (Explained Variance)')
plt.grid(True)
plt.show()

Table 3 shows the explained variance table. We can see that the first eight components have eigenvalues greater than 1.0 and together explain 79.6% of the variance. Therefore, we will retain eight components for our final PCA model. For sports analytics, retaining 75% to 80% of the variance is sufficient for most applications.

Code

Markdown(tabulate(explained_var_df, headers='keys'))

Component	Eigenvalue	Explained Variance Ratio	Cumulative Explained Variance
1	9.264	0.34	0.34
2	3.151	0.116	0.456
3	2.124	0.078	0.534
4	1.856	0.068	0.602
5	1.598	0.059	0.661
6	1.379	0.051	0.712
7	1.224	0.045	0.757
8	1.074	0.039	0.796
9	0.954	0.035	0.831
10	0.918	0.034	0.865
11	0.823	0.03	0.895
12	0.7	0.026	0.921
13	0.622	0.023	0.944
14	0.467	0.017	0.961
15	0.316	0.012	0.972
16	0.261	0.01	0.982
17	0.185	0.007	0.989
18	0.112	0.004	0.993
19	0.067	0.002	0.995
20	0.065	0.002	0.998
21	0.035	0.001	0.999
22	0.015	0.001	1
23	0.005	0	1
24	0.003	0	1
25	0	0	1
26	0	0	1
27	0	0	1

pca = PCA(n_components=8)
pca.fit(X_scaled)

# Display explained variance ratio as a table
explained_var_df = pd.DataFrame({
    "Eigenvalue": np.round(pca.explained_variance_, 3),
    "Explained Variance Ratio": np.round(pca.explained_variance_ratio_, 3),
    "Cumulative Explained Variance": np.round(np.cumsum(pca.explained_variance_ratio_), 3),
}, index=[f"{i+1}" for i in range(len(pca.explained_variance_))])
explained_var_df.index.name = "Component"

Markdown(tabulate(explained_var_df, headers='keys'))

# Calculate the Component Matrix (loadings)
loadings = pca.components_.T * np.sqrt(pca.explained_variance_)

# Format into a pandas DataFrame
component_matrix = pd.DataFrame(loadings, 
                                columns=[f'PC{i+1}' for i in range(8)], 
                                index=X.columns)
component_matrix = component_matrix.applymap(lambda x: f'{x:.3f}' if abs(x) > 0.3 else '')

Markdown(tabulate(component_matrix, headers='keys'))

rotator = Rotator(method='varimax')
rotated_loadings = rotator.fit_transform(loadings)

rotated_loadings_df = pd.DataFrame(
    rotated_loadings,
    columns=[f'PC{i+1}' for i in range(rotated_loadings.shape[1])],
    index=features
)

# Sort by the component with the highest absolute loading for better visualization
max_loading_component = rotated_loadings_df.abs().idxmax(axis=1)
sorted_index = max_loading_component.sort_values().index
rotated_component_matrix_sorted = rotated_loadings_df.loc[sorted_index]
rotated_component_matrix_sorted = rotated_component_matrix_sorted.applymap(lambda x: f'{x:.3f}' if abs(x) > 0.3 else '')

Markdown(tabulate(rotated_component_matrix_sorted, headers='keys'))

X_pca = pca.transform(X_scaled)
df_pca = pd.DataFrame(X_pca, columns=[f'PC{i+1}' for i in range(X_pca.shape[1])])
df_pca["Game"] = np.arange(1, len(df_pca) + 1)

print("Original shape:", X_scaled.shape)
print("Transformed shape:", X_pca.shape)

Original shape: (125, 27)
Transformed shape: (125, 8)

import plotly.graph_objs as go

window = 10

fig = go.Figure()

# Use a less saturated, pastel color palette
colors = {
    'PC2': 'mediumseagreen',   # muted green
    'PC3': 'lightsalmon',      # soft orange
    'PC4': 'cornflowerblue'    # soft blue
}

# PC1
fig.add_trace(go.Scatter(
    x=df_pca['Game'],
    y=df_pca['PC1'].rolling(window).mean(),
    mode='lines',
    name=f'PC1: Elite Power & Contact Quality ({window}-game avg)',
    line=dict(color='gold', width=2)  # light yellow
))

# PC2
fig.add_trace(go.Scatter(
    x=df_pca['Game'],
    y=df_pca['PC2'].rolling(window).mean(),
    mode='lines',
    name=f'PC2: Swing Mechanics ({window}-game avg)',
    line=dict(color=colors['PC2'], width=2)
))

# PC3
fig.add_trace(go.Scatter(
    x=df_pca['Game'],
    y=df_pca['PC3'].rolling(window).mean(),
    mode='lines',
    name=f'PC3: Swing and Miss Tendencies ({window}-game avg)',
    line=dict(color=colors['PC3'], width=2)
))

# PC4
fig.add_trace(go.Scatter(
    x=df_pca['Game'],
    y=df_pca['PC4'].rolling(window).mean(),
    mode='lines',
    name=f'PC4: On-Base Ability ({window}-game avg)',
    line=dict(color=colors['PC4'], width=2)
))

fig.add_hline(y=0, line_dash="dash", line_color="grey", line_width=1)

fig.update_layout(
    title="Player's Skill Profile Over the Season (Rolling Avg)",
    xaxis_title='Game Number',
    yaxis_title='Component Score (Rolling Mean)',
    legend_title='Principal Components',
    xaxis=dict(range=[1, 125]),
    template='simple_white',
    legend=dict(
        orientation="h",
        yanchor="top",
        y=-0.25,
        xanchor="center",
        x=0.5
    )
)

fig.show();

Conclusion

In this post, we performed PCA on Pete Crow-Armstrong’s game-by-game statistics from the 2025 MLB season. We started by exploring the data and visualizing correlations between variables. We then applied PCA to reduce the dimensionality of the dataset while retaining most of the important information. By examining the communalities and scree plot, we determined that retaining eight components was optimal. Finally, we interpreted the components using a varimax rotation, which revealed distinct themes related to offensive performance, swing mechanics, plate discipline, and more.

We started with 27 features and ended with eight rotated components, distilling Pete Crow-Armstrong’s season into actionable levers. A spike in the decision component alongside a flat contact-quality component suggests selectivity gains arriving before slug; a swing-path surge without decision support hints at over-aggression masquerading as form.

In daily box scores, noise drowns signal. Principal component analysis doesn’t tell us whether a hot streak is coming; it shows how one would be built—better decisions, a cleaner path, louder contact, pressure after contact—so that when one dial twitches, everyone knows which adjustment matters next. Let’s hope Pete Crow-Armstrong finds the right signal among the noise.

Introduction

Pitch tunneling is the art of deception. It’s a pitcher’s ability to make multiple, distinct pitches look identical as they leave the hand. From the batter’s perspective, two pitches can travel through the same “tunnel” partway to the plate before diverging. What looked like a hittable fastball suddenly drops off the table - a devastating curveball for a swinging strike. Effective tunneling neutralizes a batter’s ability to recognize a pitch, forcing a split-second, and often wrong, decision.

Tyler Glasnow, 99mph Two Seamer and 84mph Curveball, Overlay pic.twitter.com/7tq1KcoqKj

— Rob Friedman ((PitchingNinja?)) July 19, 2025

Notice how both pitches erupt from the exact same arm slot and follow the same initial trajectory. The batter sees the same initial trajectory for both pitches, making it difficult to distinguish between the two until it’s too late.

In this article, we are going to quantify how well a pitcher tunnels certain pitches. This project is inspired by Baseball Savant’s page on arm angle. While resources like Baseball Savant provide ample data on release points and arm angles, a dedicated metric for tunneling effectiveness is surprisingly absent. This project aims to fill that gap. In order to quantify pitch tunneling, we will use K-Nearest Neighbors (K-NN) to find similar pitches in terms of release point and movement. We can then see what percentage of those similar pitches are of the same pitch type. A high percentage indicates good tunneling ability, while a low percentage suggests that the pitcher is telegraphing their pitches.

K-Nearest Neighbor

We turn to K-Nearest Neighbor (K-NN), a non-parametric machine learning algorithm used for classification and regression tasks (Wikipedia contributors (2025)). Other methods like Logistic Regression or Support Vector Machines usually have a training phase that involves stochastic gradient descent to find optimal parameters. K-NN’s training phase is much simpler. In K-NN, the training phase stores the feature vectors and class labels in memory - that’s it. So the training phase takes no time to complete. This implies that K-NN works best with smaller amounts of data. In general, K-NN works well on low-dimensional and low-volume data.

The bulk of K-NN happens in the inference phase. Given some positive integer, , K-NN assigns a label to a query () based on the most frequent training samples nearby . K-NN commonly uses Euclidean distance to measure nearness, but other distance metrics like Manhattan distance or Minkowski distance can also be used. Here’s a rundown of the three distance metrics (“K-Nearest Neighbor(KNN) Algorithm - GeeksforGeeks” (n.d.)).

Note that when , Minkowski distance is equivalent to Euclidean distance, and when , it is equivalent to Manhattan distance.

Since there is no training phase, we just need to implement the inference phase. This is done using a brute-force approach. For each query point, we will compute the distance to all training points and select the nearest neighbors.

Implementation

K-NN can easily be implemented using NumPy and built-in Python libraries.

import numpy as np
from collections import Counter

def euclidean_distance(a, b):
    return np.sqrt(np.sum((a - b) ** 2))

def knn_predict(X_train, y_train, x_query, k):
    # Compute distances from the query point to all training points
    distances = [euclidean_distance(x_query, x_train) for x_train in X_train]
    # sort distances and get indices of k nearest neighbors
    k_indices = np.argsort(distances)[:k]
    # Extract the labels of the k nearest neighbors
    k_nearest_labels = [y_train[i] for i in k_indices]
    # Return the most common label among the k nearest neighbors
    return Counter(k_nearest_labels).most_common(1)[0][0]

Let’s visualize K-NN with a simple 2D dataset.

Code

# import blobs
from sklearn.datasets import make_blobs
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

sns.set_theme(style="whitegrid", palette="pastel")

# Create a synthetic dataset
X, y = make_blobs(n_samples=100, centers=2, random_state=47, center_box=(-1.5, 1.5))

# Define k values to test
k_values = [2, 10]
plot_data = []

# Apply K-NN for each k
for k in k_values:
    predictions = [knn_predict(X, y, x_query, k) for x_query in X]
    # Store results for plotting
    for i in range(len(X)):
        plot_data.append({
            'feature1': X[i, 0],
            'feature2': X[i, 1],
            'prediction': predictions[i],
            'k': k
        })

# Convert to DataFrame
df = pd.DataFrame(plot_data)

# Create a facet grid
g = sns.FacetGrid(df, col="k", hue="prediction", height=3)
g.map(sns.scatterplot, "feature1", "feature2", edgecolor='k')
g.add_legend()
g.set_axis_labels("Feature 1", "Feature 2")
g.set_titles("k = {col_name}")
plt.show()

Observe how the decision boundary changes with different values of . A smaller (e.g., ) leads to a more complex decision boundary that closely follows the training data, while a larger (e.g., ) results in a smoother boundary that generalizes better.

Enough math. Let’s ball.

Pitch Tunneling with K-NN

For the first time in this blog, we will use PyBaseball to fetch data. PyBaseball is a Python package that provides an easy way to access baseball data from various sources, including MLB’s Statcast and Baseball Savant. We will first examine pitcher, Joe Ryan. According to baseball savant, Ryan currently has the highest fastball run value in 2025.

Let’s first query the data for Joe Ryan.

Now that we have the data, let’s preprocess it to extract the relevant features and labels. We will focus on the release_pos_x, release_pos_z, and release_extension columns, as well as the pitch_type column. In addition, we will normalize the data to ensure that the features are on the same scale.

Magic time. The key step for using K-NN in this application is to not classify the pitches, but rather to find the nearest neighbors based on the features. We will use the NearestNeighbors class from scikit-learn to find the nearest neighbors for each pitch. Below is a Shiny app that allows you to analyze a pitcher’s tunneling ability using K-NN. By entering the pitcher’s first and last name, my app’s backend will fetch the pitcher’s data and compute the K-NN scores for the selected pitch type. The app will then display a report and a plot of the pitch types and their tunneling ability.

You can view the full app here.

The main limitation to using K-NN for pitch tunneling is that pitch types are evenly distributed. If a pitcher throws a pitch type very infrequently, then the K-NN scores will show a higher percentage of different pitch types. This is because the K-NN algorithm will find more pitches that are not of the same type, simply because there are fewer of that type in the dataset. This is why I set a minimum pitch threshold of 25 pitches for the target pitch type. If a pitcher has fewer than 25 pitches of a certain type, then the K-NN scores will not be reliable. Having said that, there is still merit in comparing the K-NN scores for a player’s main pitch.

To address the issue of uneven pitch distribution, we also provide a Log-Likelihood method to analyze pitch tunneling. This method calculates the likelihood of a pitch being of a certain type given its features, and it can be more robust to uneven distributions. We leverage the scipy.stats library to compute the log-likelihood of the pitch type given the features and compare it against the most frequently used other pitch (in other words, the secondary pitch). The app allows you to switch between K-NN and Log-Likelihood methods for analysis. The closer the log-likelihood score is to zero, the better the tunneling ability of the pitcher.

Conclusion

Pitch tunneling has always felt more like art than science, a ‘you know it when you see it’ kind of skill. The goal here was to drag it out of the shadows of intuition and into the bright, unforgiving light of data. We started with two statistical tools, K-Nearest Neighbors and Log-Likelihood, not as perfect solutions, but as instruments to see what could be seen.

From these methods, we developed the K-Score and L-Score, our first-draft attempt at a true deception metric. They represent a new way to look at the game’s oldest duel: pitcher versus batter. But a new number on a spreadsheet is just that—a number. The real work begins now. These scores need to be tested against more seasons, more pitchers, and more outcomes. We need to see if the pitchers who score well are, in fact, the same ones who consistently make the best hitters look foolish.

This is less of an endpoint and more of a promising lead. The search is on for a reliable, quantifiable measure of a pitcher’s craft. If the K-Score and L-Score—or some future, more refined version of them—can prove their mettle, they could offer a new edge in evaluating talent, a new tool for pitchers honing their art, and for the rest of us, a new window into the subtle genius of keeping a hitter guessing.

Introduction: The Problem of “Player Comps”

“Who does this guy remind you of?” For decades, player comparisons—or “comps”—have been a cornerstone of how we talk about baseball. We’ve relied on simple, useful archetypes: the “power hitter,” the “contact hitter,” the “speedster,” the “ace.” While handy, these labels have always been oversimplified. Take a modern star like Juan Soto. Is he just a “power hitter”? This label would ignore his elite plate discipline and on-base skills.

In today’s Statcast era, we have access to a wealth of data that can help us move beyond these simplistic labels. Can we create a more nuanced understanding of player similarities? Instead of relying on subjective comparisons, we can use data-driven methods to identify player archetypes based on their actual performance metrics.

K-Means Clustering Overview

Picture this: you are a shelf-stocker at a grocery store. Your goal is to organize items in a giant, messy supermarket into neat, organized sections. You want to group similar items together, like all the cereals in one aisle, all the snacks in another, and so on. This is essentially what K-Means clustering does with data.

Step 1: Choose the Number of Clusters (K) - You decide how many groups (clusters) you want to create. This is like deciding how many aisles you want in the store. For example, you might choose 5 aisles for cereals, snacks, beverages, dairy, and produce.

Step 2: Randomly Place Cluster Centers - You randomly place a few points in the store to represent the center of each aisle. These points are called “centroids.” They are like the managers of each aisle, guiding where items should go.

Step 3: Assign Items to Clusters - You look at each item in the store and decide which aisle it belongs to based on its proximity to the centroids. If a cereal box is closest to the cereal aisle centroid, you put it there. This is like assigning items to the right shelves based on their characteristics.

Step 4: Update Cluster Centers - After assigning items, you check the centroids again. You calculate the average position of all items in each aisle and move the centroids to these new positions. This is like the aisle managers adjusting their positions based on where the items are now located.

Step 5: Repeat Until Stable - You repeat steps 3 and 4 until the centroids stop moving significantly. This means the aisles are now stable, and items are grouped as best as possible. You have successfully organized the store!

In our baseball analogy, the players are the items in the store, and the clusters are the aisles. The metrics we use to compare players are like the characteristics of the items. By applying K-Means clustering, we can group players with similar performance profiles together, just like organizing items into their respective aisles.

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
import seaborn as sns

# Create synthetic dataset
X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)
df = pd.DataFrame(X, columns=['feature1', 'feature2'])

# Calculate inertia for different values of K
inertia = []
k_range = range(2, 11)  # Testing K from 2 to 10
for k in k_range:
    kmeans = KMeans(n_clusters=k, init='k-means++', n_init='auto', random_state=42)
    kmeans.fit(df)
    inertia.append(kmeans.inertia_)

# Plotting the Elbow Method
plt.figure(figsize=(10, 6))
plt.plot(k_range, inertia, marker='o')
plt.title('Elbow Method for Optimal K')
plt.xlabel('Number of Clusters (K)')
plt.ylabel('Inertia (Sum of Squared Distances)')
plt.xticks(k_range)
plt.grid()
plt.show()

import numpy as np

class SimpleKMeans:
    def __init__(self, n_clusters=4, max_iters=100, random_state=42):
        self.n_clusters = n_clusters
        self.max_iters = max_iters
        self.random_state = random_state
        self.centroids = None
        self.labels = None

    def _initialize_centroids(self, X):
        np.random.seed(self.random_state)
        random_indices = np.random.permutation(X.shape[0])
        self.centroids = X[random_indices[:self.n_clusters]]

    def _assign_clusters(self, X):
        distances = np.sqrt(((X - self.centroids[:, np.newaxis])**2).sum(axis=2))
        return np.argmin(distances, axis=0)

    def _update_centroids(self, X, labels):
        new_centroids = np.zeros((self.n_clusters, X.shape[1]))
        for k in range(self.n_clusters):
            cluster_points = X[labels == k]
            if len(cluster_points) > 0:
                new_centroids[k] = cluster_points.mean(axis=0)
        return new_centroids

    def fit(self, X):
        self._initialize_centroids(X)
        for _ in range(self.max_iters):
            self.labels = self._assign_clusters(X)
            new_centroids = self._update_centroids(X, self.labels)
            if np.all(self.centroids == new_centroids):
                break
            self.centroids = new_centroids
        return self

# Using the same synthetic data from before
X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)

# Fit the custom KMeans model
custom_kmeans = SimpleKMeans(n_clusters=4, random_state=42)
custom_kmeans.fit(X)
custom_labels = custom_kmeans.labels

# Plot the results
plt.figure(figsize=(10, 6))
sns.scatterplot(x=X[:, 0], y=X[:, 1], hue=custom_labels, palette='viridis', s=100)
plt.scatter(custom_kmeans.centroids[:, 0], custom_kmeans.centroids[:, 1], 
            s=300, c='red', marker='X', label='Centroids')
plt.title('K-Means Clustering from Scratch')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend()
plt.grid()
plt.show()

The Payoff - Profiling MLB Players with K-Means

Now that we have a solid understanding of K-Means clustering, let’s apply it to our baseball data. We will use the percentile rankings for various offensive metrics to cluster players and identify their profiles.

df = pd.read_csv("percentile_rankings.csv")
df.sort_values("xwoba", ascending=False).head(5)

The percentile rankings dataset contains various offensive metrics for players, such as xwOBA, xBA, and xSLG. For this application, we will use xba, xslg, xiso, and xobp. These metrics provide a comprehensive view of a player’s offensive performance, allowing us to cluster players based on their hitting profiles.

features = ["xba", "xslg", "xiso", "xobp"]
df_k = df[features]
df_k = df_k.dropna()
df_k = df_k.sort_values("xslg", ascending=False)
df_k.head(5)

Let’s apply the Elbow method to determine the optimal number of clusters for our baseball data. We will plot the inertia for different values of K and look for the “elbow” point.

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

inertia = []
k_values = range(1, 11)

for k in k_values:
    kmeans = KMeans(n_clusters=k, random_state=42)
    kmeans.fit(df_k)
    inertia.append(kmeans.inertia_)

plt.figure(figsize=(10, 6))
plt.plot(k_values, inertia, marker='o')
plt.title('Elbow Method for Optimal K')
plt.xlabel('Number of Clusters (K)')
plt.ylabel('Inertia')
plt.xticks(k_values)
plt.grid()
plt.show()

Looking at the elbow plot, we can see that the inertia decreases as we increase K, but there is a point where the decrease becomes less significant. This point is where we should choose our optimal K. For our dataset, it appears that is a good choice, as the inertia reduction slows down significantly after that point.

optimal_k = 6
final_kmeans = KMeans(n_clusters=optimal_k, init='k-means++', n_init='auto', random_state=42)
clusters = final_kmeans.fit_predict(df_k)

cluster_names = {2: "Elite Slugger", 5: "High-Average Hitter", 3: "Contact Specialist", 4: "Three True Outcome Hitter", 0: "Low-Average Power Threat", 1: "Struggling Hitter"}

# Add the cluster labels back to a copy of our original dataframe
results_df = df_k.loc[df_k.index].copy()
results_df['cluster'] = clusters

# map cluster names to the cluster labels
results_df['cluster'] = results_df['cluster'].map(cluster_names)

cluster_profiles = results_df.groupby('cluster')[features].mean().round(1)
cluster_profiles = cluster_profiles.sort_values(by=features, ascending=False)

print("--- Cluster Profiles (Average Percentiles) ---")
cluster_profiles.to_clipboard()

cluster_profiles = cluster_profiles.rename(index=cluster_names)
cluster_profiles

--- Cluster Profiles (Average Percentiles) ---

# Data from the user
data = {
    'cluster': ['Elite Slugger', 'High-Average Hitter', 'Contact Specialist', 'Three True Outcome Hitter', 'Low-Average Power Threat', 'Struggling Hitter'],
    'xba': [80.5, 75.8, 59.0, 56.2, 30.3, 17.2],
    'xslg': [91.8, 64.9, 26.0, 81.8, 50.8, 14.3],
    'xiso': [89.3, 55.8, 18.3, 82.8, 59.0, 20.5],
    'xobp': [89.7, 72.8, 60.4, 40.5, 32.6, 18.6]
}
df_vis = pd.DataFrame(data)
df_vis = df_vis.set_index('cluster')

# Number of variables we're plotting.
num_vars = len(df_vis.columns)

# Compute angle for each axis.
angles = np.linspace(0, 2 * np.pi, num_vars, endpoint=False).tolist()

# The plot is a circle, so we need to "complete the loop"
# and append the start to the end.
angles += angles[:1]

# Labels for each axis
labels = df_vis.columns

# Create the figure and subplots
fig, axes = plt.subplots(figsize=(10, 9), nrows=3, ncols=2, subplot_kw=dict(polar=True))
axes = axes.flatten() # Flatten the 3x2 grid of axes for easy iteration

# Define colors for each cluster
colors = plt.cm.viridis(np.linspace(0, 1, len(df_vis)))

# Plot each cluster on a separate subplot
for i, (cluster_name, row) in enumerate(df_vis.iterrows()):
    ax = axes[i]
    values = row.tolist()
    values += values[:1]  # complete the loop

    # Plot the data
    ax.plot(angles, values, color=colors[i], linewidth=2)
    ax.fill(angles, values, color=colors[i], alpha=0.25)

    # Prettify the plot
    ax.set_rlim(0, 100) # Set radial limits to be consistent (0-100 for percentiles)
    ax.set_yticklabels([0, 25, 50, 75, 100])
    ax.set_xticks(angles[:-1])
    ax.set_xticklabels(labels, size=8)
    ax.set_title(cluster_name, size=12, y=1.1)

# Adjust layout to prevent titles from overlapping
plt.tight_layout(pad=3.0)
plt.show()

results_df = results_df.sort_values('xslg', ascending=False)
results_df = results_df.merge(df[['player_name']], left_index=True, right_index=True, how='left')
results_df[results_df['cluster'] == "Elite Slugger"].sort_values('xslg', ascending=False).head(5)

results_df[results_df['cluster'] == "High-Average Hitter"].sort_values('xba', ascending=False).head(5)

results_df[results_df['cluster'] == "Contact Specialist"].sort_values('xba', ascending=False).head(5)

results_df[results_df['cluster'] == "Three True Outcome Hitter"].sort_values('xslg', ascending=False).head(5)

results_df[results_df['cluster'] == "Low-Average Power Threat"].sort_values('xba', ascending=False).head(5)

results_df[results_df['cluster'] == "Struggling Hitter"].sort_values('xba', ascending=False).head(5)

results_df[results_df['cluster'] == "Struggling Hitter"].sort_values('xba', ascending=False).tail(5)

Conclusion

Using K-Means clustering, we discovered six distinct player profiles based on their expected offensive performance metrics. This approach allows us to move beyond simplistic player comparisons and gain a more nuanced understanding of player archetypes. By clustering players based on their actual performance data, we can identify similarities and differences that may not be immediately apparent through traditional scouting methods.

K-means has its limitations, such as sensitivity to the initial placement of centroids and the need to specify the number of clusters beforehand. This method requires a careful selection of features and preprocessing steps to ensure meaningful results, in addition to a heuristic-based approach to determine the optimal number of clusters. However, it remains a powerful tool for uncovering patterns in data and can be applied to various domains beyond baseball.

Data science isn’t here to replace baseball wisdom but to enhance it. This kind of analysis provides a new, powerful lens through which we can appreciate the diverse skill sets of the players we love to watch.

Look at Cody Bellinger this season. The numbers show his bat speed is ticking up. Just a little. But it’s there. Data science sees it as a player beginning to migrate from one cluster to another, a tiny tremor that might signal a return to the guy who won an MVP in 2019. It’s a reminder that these profiles aren’t destiny. They’re just a moment in time.

The data points are clues, but the players are still people. And people, thank God, can still surprise you.

Past Aricles

• Logistic Regression
• Support Vector Machines
• Decision Trees

GitHub:

• Code

Introduction: The Beauty of Baseball’s Numbers

Manny Machado, Juan Soto, and Eugenio Suarez are three all-star caliber baseball players. The trio consistently set baseball discourse ablaze. But there’s one question in baseball circles that has been debated for years: “Who is better?”

Difference between .300 and .275 hitter is one hit every two weeks. If you see both 15 games a year, there’s a 40% chance that the .275 hitter will have more hits than the .300 hitter. - Moneyball, Michael Lewis

Sure, we can all watch them play, but baseball is a game of numbers. We cannot rely on our eyes, heuristics, or biases. In following the MLB trade deadline on Twitter, I saw a tweet from Jeff Passan that described Soto, Suarez, and Machado in three different aspects.

Great question, John. For most of baseball history, the walk was sneered at – a lesser form of getting on base compared to the exceptional skill it takes to swing. The analytical revolution in the game changed that. If the objective of the game is to outscore a team, then the…

— Jeff Passan (@JeffPassan) August 2, 2025

To summarize, Passan describes three metrics: batting average (BA), on-base percentage (OBP), and slugging (SLG). Passan shares the Moneyball principle in that modern statistics have turn to other statistics to evaluate a hitter; old baseball viewed walks as a “lesser” hit. Each of these metrics tells a different story about the players. BA is the simplest, describing how often a player gets a hit. OBP is the percentage of times a player reaches base, which includes hits, walks, and hit by pitches. Slugging is the total number of bases a player gets per at-bat, which includes singles, doubles, triples, and home runs - its like batting average but weighted by the type of hit.

Following the definitions, Passan shares slashlines for Machado, Soto, and Suarez. A slashline is a shorthand way to describe a player’s hitting statistics, typically in the format BA/OBP/SLG.

• Machado: .301/.360/.505
• Soto: .247/.380/.480
• Suarez: .245/.316/.565

Machado is described as the best “all-around hitter” of the three, with the highest batting average. Soto is praised for his exceptional on-base skills. He is also in the 100th percentile for walk rate. Suarez is noted for his power-hitting ability.

import plotly.graph_objects as go
import pandas as pd

image_urls = [
    "https://img.mlbstatic.com/mlb-photos/image/upload/d_people:generic:headshot:67:current.png/w_426,q_auto:best/v1/people/592518/headshot/67/current", # Machado
    "https://img.mlbstatic.com/mlb-photos/image/upload/d_people:generic:headshot:67:current.png/w_426,q_auto:best/v1/people/665742/headshot/67/current", # Soto
    "https://img.mlbstatic.com/mlb-photos/image/upload/d_people:generic:headshot:67:current.png/w_426,q_auto:best/v1/people/553993/headshot/67/current"  # Suárez
]

# Data for the three players
data = {
    'Player': ['Manny Machado', 'Juan Soto', 'Eugenio Suárez'],
    'BA': [0.301, 0.247, 0.245],
    'OBP': [0.360, 0.380, 0.316],
    'SLG': [0.505, 0.480, 0.565]
}

df = pd.DataFrame(data)

# Create the figure
fig = go.Figure()

# Add a bar trace for each statistic
fig.add_trace(go.Bar(
    x=df['Player'],
    y=df['BA'],
    name='Batting Avg (BA)',
    marker_color='rgba(54, 162, 235, 0.7)',
    hovertemplate='%{y:.3f}<extra></extra>'
))

fig.add_trace(go.Bar(
    x=df['Player'],
    y=df['OBP'],
    name='On-Base % (OBP)',
    marker_color='rgba(75, 192, 192, 0.7)',
    hovertemplate='%{y:.3f}<extra></extra>'
))

fig.add_trace(go.Bar(
    x=df['Player'],
    y=df['SLG'],
    name='Slugging % (SLG)',
    marker_color='rgba(255, 99, 132, 0.7)',
    hovertemplate='%{y:.3f}<extra></extra>'
))

# --- Add Headshot Images ---
for i, player in enumerate(df['Player']):
    fig.add_layout_image(
        dict(
            source=image_urls[i],
            xref="x",
            yref="paper",
            x=player,  # Use player name to anchor on x-axis
            y=-0.30,    # Position below the x-axis
            sizex=0.25, # Size of the image
            sizey=0.25,
            xanchor="center",
            yanchor="bottom"
        )
    )

# Update the layout for a clean, grouped bar chart
fig.update_layout(
    barmode='group',
    title={
        'text': '<b>Player "Slash Line" Comparison</b>',
        'y':0.9,
        'x':0.5,
        'xanchor': 'center',
        'yanchor': 'top'
    },
    xaxis_title='Player',
    yaxis_title='Rate',
    yaxis_range=[0, 0.6],
    legend_title_text='Statistic:',
    legend=dict(
        orientation="h",
        yanchor="bottom",
        xanchor="left",
        y=1.02,
        x=0.2,
    ),
    template='plotly_white',
    font=dict(
        family="Inter, sans-serif",
        size=12
    ),
    margin=dict(b=120) # Increase bottom margin to make space for images
)


# Show the figure
fig.show()