Marks_Channels_Seaborn_Objects.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMSBrVYhb7ubCyfP4Kbj4zy",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/odu-cs625-datavis/public-fall23-mcw/blob/main/Marks_Channels_Seaborn_Objects.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Marks and Channels with Seaborn Objects Tutorial\n",
        "\n",
        "Marks, channels, and data types are the building blocks of creating charts and visualizations. We will use this terminology in our coding examples.\n",
        "\n",
        "From Chapter 5 in [VAD](https://www.cs.ubc.ca/~tmm/vadbook/):\n",
        "* \"*marks* are the basic geometric elements that depcit items or links\"\n",
        "* \"*channels* control their [marks] appearance\"\n",
        "* \"the effectiveness of a channel for encoding data depends on its *type*\"\n",
        "\n",
        "References:\n",
        "* A Quick Introduction to the Seaborn Objects System, https://www.sharpsightlabs.com/blog/seaborn-objects-introduction/\n",
        "* The seaborn.objects interface, https://seaborn.pydata.org/tutorial/objects_interface.html\n",
        "* Properties of Mark objects, https://seaborn.pydata.org/tutorial/properties.html\n",
        "\n",
        "To work along with this tutorial, sign in to your Google account and File > Save a copy in Drive."
      ],
      "metadata": {
        "id": "shXWgweaWGw9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Data\n",
        "\n",
        "First, we'll import the dataset that we'll use for this tutorial.  We will visualize global health and population measures for countries of the world, recorded over the years 1955 to 2005. The data was collected by the [Gapminder Foundation](https://www.gapminder.org/) and shared in [Hans Rosling's popular TED talk](https://www.youtube.com/watch?v=hVimVzgtD6w). (If you haven't seen the talk, I encourage you to watch it!)\n",
        "\n",
        "(The vega-datasets GitHub repo has lots of sample datasets that you can use to practice, see https://github.com/vega/vega-datasets/blob/main/SOURCES.md.)\n",
        "\n",
        "We'll use Pandas to import the gapminder.json datafile into a dataframe."
      ],
      "metadata": {
        "id": "oNreEPrceaWO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd"
      ],
      "metadata": {
        "id": "9Wxi1-6xe97B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df = pd.read_json('https://cdn.jsdelivr.net/npm/vega-datasets@2/data/gapminder.json')"
      ],
      "metadata": {
        "id": "csVAN0IrfAPs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print (df.head())"
      ],
      "metadata": {
        "id": "pys9LACKfHQo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "For each `country` and `year` (in 5-year intervals), we have measures of fertility in terms of the number of children per woman (`fertility`), life expectancy in years (`life_expect`), and total population (`pop`)."
      ],
      "metadata": {
        "id": "BqRqKsFWgAWQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, we'll create some smaller dataframes that we'll use later. The one below should contain the data only for the year 2000."
      ],
      "metadata": {
        "id": "KXmNCQfaIuBC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df_2000 = df.query(\"year == 2000\")\n",
        "print (df_2000.head())"
      ],
      "metadata": {
        "id": "SdbOc8__gSjY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This one has data for countries labeled cluster 1 in the year 2000."
      ],
      "metadata": {
        "id": "52vjOzDMNsED"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df_2000c1 = df_2000.query(\"cluster == 1\")\n",
        "print(df_2000c1.head())"
      ],
      "metadata": {
        "id": "ekg9jymDNdQh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We'll also create a dataset that has values only for the US."
      ],
      "metadata": {
        "id": "Lh91wXYkinKJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df_US = df.query(\"country == 'United States'\")\n",
        "print(df_US.head())"
      ],
      "metadata": {
        "id": "4UPeL0cIirJQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finally, we'll have a set with only a few countries."
      ],
      "metadata": {
        "id": "ndIm8I6uI1fx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df_5countries = df.query(\"country in ('United States', 'France', 'Austria', 'Brazil', 'Germany')\")\n",
        "print(df_5countries.head())"
      ],
      "metadata": {
        "id": "QSom0qVwI1E8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Seaborn's Objects Interface\n",
        "\n",
        "In September 2022, the seaborn.objects interface was released. It is based on the [Grammar of Graphics](https://vita.had.co.nz/papers/layered-grammar.pdf), which is what R's [ggplot2](https://ggplot2.tidyverse.org/) is also based on. So, if you've created charts in R before, this should be a bit familiar. It also follows along with the VAD textbook's terminology of marks and channels."
      ],
      "metadata": {
        "id": "HzY4cdr-X1Bi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "First, we need to import the library:"
      ],
      "metadata": {
        "id": "qQ94cCp7bDRl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import seaborn as sns\n",
        "import seaborn.objects as so"
      ],
      "metadata": {
        "id": "OViwpXw9bG0m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Every Seaborn Objects chart uses the [`so.Plot()`](https://seaborn.pydata.org/generated/seaborn.objects.Plot.html) function."
      ],
      "metadata": {
        "id": "TewGjVTIdyoW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "so.Plot()"
      ],
      "metadata": {
        "id": "nMQ3-Vkjdz8J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note that inside the notebook environment, you don't need to explicitly call the [`show()`](https://seaborn.pydata.org/generated/seaborn.objects.Plot.show.html) function, but if you want to run these scripts locally, you'll need to add `.show()` as the final command: `so.Plot().show()`"
      ],
      "metadata": {
        "id": "MIR5CVo2lSKo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "`so.Plot()` takes several parameters, the most important of which are `data`, `x`, and `y`. As you might expect, `data` specifies the dataframe to use.\n",
        "\n",
        "Most charts will map data to the position channels, so `x` specifies the attribute (column in the dataframe) to be mapped to the horizontal position *channel*, and `y` specifies the attribute to be mapped to the vertical position *channel*."
      ],
      "metadata": {
        "id": "tkLaKOvag4CS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(so.Plot(data=df_2000,\n",
        "         x='fertility',\n",
        "         y='life_expect')\n",
        ")"
      ],
      "metadata": {
        "id": "YuTz-gg1iFYg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The axes are set, but there's nothing in the chart because no *mark* has been specified.  That's where the `add()` function comes in.\n",
        "\n",
        "There are several types of marks available ([full list](https://seaborn.pydata.org/api.html#mark-objects)).  Some of the more common are [`so.Dot()`](https://seaborn.pydata.org/generated/seaborn.objects.Dot.html), [`so.Line()`](https://seaborn.pydata.org/generated/seaborn.objects.Line.html), [`so.Bar()`](https://seaborn.pydata.org/generated/seaborn.objects.Bar.html), and [`so.Area()`](https://seaborn.pydata.org/generated/seaborn.objects.Area.html)."
      ],
      "metadata": {
        "id": "TkLdyjY3iVnw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(so.Plot(data=df_2000,\n",
        "         x='fertility',\n",
        "         y='life_expect')\n",
        "  .add(so.Dot())\n",
        ")"
      ],
      "metadata": {
        "id": "pVlutWqbjSIe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Adding Channels"
      ],
      "metadata": {
        "id": "j113Trll67UW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can apply additional channels to the marks by specifying them as parameters to `so.Plot()`."
      ],
      "metadata": {
        "id": "G3OUz5itjsl-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(so.Plot(data=df_2000,\n",
        "         x='fertility',\n",
        "         y='life_expect',\n",
        "         color='cluster')\n",
        "  .add(so.Dot())\n",
        ")"
      ],
      "metadata": {
        "id": "ShZ7c8pUj0lY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A key thing to note is that when you set `color` in the `Plot()` function, it *maps* the channel to the data. If you set the color in the `Dot()` function, it sets the color directly (i.e., it's not tied to the data).\n",
        "\n",
        "You can see the difference between *mapping* color and *setting* color below."
      ],
      "metadata": {
        "id": "iTnjJj4Snj24"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(so.Plot(data=df_2000,\n",
        "         x='fertility',\n",
        "         y='life_expect')\n",
        "  .add(so.Dot(color=\"green\"))\n",
        ")"
      ],
      "metadata": {
        "id": "bue7iecpV_WP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can apply the shape channel to point marks using the [`marker`](https://seaborn.pydata.org/tutorial/properties.html#marker) property."
      ],
      "metadata": {
        "id": "oBaD3g0w54Ug"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(so.Plot(data=df_2000,\n",
        "         x='fertility',\n",
        "         y='life_expect',\n",
        "         marker='cluster')\n",
        "  .add(so.Dot())\n",
        ")"
      ],
      "metadata": {
        "id": "DFvrzTSa53PM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can add more channels, like combining color and size."
      ],
      "metadata": {
        "id": "xqBeFIL-6f4I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(so.Plot(data=df_2000,\n",
        "         x='fertility',\n",
        "         y='life_expect',\n",
        "         color='cluster',\n",
        "         pointsize='pop')\n",
        "  .add(so.Dot())\n",
        ")"
      ],
      "metadata": {
        "id": "Ifv33lER6EPN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Questions"
      ],
      "metadata": {
        "id": "PE1TWAti6siy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "🚨\n",
        "\n",
        "<font color='red'>**Q1:**</font> *What happens if you set color in both `Plot()` and `Dot()`?*\n",
        "\n",
        "👇 Create a new cell and enter the code below."
      ],
      "metadata": {
        "id": "3zC9ODW0XqZk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "🚨\n",
        "\n",
        "<font color='red'>**Q2:**</font> *Can you set the marker type in `Dot()` as you can with color?* (See [marker](https://seaborn.pydata.org/tutorial/properties.html#marker))\n",
        "\n",
        "👇 Create a new cell and enter the code below."
      ],
      "metadata": {
        "id": "yS_eA8CZ7YNA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "🚨\n",
        "\n",
        "<font color='red'>**Q3:**</font> *Can you map two different channels to the same attribute (called [redundant encoding](https://visualthinking.psych.northwestern.edu/projects/redundantencoding.html))?*  \n",
        "\n",
        "👇 Create a new cell and enter the code below."
      ],
      "metadata": {
        "id": "EnBvTGJ64mkU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "🚨\n",
        "\n",
        "We've seen that when we map a channel other than x or y to an attribute, the values get displayed in the legend.\n",
        "\n",
        "<font color='red'>**Q4:**</font>  *What happens if you map a channel to the `country` attribute, which has lots of unique items? Which Ch 5 principle, discriminability or separability, is being violated here?*\n",
        "\n",
        "👇 Create a new cell and enter the code below."
      ],
      "metadata": {
        "id": "CPSAf7NX42_Y"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "🚨\n",
        "\n",
        "In the example above where we mapped color to `cluster`, the colors were ordered from lighter to darker. In this dataset, `cluster` is a categorical attribute.\n",
        "\n",
        "<font color='red'>**Q5:**</font> *What Ch 5 principle is being violated when mapping an ordered channel to a categorical attribute?*"
      ],
      "metadata": {
        "id": "ch_lmDWo-Ss4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "🚨\n",
        "\n",
        "In all of the above examples, we have mapped `fertility` and `life_expect` to the x and y channels (both representing position on common scale).\n",
        "\n",
        "<font color='red'>**Q6:**</font> *What Ch 5 principle refers to the importance of the attribute matching the salience, or noticeability, of the channel? What does this say about the implied importance of `fertility` and `life_expect`?*"
      ],
      "metadata": {
        "id": "cbGRDuBE-3Dx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "🚨\n",
        "\n",
        "To test this out, put `pop` as one of the attributes on either the x or y axis and map `pointsize` to the attribute that you removed from x or y.\n",
        "\n",
        "👇 Create a new cell and enter the code below.\n",
        "\n",
        "<font color='red'>**Q7:**</font> *Are you still able to easily see the relationship between `fertility` and `life_expect`?*"
      ],
      "metadata": {
        "id": "xrM70vUNAHLQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "🚨\n",
        "\n",
        "<font color='red'>**Q8:**</font> *In the example above where we mapped pointsize to `pop` and color to `cluster`, what Ch 5 principle should we be concerned about?*"
      ],
      "metadata": {
        "id": "uIgNi9rEC7OX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Marks Other than Dot"
      ],
      "metadata": {
        "id": "psSY33nm8F2y"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can use a line mark as a connector between points.  We can add multiple marks by including more `add()` functions (in this example, both points and lines)."
      ],
      "metadata": {
        "id": "xM9TSEzcOWnD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(so.Plot(data=df_US, x='year', y='fertility')\n",
        "  .add(so.Dot())\n",
        "  .add(so.Line())\n",
        ")"
      ],
      "metadata": {
        "id": "Fj_yGbQmOgj5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can use color to split items by a categorical value.  Below, we'll map the color channel to country name and when we use lines, we'll get a different color line for each country."
      ],
      "metadata": {
        "id": "5y1SWCXYIEiD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(so.Plot(data=df_5countries,\n",
        "         x='year',\n",
        "         y='fertility',\n",
        "         color='country')\n",
        "  .add(so.Line())\n",
        ")"
      ],
      "metadata": {
        "id": "h2SnqQFvITJz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note that the colors used here different *hues*, so they are appropriate for categorical data."
      ],
      "metadata": {
        "id": "y_MXkBi2al64"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also show this same chart with a filled area."
      ],
      "metadata": {
        "id": "D7Kihkq1SqXp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(so.Plot(data=df_5countries, x='year', y='fertility',\n",
        "         color='country')\n",
        "  .add(so.Area())\n",
        ")"
      ],
      "metadata": {
        "id": "0xufqggXPc1H"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Below we use a line mark with horizontal spatial region based on country name and position on the vertical axis based on population. Although we call it a line mark in VAD terminology, it's called a bar mark in Seaborn. You can think of a bar as essentially a thick line."
      ],
      "metadata": {
        "id": "uK2-UjGpN0BC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(so.Plot(data=df_2000c1, x='country', y='pop')\n",
        "  .add(so.Bar())\n",
        ")"
      ],
      "metadata": {
        "id": "XFvKYo2YM_nB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can flip this so it's more readable and map the country name to the vertical spatial region, just by swapping the x and y parameters."
      ],
      "metadata": {
        "id": "85WZ_Gh1ODrj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(so.Plot(data=df_2000c1, y='country', x='pop')\n",
        "  .add(so.Bar())\n",
        ")"
      ],
      "metadata": {
        "id": "J640QNjqOL-I"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}