Target audience: Beginner
Estimated reading time: 3'
Estimated reading time: 3'
Ever thought about presenting test results in a format similar to Tableau, one that management is acquainted with? A visually appealing, business-centric display can effectively convey messages.
In this article, we delve into the PyGWalker Python library, which mirrors the interactive visualization style of Tableau, especially when it comes to geospatial graphics.
Table of contents
Notes:
- Environments: Python 3.10, Pandas 2.12, PyGWalker 0.3.9, Pedantic 2.4.2, GeoPy 2.4.0
- To enhance the readability of the algorithm implementations, we have omitted non-essential code elements like error checking, comments, exceptions, validation of class and method arguments, scoping qualifiers, and import statements.
Introduction
PyGWalker, which stands for Python binding for Graphic Walker, is a visual representation library in Python, designed to work seamlessly with Jupyter-style notebooks for data probing and assessment [ref 1].
This library renders a user interface reminiscent of Tableau [ref 2], generated directly from pandas data frames. Its user-friendly interface facilitates pattern visualization and analysis through effortless drag-and-drop actions.
Please refer to an older post, Setup Tableau with Amazon EMR-Spark for more information about Tableau configuration and deployment [ref 3].
Installation
pip: pip install pygwalker --upgrade
conda: condo install -c condo-force pygwalker
JupyterLab: pip install jupyterlab
Notebook: pip install notebook
Integration with Jupyter notebook
PyGWalker utilizes the Jupyter engine to produce an interactive user interface (UI) that resonates with the business community. Unlike Matplotlib, where visualization is code-centric, in PyGWalker, plot customization is managed directly through the UI. Thus, Python's role is mostly restricted to setting up and initiating the UI.
After importing the necessary libraries and setting up the Pandas data frame, activating the UI is just a single line of code away.
import pandas as pd
import pygwalker as pyg
my_csv_file = 'input/locations.csv'
df = pd.read_csv(my_csv_file)
# Launch the PyGWalker interactive UI
walker = pyg.walk(df)
Use case
Depicting geospatial data graphically can be quite daunting. In this context, we aim to illustrate the spread of tech and science firms throughout California.
Our scenario leverage GeoPy, a Python tool that interfaces with multiple renowned geocoding online platforms [ref 4].
This tool streamlines the process for Python programmers, allowing them to determine the coordinates of various locations—be it addresses, cities, nations, or significant landmarks—by utilizing independent geocoders and assorted data resources. Notably, while GeoPy supports geocoding from platforms like Google Maps, Bing Maps, and Nominatim, it maintains no direct affiliations with any of them.
installation: pip install geopy
In our case, the data comes in a straightforward 2-column table, detailing the city names and the count of tech/science enterprises, labeled as 'num_companies'. We've established a class, 'TechCity', which incorporates additional attributes – longitude and latitude – facilitating the data's visualization on a geographical map.
from typing import AnyStr, TypeVar, List
from dataclasses import dataclass
@dataclass
class TechCity:
city: AnyStr
num_companies: float
longitude: float
latitude: float
@staticmethod
def header() -> List[AnyStr]:
return ['city', 'num_companies', 'longitude', 'latitude']
Following that, we establish a generator class named 'TechCitiesGenerator' that transforms the input data (comprising city names and the 'num_companies' for each city) into 'TechCity' instances for display purposes.
We employ the Nominatim geolocation service, set up during the class construction. Nominatim taps into OpenStreetMap data to pinpoint locations globally by either name or address (a process called geocoding) [ref 5].
The procedure __call__, can be broken down into three steps:
- Create a 'TechCity' instance.
- Transition these instances into a dictionary format.
- Archive this dictionary as a CSV or JSON file.
class TechCitiesGenerator(object):
""" Generate the input to PyGWalker table with geo-location data :param cities List of cities with significant number of tech/science companies :param num_companies List of number of companies associated with each city :param filename Name of the output file (CSV or JSON) """
def __init__(self, cities: List[AnyStr], num_companies: List[int], filename: AnyStr):
from geopy.geocoders import Nominatim
self.filename = filename
self.cities = cities
self.num_companies_lst = num_companies
self.loc = Nominatim(user_agent='Geopy Library')
def __call__(self) -> bool:
import csv
import logging
# Step 1: Generate the records of type TechCity
tech_cities = [
TechCity(city, num_companies, self.loc.geocode(city).longitude, self.loc.geocode(city).latitude)
for index, (city, num_companies)
in enumerate(zip(self.cities, self.num_companies_lst))
]
# Step 2: Convert to list into a dictionary
records = [vars(tech_city) for tech_city in tech_cities]
# Step 3: Store the dictionary in CSV or JSON format, give the file name
try:
match self.filename[-4:]:
case '.csv':
with open(self.filename, 'w') as f:
writer = csv.DictWriter(f, fieldnames=TechCity.header())
writer.writeheader()
for record in records:
writer.writerow(record)
return True
case 'json':
import json
json_repr = json.dumps(records, indent=4)
with open(self.filename, 'w') as f:
f.write(json_repr)
return True
case _:
logging.error(f'Extension for {self.filename} is incorrect')
return False
'except Exception as e: logging.error(f'Failed to store object {str(e)}') return True
Output
The most basic visualization is a table akin to standard Tableau worksheets, where the columns depict the four attributes of the TechCity class, and each row corresponds to an individual instance.
The display below showcases PyGWalker's ability to map the count of companies across the cities listed in the table, superimposed on a geographical layout. Achieving this visualization involves three straightforward steps:
- Choose 'Geographic' for the Coordinate System.
- Drag the longitude (and subsequently, latitude) column to the respective 'Longitude' (and 'Latitude') fields.
- Drag the 'num_companies' column, representing the number of companies, into the size field.
That's it.
Tableau-like geospatial representation of number of
tech & science companies for California cities
Conclusion
Effective communication of findings between data scientists and stakeholders is pivotal for any project's triumph. PyGWalker equips engineers with the ability to represent model outcomes in a style reminiscent of Tableau, a platform that many executives recognize, right within their notebooks.
Additionally, PyGWalker's visualization approach is both instinctive and interactive, sidestepping the clutter that additional coding can sometimes introduce in notebooks
Thank you for reading this article. For more information ...
References
[1] GitHub PyGWalker
[2] Tableau.com
---------------------------
Patrick Nicolas has over 25 years of experience in software and data engineering, architecture design and end-to-end deployment and support with extensive knowledge in machine learning.
He has been director of data engineering at Aideo Technologies since 2017 and he is the author of "Scala for Machine Learning" Packt Publishing ISBN 978-1-78712-238-3
He has been director of data engineering at Aideo Technologies since 2017 and he is the author of "Scala for Machine Learning" Packt Publishing ISBN 978-1-78712-238-3
