Dive into Jupyter Notebooks

After opening a new notebook, you will be prompted to select a kernel

• If you have never created a kernel to use, you will only see a list of default Jupyter kernels available on the cluster

• You may check the box to start with the preferred kernel every time you open a notebook

Default Kernels on ARCC HPC Resources include:

• Python Kernels

• R Kernels

HPC-wide kernels are titled by packages installed and available when launched

Users can also create user-defined kernels from conda environments (Covered in a subsequent module. See: Launching Jupyter Kernels from Conda Environments)

From the Right side of the File Management Tab:

New->Notebook-> Select from a list of kernels. Choose Python 3 (ipykernel)

This should open a new browser tab/window with a blank Jupyter notebook named: Untitled.ipynb

If we go back to our previous Jupyter tab/window containing the file browser from which we launched our notebook, this new file shows up in the list, and has a green icon to it’s left, meaning it is currently running:

• Header: Top has the document name (editable).

• Menu bar with drop-downs & loaded kernel

• Toolbar

• Body

• Has top-level menus that expose actions available in Jupyter Notebook:

  • File: actions related to files and folders

  • Edit: actions related to editing notebooks

  • View: Options to alter appearance of Notebook

  • Insert: Limited options for cell insertion

  • Kernel: actions for kernel management

  • Help: a list of Jupyter help links

Note: Jupyter extensions can create new top-level menus in the menu bar.

Right of the menu bar, the current kernel is listed

- Save and checkpoint notebook
- Add a cell below the current one
- Cut/Delete this cell
- Copy contents of current cell
- Paste in new cell below active cell
- Up 1 cell
- Down 1 cell
- Run current cell
- Stop running cell
- **Reload/Restart Kernel
- **Restart Kernel & Re-run entire notebook
- Select current cell type
- Display full list of keyboard shortcuts for Jupyter Notebooks

** - Will restart entire kernel and you will lose all current output. (Is output easily regenerable?)

We can use the cell type option in the toolbar to set cell type in the notebook body:

• Code: Define computational code (language = from kernel) in the document.

  • If the kernel is python cell type, the cell will expect input in the form of python code.

  • This is our default code type when new cells are created.

• Markdown: Uses Markdown language to build nicely formatted narratives around the code in the rest of the document. Click here for Markdown Cheat Sheet

• Raw NBconvert: Used when text should be kept in raw form for conversion to another format (such as HTML or Latex). When you use these, cells marked as Raw are converted in a way specific to your targeted output format.

• Heading: For making headings. Somewhat redundant - you can also make headings in a markdown cell.

Raw NBConvert

• Stands for “Raw Notebook Convert”

• Retains any text in these cells in their raw form and does not run them

• Enables the conversion of your notebook to another format as given by the FORMAT string using Jinja templates.

  • Presenting: PDF

  • Publishing: LaTeX

  • Collaboration

  • Sharing: HTML

• Setting to “none” just makes it a “Raw” cell in which nothing is run on it.

Previously, we said the file management tab shows the filesystem accessible to the user, rooted by the directory from which the notebook was launched.

In the file management tab we can see root directory, and within it, the Desktop, Documents, and Downloads, and ondemand directories.

We could just assume the file manager is showing our home directory. But how would we find out for certain?

Running with a Python kernel, we can use our jupyter notebook to get this information from the system:

1. import the python OS module (to let us interact with the native OS on the cluster that Jupyter is running on top of)

2. On the next line, type os.getcwd() (AKA: get current working directory)

3. Click the run button to run our cell and generate a new output cell, which also creates a new input cell below that.

Note: New input cells are code cell types by default

With the information from our output cell, we can conclude that OnDemand launches Jupyter from your $HOME

import os : import a python module allowing us to use python kernel running this notebook to interact with underlying HPC cluster’s OS

os.getcwd(): a python command to output the full system path in which our active jupyter notebook resides.

If we select the default Python 3 (ipykernel), we are presented with the file explorer showing our home directory as it’s rooted location. This means we can’t go up any further in system’s directory structure.

• With our local root location for the notebook set to our $HOME, we are unable to see our /project and /gscratch directories on the cluster.

• To expose these folders to the jupyter environment, create a symbolic link (aka shortcut) within our /home.

• Instructions for creating a symbolic link may be found here or expanded in the cell to the right

In our notebook, we can see which modules are available by opening a new cell with the + button.

In our cell box, set as “code” use the python import command, followed by a space, then hit tab to get a list of options.

Hitting tab after import runs autocomplete options for the import command. This list of options has populated all modules available to us in our jupyter notebook:

Since we appear to have a large number of packages available in this environment, we’ll import one we expect to be there.

In our bottom-most cell, add to the import command by typing an import for a common package used in mathematic and multi dimensional matrix computations - numpy.

Our output results in an error:

• The error means this particular module is not available in the kernel we have loaded, despite being a commonly used software package for researchers and computations.

• While many packages were listed when we autocompleted an import command, most of them were installed as part of the jupyter installation and underlying OS environment.

• Most software we’d need to perform even more simple and common activities for our research would still need to be installed or made available somehow. What are our options?

Depending on the HPC’s native environment, you may have other kernels available.

• To load a different kernel, we go to the Kernel option in our drop down menu then navigate to “Change kernel”.

• Select a different kernel than the current one, based on your own preference

The new kernel is loaded as shown in the top right of our notebook.

• If we rerun our 2 cells again, what happens this time?

Starting Jupyter from OnDemand

Dive into Jupyter Labs