challenges-for-true-pytorch-heroes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PyTorch Challenges\n",
    "\n",
    "[Sasha Rush](https://twitter.com/srush_nlp) compiled a set of [16 Tensor mini-puzzles](https://github.com/srush/Tensor-Puzzles) that involve reasoning about broadcasting in a constrained setting: people are allowed to use only a single PyTorch function: `torch.arange`. Can you do it?\n",
    "\n",
    "Here, I've extended his list to 27 puzzles! \n",
    "\n",
    "**Rules**\n",
    "\n",
    "- Each puzzle needs to be solved in 1 line (<80 columns) of code.\n",
    "- You are allowed @, arithmetic, comparison, shape, any indexing (e.g. `a[:j], a[:, None], a[arange(10)]`), and previous puzzle functions.\n",
    "- To start off, we give you an implementation for the `torch.arange` function.\n",
    "\n",
    "**Anti-Rules**\n",
    "- Nothing else. No `.view, .sum, .take, .squeeze, .tensor`.\n",
    "- No cheating. Stackoverflow is great, but this is about first-principles.\n",
    "- Hint... these puzzles are mostly about [Broadcasting](https://pytorch.org/docs/master/notes/broadcasting.html). Make sure you understand this rule, which is a key concept for dealing with n-dimensional arrays.\n",
    "\n",
    "🐶🐶🐶 After you convince yourself your code is correct, run the cell to test it. If the test succeeds, you will get a puppy 🐶🐶🐶."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List of puzzles:\n",
    "\n",
    "1. [where](#1\\)-where)\n",
    "2. [ones](#2\\)-ones)\n",
    "3. [sum](#3\\)-sum)\n",
    "4. [outer](#4\\)-outer)\n",
    "5. [diag](#5\\)-diag)\n",
    "6. [eye](#6\\)-eye)\n",
    "7. [triu](#7\\)-triu)\n",
    "8. [cumsum](#8\\)-cumsum)\n",
    "9. [diff](#9\\)-diff)\n",
    "10. [vstack](#10\\)-vstack)\n",
    "11. [roll](#11\\)-roll)\n",
    "12. [flip](#12\\)-flip)\n",
    "13. [compress](#13\\)-compress)\n",
    "14. [pad_to](#14\\)-pad_to)\n",
    "15. [sequence_mask](#15\\)-sequence_mask)\n",
    "16. [bincount](#16\\)-bincount)\n",
    "17. [scatter_add](#17\\)-scatter_add)\n",
    "18. [flatten](#18\\)-flatten)\n",
    "19. [linspace](#19\\)-linspace)\n",
    "20. [heaviside](#20\\)-heaviside)\n",
    "21. [hstack](#21\\)-hstack)\n",
    "22. [view](#22\\)-view-\\(1d-to-2d\\))\n",
    "23. [repeat](#23\\)-repeat-\\(1d\\))\n",
    "24. [repeat_interleave](#24\\)-repeat_interleave-\\(1d\\))\n",
    "25. [chunk](#25\\)-chunk)\n",
    "26. [nonzero](#26\\)-nonzero)\n",
    "27. [bucketize](#27\\)-bucketize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install -qqq torchtyping hypothesis pytest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from spec import make_test, run_test, TT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### arange\n",
    "\n",
    "This one is given! Think about it as a \"for-loop\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def arange(i: int):\n",
    "    return torch.arange(i)\n",
    "\n",
    "arange(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1) where\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.where.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def where_spec(q, a, b, out):\n",
    "    for i in range(len(out)):\n",
    "        out[i] = a[i] if q[i] else b[i]\n",
    "\n",
    "def where(q: TT[\"i\", bool], a: TT[\"i\"], b: TT[\"i\"]) -> TT[\"i\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"where\", where, where_spec))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) ones\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.ones.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ones_spec(out):\n",
    "    for i in range(len(out)):\n",
    "        out[i] = 1\n",
    "\n",
    "def ones(i: int) -> TT[\"i\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"one\", ones, ones_spec, add_sizes=[\"i\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3) sum\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.sum.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_spec(a, out):\n",
    "    out[0] = 0\n",
    "    for i in range(len(a)):\n",
    "        out[0] += a[i]\n",
    "\n",
    "def sum(a: TT[\"i\"]) -> TT[1]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"sum\", sum, sum_spec))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4) outer\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.outer.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer_spec(a, b, out):\n",
    "    for i in range(len(out)):\n",
    "        for j in range(len(out[0])):\n",
    "            out[i][j] = a[i] * b[j]\n",
    "\n",
    "def outer(a: TT[\"i\"], b: TT[\"j\"]) -> TT[\"i\", \"j\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"outer\", outer, outer_spec))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5) diag\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.diag.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diag_spec(a, out):\n",
    "    for i in range(len(a)):\n",
    "        out[i] = a[i][i]\n",
    "        \n",
    "def diag(a: TT[\"i\", \"i\"]) -> TT[\"i\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"diag\", diag, diag_spec))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6) eye\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.eye.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eye_spec(out):\n",
    "    for i in range(len(out)):\n",
    "        out[i][i] = 1\n",
    "        \n",
    "def eye(j: int) -> TT[\"j\", \"j\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"eye\", eye, eye_spec, add_sizes=[\"j\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7) triu\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.triu.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def triu_spec(out):\n",
    "    for i in range(len(out)):\n",
    "        for j in range(len(out)):\n",
    "            if i <= j:\n",
    "                out[i][j] = 1\n",
    "            else:\n",
    "                out[i][j] = 0\n",
    "                \n",
    "def triu(j: int) -> TT[\"j\", \"j\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"triu\", triu, triu_spec, add_sizes=[\"j\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8) cumsum\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.cumsum.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cumsum_spec(a, out):\n",
    "    total = 0\n",
    "    for i in range(len(out)):\n",
    "        out[i] = total + a[i]\n",
    "        total += a[i]\n",
    "\n",
    "def cumsum(a: TT[\"i\"]) -> TT[\"i\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"cumsum\", cumsum, cumsum_spec))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9) diff\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.diff.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diff_spec(a, out):\n",
    "    out[0] = a[0]\n",
    "    for i in range(1, len(out)):\n",
    "        out[i] = a[i] - a[i - 1]\n",
    "\n",
    "def diff(a: TT[\"i\"], i: int) -> TT[\"i\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"diff\", diff, diff_spec, add_sizes=[\"i\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10) vstack\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.vstack.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vstack_spec(a, b, out):\n",
    "    for i in range(len(out[0])):\n",
    "        out[0][i] = a[i]\n",
    "        out[1][i] = b[i]\n",
    "\n",
    "def vstack(a: TT[\"i\"], b: TT[\"i\"]) -> TT[2, \"i\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"vstack\", vstack, vstack_spec))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11) roll\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.roll.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def roll_spec(a, out):\n",
    "    for i in range(len(out)):\n",
    "        if i + 1 < len(out):\n",
    "            out[i] = a[i + 1]\n",
    "        else:\n",
    "            out[i] = a[i + 1 - len(out)]\n",
    "            \n",
    "def roll(a: TT[\"i\"], i: int) -> TT[\"i\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"roll\", roll, roll_spec, add_sizes=[\"i\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 12) flip\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.flip.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flip_spec(a, out):\n",
    "    for i in range(len(out)):\n",
    "        out[i] = a[len(out) - i - 1]\n",
    "        \n",
    "def flip(a: TT[\"i\"], i: int) -> TT[\"i\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"flip\", flip, flip_spec, add_sizes=[\"i\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 13) compress\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.compress.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compress_spec(g, v, out):\n",
    "    j = 0\n",
    "    for i in range(len(g)):\n",
    "        if g[i]:\n",
    "            out[j] = v[i]\n",
    "            j += 1\n",
    "            \n",
    "def compress(g: TT[\"i\", bool], v: TT[\"i\"], i:int) -> TT[\"i\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"compress\", compress, compress_spec, add_sizes=[\"i\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 14) pad_to\n",
    "\n",
    "https://pytorch.org/docs/stable/generated/torch.nn.utils.rnn.pad_sequence.html?highlight=pad#torch.nn.utils.rnn.pad_sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pad_to_spec(a, out):\n",
    "    for i in range(min(len(out), len(a))):\n",
    "        out[i] = a[i]\n",
    "\n",
    "def pad_to(a: TT[\"i\"], i: int, j: int) -> TT[\"j\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"pad_to\", pad_to, pad_to_spec, add_sizes=[\"i\", \"j\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15) sequence_mask\n",
    "https://www.tensorflow.org/api_docs/python/tf/sequence_mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sequence_mask_spec(values, length, out):\n",
    "    for i in range(len(out)):\n",
    "        for j in range(len(out[0])):\n",
    "            if j < length[i]:\n",
    "                out[i][j] = values[i][j]\n",
    "            else:\n",
    "                out[i][j] = 0\n",
    "\n",
    "def constraint_set_length(d, sizes=None):\n",
    "    d[\"length\"] = d[\"length\"] % d[\"values\"].shape[1]\n",
    "    return d\n",
    "    \n",
    "def sequence_mask(values: TT[\"i\", \"j\"], length: TT[\"i\", int]) -> TT[\"i\", \"j\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"sequence_mask\",\n",
    "    sequence_mask, sequence_mask_spec, constraint=constraint_set_length\n",
    "))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 16) bincount\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.bincount.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bincount_spec(a, out):\n",
    "    for i in range(len(a)):\n",
    "        out[a[i]] += 1\n",
    "        \n",
    "def constraint_set_max(d, sizes=None):\n",
    "    d[\"a\"] = d[\"a\"] % d[\"return\"].shape[0]\n",
    "    return d\n",
    "        \n",
    "def bincount(a: TT[\"i\"], j: int) -> TT[\"j\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"bincount\",\n",
    "    bincount, bincount_spec, add_sizes=[\"j\"], constraint=constraint_set_max\n",
    "))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 17) scatter_add\n",
    "https://pytorch-scatter.readthedocs.io/en/1.3.0/functions/add.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scatter_add_spec(values, link, out):\n",
    "    for j in range(len(values)):\n",
    "        out[link[j]] += values[j]\n",
    "\n",
    "def constraint_set_max(d, sizes=None):\n",
    "    d[\"link\"] = d[\"link\"] % d[\"return\"].shape[0]\n",
    "    return d\n",
    "\n",
    "def scatter_add(values: TT[\"i\"], link: TT[\"i\"], j: int) -> TT[\"j\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "\n",
    "run_test(make_test(\"scatter_add\",\n",
    "    scatter_add, scatter_add_spec, add_sizes=[\"j\"], constraint=constraint_set_max\n",
    "))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 18) flatten\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flatten.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flatten_spec(a, out):\n",
    "    k = 0\n",
    "    for i in range(len(a)):\n",
    "        for j in range(len(a[0])):\n",
    "            out[k] = a[i][j]\n",
    "            k += 1\n",
    "\n",
    "def flatten(a: TT[\"i\", \"j\"], i:int, j:int) -> TT[\"i * j\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"flatten\", flatten, flatten_spec, add_sizes=[\"i\", \"j\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 19) linspace\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.linspace.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linspace_spec(i, j, out):\n",
    "    for k in range(len(out)):\n",
    "        out[k] = float(i + (j - i) * k / max(1, len(out) - 1))\n",
    "\n",
    "def linspace(i: TT[1], j: TT[1], n: int) -> TT[\"n\", float]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"linspace\", linspace, linspace_spec, add_sizes=[\"n\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 20) heaviside\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.heaviside.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def heaviside_spec(a, b, out):\n",
    "    for k in range(len(out)):\n",
    "        if a[k] == 0:\n",
    "            out[k] = b[k]\n",
    "        else:\n",
    "            out[k] = int(a[k] > 0)\n",
    "\n",
    "def heaviside(a: TT[\"i\"], b: TT[\"i\"]) -> TT[\"i\"]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"heaviside\", heaviside, heaviside_spec))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 21) hstack\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.hstack.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hstack_spec(a, b, out):\n",
    "    for i in range(len(out)):\n",
    "        out[i][0] = a[i]\n",
    "        out[i][1] = b[i]\n",
    "            \n",
    "def hstack(a: TT[\"i\"], b: TT[\"i\"]) -> TT[\"i\", 2]:\n",
    "    raise NotImplementedError\n",
    "\n",
    "run_test(make_test(\"hstack\", hstack, hstack_spec))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "No more puppies from now on... For now, check with the examples shown in the docs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 22) view (1d to 2d)\n",
    "\n",
    "https://pytorch.org/docs/stable/generated/torch.Tensor.view.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def view(a: TT[\"i * j\"], i: int, j: int) -> TT[\"i\", \"j\"]:\n",
    "    raise NotImplementedError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 23) repeat (1d)\n",
    "\n",
    "https://pytorch.org/docs/stable/generated/torch.Tensor.repeat.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def repeat(a: TT[\"i\"], d: int) -> TT[\"d\"]:\n",
    "    raise NotImplementedError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 24) repeat_interleave (1d)\n",
    "\n",
    "https://pytorch.org/docs/stable/generated/torch.repeat_interleave.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def repeat_interleave(a: TT[\"i\"], d: int) -> TT[\"d\"]:\n",
    "    raise NotImplementedError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 25) chunk\n",
    "https://pytorch.org/docs/stable/generated/torch.chunk.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chunk(a: TT[\"i\"], c: int) -> TT[\"c\", \"i // c\"]:\n",
    "    raise NotImplementedError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 26) nonzero\n",
    "https://pytorch.org/docs/stable/generated/torch.nonzero.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nonzero(a: TT[\"i\",\"j\"], i: int, j: int) -> TT[\"k\", 2]:\n",
    "    raise NotImplementedError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 27) bucketize\n",
    "https://pytorch.org/docs/stable/generated/torch.bucketize.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bucketize(v: TT[\"i\"], boundaries: TT[\"j\"]) -> TT[\"i\"]:\n",
    "    raise NotImplementedError"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Raw Cell Format",
  "jupytext": {
   "formats": "ipynb,py:percent"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}