REU_DataVis_Python_Seaborn.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "REU-DataVis-Python-Seaborn.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyM/Lk37+Ypw0hDdRlNgrVYN",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/odu-cs432-websci/public/blob/main/REU_DataVis_Python_Seaborn.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hdzLxxc9Q4ES"
      },
      "source": [
        "# REU Site Data Vis with Python using Seaborn Notebook"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Setup\n",
        "\n",
        "Initial setup includes loading any needed libraries (Matplotlib, Numpy, Pandas, Seaborn) and setting the default style of charts."
      ],
      "metadata": {
        "id": "gmZgSO4G59gB"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IZeTiREWlOLy"
      },
      "source": [
        "import matplotlib.pyplot as plt  # will need some Matplotlib functions\n",
        "import numpy as np \n",
        "import seaborn as sns\n",
        "import pandas as pd              # will use Pandas for data manipulation\n",
        "sns.set(rc={\"figure.figsize\":(8, 6)}) # width=8, height=6\n",
        "sns.set_style(\"white\")   # white background, no grid"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "For a few of the charts, we'll use a dataset about the characteristics of penguins from the Palmer Station in Antarctica.  It's one of the datasets directly accessible by the Seaborn function `load_dataset()`. \n",
        "\n",
        "Original penguin data: https://github.com/allisonhorst/palmerpenguins   \n",
        "Seaborn datasets: https://github.com/mwaskom/seaborn-data\n"
      ],
      "metadata": {
        "id": "BdRgX7wi13Xo"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wpTt3spyo6u6"
      },
      "source": [
        "penguins = sns.load_dataset(\"penguins\")\n",
        "penguins.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PsnBm1atRBuS"
      },
      "source": [
        "## Scatterplot"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GB7VbsgQqBB5"
      },
      "source": [
        "Here's a basic scatterplot, showing the relationship between flipper length and body mass.  \n",
        "\n",
        "`scatterplot()` - https://seaborn.pydata.org/generated/seaborn.scatterplot.html"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sns.scatterplot(data=penguins, x=\"flipper_length_mm\", y=\"body_mass_g\")"
      ],
      "metadata": {
        "id": "RqCPVzXR07pa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we would expect, the longer the flipper, the heavier the penguin."
      ],
      "metadata": {
        "id": "mcR3H2EM3N0Q"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QuTrMBn13HeR"
      },
      "source": [
        "Now we're going to color the dots based on the species of penguin. Since this is categorical data, we use color `hue`. \n",
        "\n",
        "The `scatterplot()` function returns an Axes object, so we'll name the resulting plot `ax`.  Then we can use `ax` to modifiy the axis labels and give the chart a title that describes what's going on. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0E3ItFN93HCq"
      },
      "source": [
        "ax = sns.scatterplot(data=penguins, x=\"flipper_length_mm\", y=\"body_mass_g\", hue=\"species\")\n",
        "ax.set_xlabel ('Flipper Length (mm)')\n",
        "ax.set_ylabel ('Penguin Body Mass (g)')\n",
        "ax.set_title('The longer the flipper, the heavier the penguin');   # use a semicolon at the end, so won't print output"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here's one example of some of the differences between using the Axes-level function `scatterplot()` and the Figure-level function `relplot()`.  Note that to access the title and labels, we need to access the Axes object, using `g.ax`.\n",
        "\n",
        "`replot()` - https://seaborn.pydata.org/generated/seaborn.relplot.html"
      ],
      "metadata": {
        "id": "tIRdT0Is4JRs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "g = sns.relplot(data=penguins, x=\"flipper_length_mm\", y=\"body_mass_g\", hue=\"species\", kind=\"scatter\")\n",
        "g.ax.set_xlabel ('Flipper Length (mm)')\n",
        "g.ax.set_ylabel ('Penguin Body Mass (g)')\n",
        "g.ax.set_title('The longer the flipper, the heavier the penguin');"
      ],
      "metadata": {
        "id": "7qDi-g4h3s0Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_pzMwxshRDRM"
      },
      "source": [
        "## Bar Chart"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Given a set of data, `barplot()` will calculate the mean and confidence interval for the set of observations.  In this example, it's showing the average body mass (g) over all penguins of each species in our dataset.\n",
        "\n",
        "`barplot()` - https://seaborn.pydata.org/generated/seaborn.barplot.html"
      ],
      "metadata": {
        "id": "zUspjlUpV7ac"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sns.barplot(data=penguins, x=\"species\", y=\"body_mass_g\");"
      ],
      "metadata": {
        "id": "0BIFrWjLVp5F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Seaborn also has a `countplot()` function that will create a bar chart of counts.  In this example, we're showing the number of penguins in each species.\n",
        "\n",
        "`countplot()` - https://seaborn.pydata.org/generated/seaborn.countplot.html"
      ],
      "metadata": {
        "id": "18ElOPU6WrGB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sns.countplot(data=penguins, x=\"species\");"
      ],
      "metadata": {
        "id": "mG7RWmIyXaQq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "By default, the bars are sorted in alphabetical order.  To order them by the counts, we can add the `order` parameter."
      ],
      "metadata": {
        "id": "oPpYlorOXhCi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sns.countplot(x=\"species\", data=penguins, order=penguins['species'].value_counts().index);"
      ],
      "metadata": {
        "id": "XjwTiAns-2Sn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pPqq_1DycUnS"
      },
      "source": [
        "For charts that have long x-axis labels, you can turn the chart sideways for a horizontal bar chart. Just switch x and y axes.  This also demonstrates making all bars the same color."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ax = sns.countplot(y=\"species\", data=penguins, order=penguins['species'].value_counts().index, color=\"steelblue\")\n",
        "ax.set_xlabel(\"Number of Penguins\")\n",
        "ax.set_ylabel(\"Species\")\n",
        "ax.set_title(\"There are over twice as many Adelie penguins as Chinstrap penguins\");"
      ],
      "metadata": {
        "id": "uRCjaDHRXxKp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Both `barplot()` and `countplot()` are Axes-level functions under the Figure-level function `catplot()`, for categorical plot.\n",
        "\n",
        "`catplot()` - https://seaborn.pydata.org/generated/seaborn.catplot.html"
      ],
      "metadata": {
        "id": "5TYt2cOXY8-X"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2viXqJtwREmc"
      },
      "source": [
        "## Line Chart"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Line charts are typically used for timeseries, when the x-axis is a temporal.  For this, we'll use a different dataset.  The flights dataset shows the number of passengers per month between Jan 1949 and Dec 1960."
      ],
      "metadata": {
        "id": "KYOdXRJEZZvN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "flights = sns.load_dataset(\"flights\")\n",
        "flights.head()"
      ],
      "metadata": {
        "id": "DrLI0jM2uwAC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we want to examine the most popular months for flying, we can group the data by month and sum the number of passengers.  `reset_index()` just puts the data back into a DataFrame."
      ],
      "metadata": {
        "id": "R7mwUGBHZrSi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "per_month = flights.groupby('month')['passengers'].sum().reset_index(name='passengers')\n",
        "per_month"
      ],
      "metadata": {
        "id": "zPGwRCuFx99-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We'll use the Axes-level function `lineplot()`, which has a similar setup as the other charts we've seen so far. \n",
        "\n",
        "`lineplot()` - https://seaborn.pydata.org/generated/seaborn.lineplot.html"
      ],
      "metadata": {
        "id": "zpxvBpa4Z9k3"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mb6ZvhQz2Ee3"
      },
      "source": [
        "sns.lineplot(data=per_month, x=\"month\", y=\"passengers\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also use the entire dataset and `lineplot()` will calculate the mean number of passengers in each month and 95% confidence interval."
      ],
      "metadata": {
        "id": "3FZeKNnIaQ7t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sns.lineplot(data=flights, x=\"month\", y=\"passengers\");"
      ],
      "metadata": {
        "id": "ATr9NO-_aYd0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we want to split this out and show a line for each year, we can use the `hue` option to specify that.  Note that to get the full set of items in the legend to display, we have to use `legend=\"full\"`. The second line shows how to move the legend outside of the chart area."
      ],
      "metadata": {
        "id": "0EjXkdxkakzU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ax = sns.lineplot(data=flights, x=\"month\", y=\"passengers\", hue=\"year\", legend=\"full\")\n",
        "plt.legend(bbox_to_anchor=(1.02, 1), loc='upper left');\n",
        "ax.set_xlabel (\"\")\n",
        "ax.set_ylabel (\"Passengers\")\n",
        "ax.set_title (\"Summer months see an increase in passengers over all years\");"
      ],
      "metadata": {
        "id": "mKy5OUhMGyqH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note that the Figure-level `relplot()` puts the legend outside the plot by default.  Example is also demonstrating the use of the `palette` option to choose the colormap."
      ],
      "metadata": {
        "id": "KKaRBKek6BEV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "g = sns.relplot(data=flights, x=\"month\", y=\"passengers\", hue=\"year\", legend=\"full\", kind=\"line\", palette=\"tab20\")\n",
        "g.ax.set_xlabel (\"\")\n",
        "g.ax.set_ylabel (\"Passengers\")\n",
        "g.ax.set_title (\"Summer months see an increase in passengers over all years\");"
      ],
      "metadata": {
        "id": "3TznM9cC566F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Stacked Bar Chart"
      ],
      "metadata": {
        "id": "tsfGoH85-byP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Seaborn doesn't directly support stacked bar charts. You can find pages online that talk about creating charts for the bars separately and plotting them on top of each other, but that's a lot of trouble.  Pandas `plot()` though does easily support stacked bars.\n",
        "\n",
        "We want to create a stacked bar chart that shows the number of male and female penguins in each species. First, we'll group our penguins by species and sex and count the rows in each set."
      ],
      "metadata": {
        "id": "nu-wfZuxBXcr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num_species_sex = penguins.groupby(['species', 'sex']).size().reset_index(name='count')\n",
        "num_species_sex"
      ],
      "metadata": {
        "id": "LA4WyDoDCt2m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "For the stacked bar chart, we need the data in a different format, so we can use `pivot_table()` to transform the data."
      ],
      "metadata": {
        "id": "TAfQfokVeSuF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "penguin_pivot = pd.pivot_table(data=num_species_sex, index=['species'], columns=['sex'], values='count')\n",
        "penguin_pivot"
      ],
      "metadata": {
        "id": "ePtTxrTmDUcg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "With our data in the proper format, we can create the stacked bar chart using `plot.bar()` and the `stacked=True` option.\n",
        "\n",
        "`plot.bar()` - https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.bar.html"
      ],
      "metadata": {
        "id": "8_b0ce9Pedr5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "penguin_pivot.plot.bar(stacked=True);"
      ],
      "metadata": {
        "id": "A96-ZLQLAFiZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Use `plot.barh()` to create a horizontal stacked bar chart.\n",
        "\n",
        "`plot.barh()` - https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.barh.html"
      ],
      "metadata": {
        "id": "iasCXvDgJuxm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "penguin_pivot.plot.barh(stacked=True);"
      ],
      "metadata": {
        "id": "0V5qQPnkJZey"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Grouped Bar Chart"
      ],
      "metadata": {
        "id": "3zHUIj1uAGAy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "For a grouped bar chart, we just need to add the `hue` option to a bar chart (either `countplot` or `barplot`).  In this example, we'll look at which island the penguins were found on."
      ],
      "metadata": {
        "id": "gaY8_HOnfUCA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sns.countplot(data=penguins, x=\"species\", hue=\"island\")"
      ],
      "metadata": {
        "id": "vpwLcvGmAKVh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Pie Chart"
      ],
      "metadata": {
        "id": "Kakoma6aEaBL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Pandas Plot has a `pie()` function to generate pie charts. \n",
        "\n",
        "`plot.pie()` - https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.pie.html  \n",
        "*Note: The example pie charts on that page make no sense.*"
      ],
      "metadata": {
        "id": "sSSImRs2gIkX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = penguins.groupby(\"species\").size()\n",
        "data"
      ],
      "metadata": {
        "id": "Gu6ahJ0GFAmz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The data can be set up as a Series rather than a DataFrame, so we don't need to transform the result."
      ],
      "metadata": {
        "id": "T3FjBY_sg28C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data.plot.pie(autopct=\"%.1f%%\");"
      ],
      "metadata": {
        "id": "zqAaQTweEbKR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Heatmap"
      ],
      "metadata": {
        "id": "vpXW3p9dFtyE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "For a heatmap, we need the data formatted so that we have 2D data (2 keys).  We can do this using `pivot()` to create a pivot table.  We specify the row attribute (key 1), column attribute (key 2), and values."
      ],
      "metadata": {
        "id": "0fjx7eieMN7A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "flights.head()"
      ],
      "metadata": {
        "id": "hhholHaiMak2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pivot = flights.pivot(\"month\", \"year\", \"passengers\")\n",
        "pivot.head()"
      ],
      "metadata": {
        "id": "dUwbyMosFudw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Once we have the data in the proper format, we can use the `heatmap()` function to generate the heatmap.\n",
        "\n",
        "`heatmap()` - https://seaborn.pydata.org/generated/seaborn.heatmap.html"
      ],
      "metadata": {
        "id": "E9SLv3rRMocs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sns.heatmap(pivot);"
      ],
      "metadata": {
        "id": "qwUmVtNSL64j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can use the `cmap` option to choose a Matplotlib colormap. See \"Choosing Colormaps in Matplotlib\", https://matplotlib.org/stable/tutorials/colors/colormaps.html"
      ],
      "metadata": {
        "id": "Z04hMOIdNHV4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sns.heatmap(pivot, cmap=\"plasma\");"
      ],
      "metadata": {
        "id": "KtpqGvSmNTZG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qM1518i8RGv5"
      },
      "source": [
        "## Scatterplot Matrix"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "02HbPW-7-yo4"
      },
      "source": [
        "We can use the `pairplot()` function to plot a scatterplot matrix.  It plots \"pairwise relationships in a dataset\". Instead of plotting the data in the diagonals, it plots a histogram of that attribute. \n",
        "\n",
        "`pairplot()` - https://seaborn.pydata.org/generated/seaborn.pairplot.html"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-tLsxW0Z-YQ6"
      },
      "source": [
        "sns.pairplot(penguins);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "By default, `pairplot()` plots all quantitative attributes, but you can specify particular attributes to include using the `vars` option."
      ],
      "metadata": {
        "id": "fVNt82LrQSSh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "g = sns.pairplot(penguins, vars=['bill_length_mm', 'flipper_length_mm', 'body_mass_g']);"
      ],
      "metadata": {
        "id": "YKPS1RqAQJP8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NneMJx2ZRIL1"
      },
      "source": [
        "## Histogram"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g0eXhJqf52Nd"
      },
      "source": [
        "A histogram uses the data from just a single attribute.  We use the `histplot()` function and pass in a specific column of the data.\n",
        "\n",
        "`histplot()` - https://seaborn.pydata.org/generated/seaborn.histplot.html"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gfKq7f4H5pCl"
      },
      "source": [
        "sns.histplot(penguins['body_mass_g']);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZEiOqNK78bkI"
      },
      "source": [
        "We can use the `bins` option to change the number of bins in the histogram."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "phpm155a9o01"
      },
      "source": [
        "sns.histplot(penguins['body_mass_g'], bins=100);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V2RG95LkRKQe"
      },
      "source": [
        "## Boxplot"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2NWJOTNE5PKx"
      },
      "source": [
        "We can use `boxplot()` to create a boxplot for an attribute.  If you only supply the dataset, the function will create a boxplot for each of the quantitative attributes.  If you supply the `y` option, it will create a single boxplot for that attribute only.  If you add in `x` with a categorical attribute, it will split the data accordingly and produce a boxplot for each category.\n",
        "\n",
        "`boxplot()` - https://seaborn.pydata.org/generated/seaborn.boxplot.html"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sns.boxplot(data=penguins, y=\"body_mass_g\");"
      ],
      "metadata": {
        "id": "CU_9KjRqTHyq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QAZ2z22C4qmY"
      },
      "source": [
        "sns.boxplot(data=penguins, x=\"species\", y=\"body_mass_g\"); "
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}