---
license: apache-2.0
task_categories:
- feature-extraction
size_categories:
- 100M<n<1B
---

# Foursqure OS Places 100M

Full Foursquare OS Places dump from https://opensource.foursquare.com/os-places/.
This is a single (geo-)parquet file based on the 81 individual parquet files from fused.io on https://source.coop/fused/fsq-os-places/2024-11-19/places.

As it's just 10Gb, it's fairly easy to handle as a single file and can easily be queried over modern technologies like httpfs. 

## Ways to query the file & visualize the results
If you just want to poke around in the data to get an idea of kind of places to expect, I'd recommend DuckDB.
Huggingface has a DuckDB WASM console integrated but it's too slow (or runs out of memory) when run over the entire file. You can try it [here](https://huggingface.co/datasets/do-me/foursquare_places_100M?sql_console=true&sql=--+The+SQL+console+is+powered+by+DuckDB+WASM+and+runs+entirely+in+the+browser.%0A--+Get+started+by+typing+a+query+or+selecting+a+view+from+the+options+below.%0ASELECT+*+FROM+train+WHERE+name+ILIKE+%27%25bakery%25%27%3B%0A)

A better way is to run DuckDB locally and query it over httpfs (you do not need to download the whole file but thanks to modern range requests DuckDB just pulls the entries that match the query) as such, e.g. in  Python or in the CLI.
Here I use Jupyter and convert the results to a pandas view for displaying convenience.

### Example 1: Queried over httpfs with DuckDB

```python
import duckdb
duckdb.sql("INSTALL httpfs;LOAD httpfs;") # required extension
duckdb.sql(f"SELECT * FROM 'hf://datasets/do-me/foursquare_places_100M/foursquare_places.parquet' WHERE name ILIKE '%bakery%' ").df()
```

This command takes roughly 70 seconds on my system/network (M3 Max) and yields 104985 entries: 

![image/png](https://cdn-uploads.huggingface.co/production/uploads/64c4da8719565937fb268b32/LsCYG2HTQmO0t6cJa3Y3R.png)

### Example 2: Queried fully locally with DuckDB

This method is much faster, but you need to download the file once. Just download the file directly clicking [this link](https://huggingface.co/datasets/do-me/foursquare_places_100M/resolve/main/foursquare_places.parquet). 
You could also use Huggingface datasets library.

```python
import duckdb
duckdb.sql("SELECT * FROM 'foursquare_places.parquet' WHERE name ILIKE '%bakery%' ").df()
```

It yields precisely the same results but takes only 4.5 seconds! 

### Example 3: Queried fully locally with Geopandas

In case you'd like to do some easy geoprocessing, just stick to Geopandas. It's of course a bit slower and loads everything in memory but gets the job done nicely.

```python
import geopandas as gpd
gdf = gpd.read_parquet("foursquare_places.parquet")
```

Loading the gdf once takes 2 - 3 mins in my case.

Then you can make use of good old pandas query operators and geospatial tools. 

E.g. looking for bakeries again.
```python 
gdf[gdf["name"].str.contains("bakery")]
```
I was actually surprised that the string operator in pandas is that efficient! It only takes 11 seconds, so fairly fast for 100M rows!

But to be fair, the actual equivalent to ILIKE in pandas would be this query: 

```python
gdf[gdf["name"].str.contains("bakery", case=False, na=False)]
```

It yields exactly the same number of rows like the SQL command but takes 19 seconds, so - as expected - indeed much slower than DuckDB (especially considering that we just count the query time, not the loading time)

### Example 4: Queried fully locally with Geopandas and visualized with Lonboard

If you quickly want to visulize the data, Lonboard is a super convenient Jupyter wrapper for deck.gl. 
Install it with `pip install lonboard` and you're ready to go. 

```python
import geopandas as gpd
from lonboard import viz

gdf = gpd.read_parquet("foursquare_places.parquet")

bakeries = gdf[gdf["name"].str.contains("bakery", case=False, na=False)]

viz(bakeries)
```
It created a nice interactive map with tooltips.

![image/png](https://cdn-uploads.huggingface.co/production/uploads/64c4da8719565937fb268b32/QIolrK2nlrENnkWlE6TFh.png)

If you ask yourself: "Wait, how is it possible that there are so little bakeries in other countries than the US & UK?", just read on!

## Motivation

So why would I create this repo and duplicate the data if you can download it directly from AWS or Source Cooperative? 

It's mainly about convenience: many folks might just want to get an idea of the data and httpfs is perfectly suited for this purpose. 
However the ACTUAL reason why I'm doing this, is that I created a geospatial semantic search workflow for social media data, Overturemaps and other data sources. 
The idea is to use text embeddings and visulize the query similarity on a map. Just play with the apps here to get an idea, it's easier to understand once you tried it:

- Geospatial Semantic Search for Instagram Data in Bonn, Germany: https://do-me.github.io/semantic-hexbins/
- Worldwide Geospatial Semantic Search for Overture Places: https://huggingface.co/datasets/do-me/overture-places

In the above example 4, where we are looking for bakeries around the world, it's clear that non-English-speaking countries probably do not necessarily name their bakeries "bakery" but e.g. in German "Bäckerei". 
So if we just search in the name column, we won't find it. That's the reason why Foursquare introduced categories! 

In the column `fsq_category_labels` we find `[Dining and Drinking > Bakery]` great right? Well, yes and no. Of course we can use it and we will get back some results. 
However, looking a bit closer, we can quickly see why these categories do not seem to work that well: 

![image/png](https://cdn-uploads.huggingface.co/production/uploads/64c4da8719565937fb268b32/vtDreZy3bdf7UOnQyqWQG.png)

Sometimes there are no categories and sometimes entries like `Beef&bakery` probably should have gotten more than one entry.

So how can we solve this?