Showing posts with label Visualization. Show all posts
Showing posts with label Visualization. Show all posts

Wednesday, November 1, 2023

Tableau-like Visualization with PyGWalker

Target audience: Beginner
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
      Installation

Follow me on LinkedIn
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:
  1. Create a 'TechCity' instance.
  2. Transition these instances into a dictionary format.
  3. 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.


Tabular representation of TechCity instances


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:
  1. Choose 'Geographic' for the Coordinate System.
  2. Drag the longitude (and subsequently, latitude) column to the respective 'Longitude' (and 'Latitude') fields.
  3. 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





---------------------------
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