01_tutorial_getting_started.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pystencils.session import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial 01: Getting Started\n",
    "\n",
    "\n",
    "## Overview\n",
    "\n",
    "*pystencils* is a package that can speed up computations on *numpy* arrays. All computations are carried out fully parallel on CPUs (single node with OpenMP, multiple nodes with MPI) or on GPUs.\n",
    "It is suited for applications that run the same operation on *numpy* arrays multiple times. It can be used to accelerate computations on images or voxel fields. Its main application, however, are numerical simulations using finite differences, finite volumes, or lattice Boltzmann methods. \n",
    "There already exist a variety of packages to speed up numeric Python code. One could use pure numpy or solutions that compile your code, like *Cython* and *numba*. See [this page](demo_benchmark.ipynb) for a comparison of these tools.\n",
    "\n",
    "![Stencil](../img/pystencils_stencil_four_points_with_arrows.svg)\n",
    "\n",
    "As the name suggests, *pystencils* was developed for **stencil codes**, i.e. operations that update array elements using only a local neighborhood. \n",
    "It generates C code, compiles it behind the scenes, and lets you call the compiled C function as if it was a native Python function. \n",
    "But lets not dive too deep into the concepts of *pystencils* here, they are covered in detail in the following tutorials. Let's instead look at a simple example, that computes the average neighbor values of a *numpy* array. Therefor we first create two rather large arrays for input and output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_arr = np.random.rand(1024, 1024)\n",
    "output_arr = np.zeros_like(input_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We first implement a version of this algorithm using pure numpy and benchmark it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def numpy_kernel():\n",
    "    output_arr[1:-1, 1:-1] = input_arr[2:, 1:-1] + input_arr[:-2, 1:-1] + \\\n",
    "                             input_arr[1:-1, 2:] + input_arr[1:-1, :-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.84 ms ± 36.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit \n",
    "numpy_kernel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets see how to run the same algorithm with *pystencils*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/latex": [
       "$\\displaystyle {{dst}_{(0,0)}} \\leftarrow \\frac{{{src}_{(-1,0)}}}{4} + \\frac{{{src}_{(0,-1)}}}{4} + \\frac{{{src}_{(0,1)}}}{4} + \\frac{{{src}_{(1,0)}}}{4}$"
      ],
      "text/plain": [
       "         src_W   src_S   src_N   src_E\n",
       "dst_C := ───── + ───── + ───── + ─────\n",
       "           4       4       4       4  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "src, dst = ps.fields(src=input_arr, dst=output_arr)\n",
    "\n",
    "symbolic_description = ps.Assignment(dst[0,0], \n",
    "                                     (src[1, 0] + src[-1, 0] + src[0, 1] + src[0, -1]) / 4)\n",
    "symbolic_description"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(3,3))\n",
    "ps.visualize_stencil_expression(symbolic_description.rhs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we first have created a symbolic notation of the stencil itself. This representation is built on top of *sympy* and is explained in detail in the next section. \n",
    "This description is then compiled and loaded as a Python function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "kernel = ps.create_kernel(symbolic_description).compile()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This whole process might seem overly complicated. We have already spent more lines of code than we needed for the *numpy* implementation and don't have anything running yet! However, this multi-stage process of formulating the algorithm symbolically, and just in the end actually running it, is what makes *pystencils* faster and more flexible than other approaches.\n",
    "\n",
    "Now finally lets benchmark the *pystencils* kernel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pystencils_kernel():\n",
    "    kernel(src=input_arr, dst=output_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "639 µs ± 35 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "pystencils_kernel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This benchmark shows that *pystencils* is a lot faster than pure *numpy*, especially for large arrays. \n",
    "If you are interested in performance details and comparison to other packages like Cython, have a look at [this page](demo_benchmark.ipynb).\n",
    "\n"
   ]
  },