I told myself I wouldn’t do it again. The last time nearly broke me. And yet, just when I thought I was out, they pull me back in.

Against my better judgement, I did another sandwich data science project. Thankfully, this one was significantly simpler.

An Impenetrable Menu

I work at Square, and their NYC office is in SoHo. While there are many reasons not to go into the office nowadays, one draw is that I can pick up lunch at Alidoro, a tiny Italian sandwich shop that’s nearby. The sandwiches are the quintissential European antithesis to American sandwiches; they consist of only a couple, extremely high quality ingredients.

From these few ingredients emerge 40 different types of sandwiches, and these 40 sandwiches form an impenetrable menu.

Naively, you may think you can pick a sandwich that looks close to what you want and then customize it. Perhaps you would like the Romeo but with some fresh mozzarella? Well then perhaps you would be wrong because customization is not allowed. Did I mention that there are some Soup Nazi vibes to this place? You can only order what’s on the menu, and it took the global pandemic to finally break their will to remain cash only.

Some people like to explore new items on a menu, while I always exploit the one that I’ve been happy with. Case in point: I get the Fellini on Foccacia every time. Still, I remember what it was like to be a newcomer and encounter that impenetrable menu.

And so, this blog post is my attempt at data visualization. My goal is to visualize the menu in such a way that one can quickly scan it to find a sandwich they would like. As an added bonus, I’ll close with some statistical modeling of the sandwich pricing.

Packaging and Presentation

Like many of my blog posts, I wrote this one in a Jupyter notebook. While I would prefer to show the full code for the blog post, I didn’t want this post to be as impenetrable as Alidoro’s menu. I made a small sandmat package to house much of the code. The package, along with the Jupyter notebook version of this blog post can be found on GitHub here.

Menu Scraping

To start, we need to get the menu and turn it into “data”. For whatever reason, I didn’t feel like using pandas for this blog post, so everything we’ll deal with will be collections of dataclasses.

Within the sandmat package, I make two dataclasses: Ingredient and Sandwich. Most of the fields are self-explanatory with the exception for the ingredient categories. For these, I manually classify ingredients into meat, cheese, topping, or dressing. In hindsight, I probably should’ve made this an Enum field.

@dataclass(frozen=True)
class Ingredient:
    name: str
    category: str


@dataclass(frozen=True)
class Sandwich:
    name: str
    ingredients: Tuple[Ingredient]
    price: float 

I use Beautiful Soup to scrape the menu page of the Alidoro website and grab the section of the HTML that pertains to the menu. I then do some parsing, cleaning, and categorization in order to turn the menu into a list of Sandwich objects.

Ingredient Rank and File

I would like to display the sandwiches in “matrix” form. Each sandwich will be a row, each ingredient will be a column, and the values of the matrix will indicate if a sandwich has a particular ingredient. What’s left is to decide on an order to the sandwich rows and an order to the ingredient columns.

In my initial approach, I coded up a traveling salesman problem in which sandwiches were cities and the overlap in ingredients between any two sandwiches was the “distance” between sandwiches. It would’ve made for the perfect title (“Traveling Sandwich Problem”, obviously), but, contrary to the numerical solution, the result was visually suboptimal.

Thankfully, this is a problem where we can rely on domain expertise. As a sandwich eater myself, I thought about how I typically pick a sandwich. I often look at the meats first, then the cheeses, and then everything else. Ok, let’s sort the ingredient columns by category “rank”: meat, cheese, topping, dressing. Within each category, how about using the recsys go-to of sorting in descending order of popularity? Combining category rank and popularity gives us our full ingredient column order. In SQL, we’d want to do something like

SELECT
  category
  , CASE 
    WHEN category = 'meat' THEN 1
    WHEN category = 'cheese' THEN 2
    WHEN cateogry = 'topping' THEN 3
    WHEN category = 'dressing' THEN 4
  END AS category_rank
  , ingredient
  , COUNT(DISTINCT sandwich) as num_sandwiches
FROM sandwich_ingredients
GROUP BY category, category_rank, ingredient
ORDER BY category_rank ASC, num_sandwiches DESC

For ordering our sandwich rows, let’s sort them by a special key which is a tuple that contains their most popular ingredient in each category where the tuple is in order of meat, cheese, topping, dressing.

Visualizing the Matrix

Finally, with our ordered ingredients and sandwiches, we can visualize the Alidoro sandwich menu as a matrix.

Ed ecco qua

Pricing Analysis

Just for prosciuttos and giggles, I decided to treat my sandwich matrix as a design matrix. I’ll fit a linear regression on the sandwich matrix with the sandwich price as the target variable. The model coefficients will thus be the price of each ingredient, and a bias term will take care of the base price of the sandwich (which includes the bread). As you can see, the model is pretty well-calibrated! I guess Alidoro’s sandwich pricing is pretty consistent.

We can inspect this model visually by plotting the prices of all of the ingredients. I had no idea mortadella was the most expensive meat.

And last but not least, we can compare the sandwich price to the model’s predicted price in order to get an idea if any sandwich’s price is wildly inconsistent. Most sandiwch prices are consistent, although the Gabriella is apparently cheaper than expected at $11.00 for (only!) fresh mozzarella, dressing, and arugula. I don’t know if I’d call that cheap, but, then again, neither is SoHo.