seaborn_uni_bivariate_plotting.ipynb

{
  "cells": [
    {
      "metadata": {
        "_uuid": "4f61bee808da4c7d72017ebe6a5348e10499695f",
        "_cell_guid": "38b8db4c-7e28-4c7b-8079-d6a633025be3"
      },
      "cell_type": "markdown",
      "source": "# Plotting with seaborn\n\n<table>\n<tr>\n<td><img src=\"https://i.imgur.com/3cYy56H.png\" width=\"350px\"/></td>\n<td><img src=\"https://i.imgur.com/V9jAreo.png\" width=\"350px\"/></td>\n<td><img src=\"https://i.imgur.com/5a6dwtm.png\" width=\"350px\"/></td>\n<td><img src=\"https://i.imgur.com/ZSsHzrA.png\" width=\"350px\"/></td>\n</tr>\n<tr>\n<td style=\"font-weight:bold; font-size:16px;\">Count (Bar) Plot</td>\n<td style=\"font-weight:bold; font-size:16px;\">KDE Plot</td>\n<td style=\"font-weight:bold; font-size:16px;\">Joint (Hex) Plot</td>\n<td style=\"font-weight:bold; font-size:16px;\">Violin Plot</td>\n</tr>\n<tr>\n<td>sns.countplot()</td>\n<td>sns.kdeplot()</td>\n<td>sns.jointplot()</td>\n<td>sns.violinplot()</td>\n</tr>\n<tr>\n<td>Good for nominal and small ordinal categorical data.</td>\n<td>Good for interval data.</td>\n<td>Good for interval and some nominal categorical data.</td>\n<td>Good for interval data and some nominal categorical data.</td>\n</tr>\n</table>\n\nIn the previous two sections we explored data visualization using the `pandas` built-in plotting tools. In this section, we'll do the same with `seaborn`.\n\n`seaborn` is a standalone data visualization package that provides many extremely valuable data visualizations in a single package. It is generally a much more powerful tool than `pandas`; let's see why."
    },
    {
      "metadata": {
        "collapsed": true,
        "_uuid": "3e6df9a405b1c795d8b18401eab8b1bf64d4cb8c",
        "_cell_guid": "dc06ff32-9804-49ed-b76a-5076774adb8b",
        "trusted": true
      },
      "cell_type": "code",
      "source": "import pandas as pd\nreviews = pd.read_csv(\"../input/wine-reviews/winemag-data_first150k.csv\", index_col=0)\nimport seaborn as sns\nfrom matplotlib import pyplot as plt",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "58ea16434bcf678af906dd3c8e2b1a2b51c54345",
        "_cell_guid": "9397fd15-d742-41f3-9209-5b17a33ea3b7"
      },
      "cell_type": "markdown",
      "source": "## Countplot\n\nThe `pandas` bar chart becomes a `seaborn` `countplot`."
    },
    {
      "metadata": {
        "_uuid": "0e8836597f86822908b6a10f08296bed46a80483",
        "_cell_guid": "0ffc5715-142b-4bd7-a4b6-8f1811e613c0",
        "trusted": true
      },
      "cell_type": "code",
      "source": "sns.countplot(reviews['points'])",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "8207ca9c7173fc6517db698fc46e6c11134affcf",
        "_cell_guid": "3efba799-aa2f-4ebf-af8a-e91064661d21"
      },
      "cell_type": "markdown",
      "source": "Comparing this chart with the bar chart from two notebooks ago, we find that, unlike `pandas`, `seaborn` doesn't require us to shape the data for it via `value_counts`; the `countplot` (true to its name) aggregates the data for us!\n\n`seaborn` doesn't have a direct analogue to the line or area chart. Instead, the package provides a `kdeplot`:"
    },
    {
      "metadata": {
        "_uuid": "ef56a55e6a5ab98c7a0c1ec01892be7351daa81b",
        "_cell_guid": "56482637-9022-48da-b99e-a7536e53a55f"
      },
      "cell_type": "markdown",
      "source": "## KDE Plot"
    },
    {
      "metadata": {
        "_uuid": "e41c6e54ed366b6c79e5be1360d7648d4db98c81",
        "_cell_guid": "fcdc8bb0-a4be-475b-94d8-469b1d752c09",
        "trusted": true
      },
      "cell_type": "code",
      "source": "sns.kdeplot(reviews.query('price < 200').price)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "ef5fa23c8a444ebf40ec40e378a726fb4209c2ef",
        "_cell_guid": "d4e2d513-7d16-497f-87a2-84ab36d1c3c4"
      },
      "cell_type": "markdown",
      "source": "KDE, short for \"kernel density estimate\", is a statistical technique for smoothing out data noise. It addresses an important fundamental weakness of a line chart: it will buff out outlier or \"in-betweener\" values which would cause a line chart to suddenly dip.\n\nFor example, suppose that there was just one wine priced 19.93\\$, but several hundred prices 20.00\\$. If we were to plot the value counts in a line chart, our line would dip very suddenly down to 1 and then back up to around 1000 again, creating a strangely \"jagged\" line. The line chart with the same data, shown below for the purposes of comparison, has exactly this problem!"
    },
    {
      "metadata": {
        "_uuid": "89d919218ca76b700a276fbd8826de131e3ebab0",
        "_cell_guid": "88c9485f-5f60-48db-a23f-3b237e433553",
        "trusted": true
      },
      "cell_type": "code",
      "source": "reviews[reviews['price'] < 200]['price'].value_counts().sort_index().plot.line()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "41f40c60d5821b078d33905592e56db921e1a789",
        "_cell_guid": "31111f7a-c16f-4847-ad72-195b9aaf81b8"
      },
      "cell_type": "markdown",
      "source": "A KDE plot is better than a line chart for getting the \"true shape\" of interval data. In fact, I recommend always using it instead of a line chart for such data.\n\nHowever, it's a worse choice for ordinal categorical data. A KDE plot expects that if there are 200 wine rated 85 and 400 rated 86, then the values in between, like 85.5, should smooth out to somewhere in between (say, 300). However, if the value in between can't occur (wine ratings of 85.5 are not allowed), then the KDE plot is fitting to something that doesn't exist. In these cases, use a line chart instead.\n\nKDE plots can also be used in two dimensions."
    },
    {
      "metadata": {
        "_uuid": "2ee4987ede1d583dda57d5c09ad5fe9057f0723d",
        "_cell_guid": "047332b2-bdff-4a46-a9fe-8a673c30c5c1",
        "trusted": true
      },
      "cell_type": "code",
      "source": "sns.kdeplot(reviews[reviews['price'] < 200].loc[:, ['price', 'points']].dropna().sample(5000))",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "c0c76d49e572f430aac62cb4d4e2f39615a6bc0b",
        "_cell_guid": "35d53cb7-fce4-44bb-a529-84e780ced888"
      },
      "cell_type": "markdown",
      "source": "Bivariate KDE plots like this one are a great alternative to scatter plots and hex plots. They solve the same data overplotting issue that scatter plots suffer from and hex plots address, in a different but similarly visually appealing. However, note that bivariate KDE plots are very computationally intensive. We took a sample of 5000 points in this example to keep compute time reasonable."
    },
    {
      "metadata": {
        "_uuid": "febe6f453d21aefa958873c2b2f31f648af96481",
        "_cell_guid": "437a0051-1ea2-48c6-afb0-746be27d81d3"
      },
      "cell_type": "markdown",
      "source": "## Distplot\n\nThe `seaborn` equivalent to a `pandas` histogram is the `distplot`. Here's an example:"
    },
    {
      "metadata": {
        "_uuid": "2fb9fa2ac02895f84c0b07d2bec710f133e7a993",
        "_cell_guid": "6e45384f-cf4c-46e5-8ee2-a47f199ec4b1",
        "trusted": true
      },
      "cell_type": "code",
      "source": "sns.distplot(reviews['points'], bins=10, kde=False)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "73f53b37ee47f27575a23c62bcf418a57ffe2f09",
        "_cell_guid": "f0639d7e-f08c-42f4-baca-e4226e4df863"
      },
      "cell_type": "markdown",
      "source": "The `distplot` is a composite plot type. In the example above we've turned off the `kde` that's included by default, and manually set the number of bins to 10 (two possible ratings per bin), to get a clearer picture."
    },
    {
      "metadata": {
        "_uuid": "84569d191b8e65dd291d984c793dddb5d0fd3f6b",
        "_cell_guid": "c35f185c-1be3-47dd-8bb9-1d10e5699d9c"
      },
      "cell_type": "markdown",
      "source": "## Scatterplot and hexplot"
    },
    {
      "metadata": {
        "_uuid": "7d890d0dbb68ebceb3ac48442c5c3cac8a3ddb13",
        "_cell_guid": "020f4f72-9edc-436b-a1df-15b6df4a1a46"
      },
      "cell_type": "markdown",
      "source": "To plot two variables against one another in `seaborn`, we use `jointplot`."
    },
    {
      "metadata": {
        "_uuid": "33dea6ec448556990f191a1abd92f5935160e1e7",
        "_cell_guid": "6d6f9edf-4cc8-4aa4-8193-896e8ab712a0",
        "trusted": true
      },
      "cell_type": "code",
      "source": "sns.jointplot(x='price', y='points', data=reviews[reviews['price'] < 100])",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "b576254a3f92026955c123c465a337e42610af21",
        "_cell_guid": "e52d9f24-64a5-4235-ae24-cbb535ebda94"
      },
      "cell_type": "markdown",
      "source": "Notice that this plot comes with some bells and whistles: a correlation coefficient is provided, along with histograms on the sides. These kinds of composite plots are a recurring theme in `seaborn`. Other than that, the `jointplot` is just like the `pandas` scatter plot.\n\nAs in `pandas`, we can use a hex plot (by simply passing `kind='hex'`) to deal with overplotting:"
    },
    {
      "metadata": {
        "_uuid": "a9c79f960286c9a2d85edac768401474bf3f441a",
        "_cell_guid": "59713edb-16a3-4511-b61a-45716e8acf70",
        "trusted": true
      },
      "cell_type": "code",
      "source": "sns.jointplot(x='price', y='points', data=reviews[reviews['price'] < 100], kind='hex', \n              gridsize=20)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "445e536d348d4746b092981a944bc664cd7d0c76",
        "_cell_guid": "65121cde-56ed-40a9-8221-ba18a8741158"
      },
      "cell_type": "markdown",
      "source": "## Boxplot and violin plot\n\n`seaborn` provides a boxplot function. It creates a statistically useful plot that looks like this:"
    },
    {
      "metadata": {
        "_uuid": "518f21f75c0bef67b685379e95deed90e4b6037e",
        "_cell_guid": "46e57167-2d55-405e-9cf5-e7d4f6ec9224",
        "trusted": true
      },
      "cell_type": "code",
      "source": "df = reviews[reviews.variety.isin(reviews.variety.value_counts().head(5).index)]\n\nsns.boxplot(\n    x='variety',\n    y='points',\n    data=df\n)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "0aee5e04c60e8c432b6630114305c78403859ca7",
        "_cell_guid": "3f2d2928-05a7-4796-8d77-bbf039cfd8c8"
      },
      "cell_type": "markdown",
      "source": "The center of the distributions shown above is the \"box\" in boxplot. The top of the box is the 75th percentile, while the bottom is the 25th percentile. In other words, half of the data is distributed within the box! The green line in the middle is the median.\n\nThe other part of the plot, the \"whiskers\", shows the extent of the points beyond the center of the distribution. Individual circles beyond *that* are outliers.\n\nThis boxplot shows us that although all five wines recieve broadly similar ratings, Bordeaux-style wines tend to be rated a little higher than a Chardonnay.\n\nBoxplots are great for summarizing the shape of many datasets. They also don't have a limit in terms of numeracy: you can place as many boxes in the plot as you feel comfortable squeezing onto the page.\n\nHowever, they only work for interval variables and nominal variables with a large number of possible values; they assume your data is roughly normally distributed (otherwise their design doesn't make much sense); and they don't carry any information about individual values, only treating the distribution as a whole.\n\nI find the slightly more advanced `violinplot` to be more visually enticing, in most cases:"
    },
    {
      "metadata": {
        "scrolled": false,
        "_uuid": "6e972117854b4398fb8873eb25fab41a7c7d8b33",
        "_cell_guid": "0c88d116-c1ca-4240-873d-d58f4f10b7ab",
        "trusted": true
      },
      "cell_type": "code",
      "source": "sns.violinplot(\n    x='variety',\n    y='points',\n    data=reviews[reviews.variety.isin(reviews.variety.value_counts()[:5].index)]\n)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "a32780a72c2d5ee1b2998c31dd34f80016fb5cb7",
        "_cell_guid": "1017c1be-745c-405a-bd7f-62c06ae70ab8"
      },
      "cell_type": "markdown",
      "source": "A `violinplot` cleverly replaces the box in the boxplot with a kernel density estimate for the data. It shows basically the same data, but is harder to misinterpret and much prettier than the utilitarian boxplot."
    },
    {
      "metadata": {
        "_uuid": "b57fa929a624c7679af8c2e792703fc491dc746f",
        "_cell_guid": "b9e4770d-8d21-42bc-8462-1efafb4e94cf"
      },
      "cell_type": "markdown",
      "source": "## Why seaborn?\n\nHaving now seen both `pandas` plotting and the `seaborn` library in action, we are now in a position to compare the two and decide when to use which for what.\n\nRecall the data we've been working with in this tutorial is in:"
    },
    {
      "metadata": {
        "_uuid": "b786b6567d641ac84d16257510e7cfaf28aa6c4f",
        "_cell_guid": "487d140a-1046-406e-9fd8-b1b040b9f8d8",
        "trusted": true
      },
      "cell_type": "code",
      "source": "reviews.head()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "872af24634858957b7cd62e2add0c6306047d5e8",
        "_cell_guid": "1b3b2bd3-e60c-4181-b23b-45bfd984a307"
      },
      "cell_type": "markdown",
      "source": "This data is in a \"record-oriented\" format. Each individual row is a single record (a review); in aggregate, the list of all rows is the list of all records (all reviews). This is the format of choice for the most kinds of data: data corresponding with individual, unit-identifiable \"things\" (\"records\"). The majority of the simple data that gets generated is created in this format, and data that isn't can almost always be converted over. This is known as a \"tidy data\" format.\n\n`seaborn` is designed to work with this kind of data out-of-the-box, for all of its plot types, with minimal fuss. This makes it an incredibly convenient workbench tool.\n\n`pandas` is not designed this way. In `pandas`, every plot we generate is tied very directly to the input data. In essence, `pandas` expects your data being in exactly the right *output* shape, regardless of what the input is.\n\n<!--\nIn the previous section of this tutorial, we purposely evaded this issue by using supplemental datasets in a \"just right\" shape. Starting from the data that we already have, here's what it would take to generate a simple histogram:\n\n```python\nimport numpy as np\ntop_five_wines_scores = (\n    reviews\n        .loc[np.where(reviews.variety.isin(reviews.variety.value_counts().head(5).index))]\n        .loc[:, ['variety', 'points']]\n        .groupby('variety')\n        .apply(lambda df: pd.Series(df.points.values))\n        .unstack()\n        .T\n)\ntop_five_wines_scores.plot.hist()\n```\n\nAs we demonstrated above, to do the same thing in `seaborn`, all we need is:\n\n```python\nsns.distplot(reviews.points, bins=10, kde=False)\n```\n\nThe difference is stark!\n-->\n\nHence, in practice, despite its simplicity, the `pandas` plotting tools are great for the initial stages of exploratory data analytics, but `seaborn` really becomes your tool of choice once you start doing more sophisticated explorations.\n\n<!--\nMy recommendations are:\n* Bar plot: \n  * `pd.Series.plot.bar`\n  * `sns.countplot`\n* Scatter plot:\n  * `pd.Series.plot.scatter`\n  * `sns.jointplot`\n* Hex plot:\n  * `pd.Series.plot.hex`\n  * `sns.jointplot`\n* Line/KDE plot:\n  * `pd.Series.plot.line` for nominal categorical variables\n  * `sns.kdeplot` for interval variables\n* Box/Violin plot:\n  * `sns.boxplot`\n  * `sns.violinplot`\n* Histogram:\n   * `sns.distplot`\n-->"
    },
    {
      "metadata": {
        "_uuid": "e9372bfddfbed428c0faaa3dc5786514a67f335f",
        "_cell_guid": "7e175119-20cd-49b3-8119-fe09d4771c36"
      },
      "cell_type": "markdown",
      "source": "# Examples\n\nAs in previous notebooks, let's now test ourselves by answering some questions about the plots we've used in this section. Once you have your answers, click on \"Output\" button below to show the correct answers.\n\n1. A `seaborn` `countplot` is equivalent to what in `pandas`?\n2. A `seaborn` `jointplot` is equivalent to a what in `pandas`?\n3. Why might a `kdeplot` not work very well for ordinal categorical data?\n4. What does the \"box\" in a `boxplot` represent?"
    },
    {
      "metadata": {
        "_uuid": "7bfca747756a4e6ebb5b2211d1d8ef8ecf789bfc",
        "_kg_hide-input": true,
        "_kg_hide-output": true,
        "_cell_guid": "8a2e2e47-e8dc-47bf-bae2-29b3677118b5",
        "trusted": true
      },
      "cell_type": "code",
      "source": "from IPython.display import HTML\nHTML(\"\"\"\n<ol>\n<li>A seaborn countplot is like a pandas bar plot.</li>\n<li>A seaborn jointplot is like a pandas hex plot.</li>\n<li>KDEPlots work by aggregating data into a smooth curve. This is great for interval data but doesn't always work quite as well for ordinal categorical data.</li>\n<li>The top of the box is the 75th percentile. The bottom of the box is the 25th percentile. The median, the 50th percentile, is the line in the center of the box. So 75% of the data in the distribution is located within the box!</li>\n</ol>\n\"\"\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "a2eb95d31ce81dfa63cc495dc6f560572528c893",
        "_cell_guid": "4ebe52aa-809f-439b-9f64-87ea7b17c32e"
      },
      "cell_type": "markdown",
      "source": "Next, try forking this kernel, and see if you can replicate the following plots. To see the answers, click the \"Input\" button to unhide the code and see the answers. Here's the dataset we've been working with:"
    },
    {
      "metadata": {
        "_uuid": "fbb3a01f209e864d91faa6c625af2bc8ce80b031",
        "_cell_guid": "ac1be017-3896-475b-98e7-eb90cef98c2a",
        "trusted": true
      },
      "cell_type": "code",
      "source": "pokemon = pd.read_csv(\"../input/pokemon/Pokemon.csv\", index_col=0)\npokemon.head()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "f83cdf2f6443afc0ce6b9db8a904a300c4482d5c",
        "_cell_guid": "89317f1f-f0c4-4a02-bfa7-d8ca0bf7e183"
      },
      "cell_type": "markdown",
      "source": "And now, the plots:"
    },
    {
      "metadata": {
        "_kg_hide-input": true,
        "_uuid": "46e2d301ac9cbb290890ff9433a0cdb662c87df7",
        "_cell_guid": "895001a2-78c7-4295-a21f-2cbca456c5ce",
        "trusted": true
      },
      "cell_type": "code",
      "source": "sns.countplot(pokemon['Generation'])",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_kg_hide-input": true,
        "_uuid": "8b199797e18a63fc065ca76b64df6456543cd634",
        "_cell_guid": "4ada9e6f-4b95-47a2-8480-83317513d086",
        "trusted": true
      },
      "cell_type": "code",
      "source": "fig, axarr = plt.subplots(1,1, figsize=(12,8))\nax = sns.distplot(pokemon['HP'], bins=40, kde=True)\nax.set_title('Pokemon HP', fontsize=18)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_kg_hide-input": true,
        "_uuid": "7f55b695c06850a4edfb9fdfa8d355b5dd6b816f",
        "_cell_guid": "ed8599fe-c6cd-4136-a9bd-5ba2fd6f7ca8",
        "trusted": true
      },
      "cell_type": "code",
      "source": "sns.jointplot(x='Attack', y='Defense', data=pokemon)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_kg_hide-input": true,
        "_uuid": "ad40c576b8eeef06ec8db0fa46a410dcfccf5ff3",
        "_cell_guid": "078563f6-b739-4d3e-bd1d-67fa06d7cf11",
        "trusted": true
      },
      "cell_type": "code",
      "source": "sns.jointplot(x='Attack', y='Defense', data=pokemon, kind='hex', gridsize=25)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "36c70adbdaa0c624a3d359dbe0dd4411c5e545a9",
        "_cell_guid": "ed3c69de-3bdc-4870-91e9-d26aad2c25ff"
      },
      "cell_type": "markdown",
      "source": "Hint: for the next exercise, use the variables `HP` and `Attack`."
    },
    {
      "metadata": {
        "_kg_hide-input": true,
        "_uuid": "b13a6cf3ab4f598e8ddd79255ec17dd326092e35",
        "_cell_guid": "dfd56659-e60c-4687-aed3-e21906ffe146",
        "trusted": true
      },
      "cell_type": "code",
      "source": "sns.kdeplot(pokemon.loc[:, ['HP', 'Attack']].dropna())",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_kg_hide-input": true,
        "_uuid": "0ccbfe9cb565a55b558fb928bc1818d38f15732b",
        "_cell_guid": "1aecf1db-e82b-4e30-addc-60dbd40621aa",
        "trusted": true
      },
      "cell_type": "code",
      "source": "sns.boxplot(\n    x='Legendary',\n    y='Attack',\n    data=pokemon\n)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_kg_hide-input": true,
        "_uuid": "d2cf8a4635b21bc32095356685325c6c67bd1355",
        "_cell_guid": "6343db7c-e03e-4bf0-9ce5-38bb1d42966a",
        "trusted": true
      },
      "cell_type": "code",
      "source": "sns.violinplot(\n    x = 'Legendary',\n    y = 'Attack',\n    data = pokemon\n)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "_uuid": "36c5658d25fed1256b3f868e23e448c0661ba234",
        "_cell_guid": "a4dd72b3-2369-43f2-8187-e3013825ea88"
      },
      "cell_type": "markdown",
      "source": "## Conclusion\n\n`seaborn` is one of the most important, if not *the* most important, data visualization tool in the Python data viz ecosystem. In this notebook we looked at what features and capacities `seaborn` brings to the table. There's plenty more that you can do with the library that we won't cover here or elsewhere in the tutorial; I highly recommend browsing the terrific `seaborn` [Gallery page](https://seaborn.pydata.org/examples/index.html) to see more beautiful examples of the library in action.\n\n[Click here to go to the next section, \"Faceting with seaborn\"](https://www.kaggle.com/residentmario/faceting-with-seaborn)."
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.6.6",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 1
}