Downloading course material

All files that are associated with this course are available via a public git repository, hosted on github. The use of git is encouraged, but not mandatory. The course material is also available via the course web page and can be downloaded from there.

Using git, all course material can be downloaded by cloning the github repository:

$ git clone --recurse-submodules https://github.com/physics-chalmers/tif285.git

after which it will be available in the tif285 directory. You will have to perform a git pull operation (from within that directory) when you want to retrieve future updates in the github repository.

$ cd path/to/tif285
$ git pull

When using the github repository to stay up-to-date with course material it is recommended to make a local copy of notebooks before starting to edit them. The git approach, however, would be to create a new branch.

Note that the lecture notes are maintained in a so called git submodule (tif285-book). The extra --recurse-submodules flag in the git clone command ensures that we fetch also that repository. You will then find all source files for the lecture notes in the doc/tif285-book directory. In particular, you might want to open and run the exercise and demonstration notebooks that are part of the lecture notes. These can be found in the subdirectories in doc/tif285-book/content.

There are plenty of tutorials and guides how to use git. Two recommended ones are:

The Git Handbook (a GitHub Guide),
Pro Git (an online book by Scott Chacon and Ben Straub).

You are encouraged to set your user name and email address. This is important because every Git commit uses this information, and it’s immutably baked into the commits you start creating:

$ git config --global user.name "Emilia Student"
$ git config --global user.email name@example.com

You might also want to set your default editor. Pick the one that you prefer. E.g.,

$ git config --global core.editor emacs/vi/nano/...

Python distribution

We will use the Python programming language and will benefit from its myriad of available libraries. Jupyter notebooks offer a useful explorative coding environment since they make it possible to run Python code interactively and to visualize your data. Jupyter notebooks also offer the possibility to run Julia or R code, or even integrate compiled code written in C, C++, Fortran etc. The focus in this course, however, will be on Python.

The notebooks that we will be using depend on several scientific python modules (see the list in environment.yml) and they require a python3.x installation.

These python modules and their dependencies are best installed using conda by creating a virtual environment. The conda package manager can easily be installed as a local user, which does not require administrator permissions. Note that the miniconda installation requires 400 MB disk space.

Download and run the miniconda installer. On Linux this is done by:
```
$ wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
$ bash Miniconda3-latest-Linux-x86_64.sh
```
(For other operating systems, e.g. MacOS or Windows, more details about the miniconda installer can be found in the conda documentation) During the installation you will have to accept the license agreement. We also recommend to use the default installation directory ~/miniconda3 and to allow the installer to run conda init to set environment variables (this is done by typing yes when prompted). It is recommended to use the bash shell. Further details and troubleshooting is available at conda.io.
Check the installation:
```
$ conda list
```
should give a list of python packages. Moreover,
```
$ which python
```
should give the path to the conda python executable ~/miniconda3/bin/python and
```
$ python --version
```
should show which Python3 version you are using.
Make sure that you have downloaded the course material, preferably with git clone as described above. Go to the directory with the environment.yml file.
```
$ cd path/to/tif285
```
Create a virtual environment
```
$ conda env create -f environment.yml
```
which reads the environment.yml file in your current directory. It will check dependencies and then download and install several packages. It might take a considerable time to run and you will probably be asked to accept the suggested installation procedure.

Some packages that we will be using are not included in the default conda channels. One can either specify relevant package channel(s) in the environment.yml file (as done here), or add them to the default conda channel configuration via, e.g, conda config --append channels conda-forge
Once the virtual environment has been created it can be activated:
```
$ conda activate tif285-env
```
For future reference, to deactivate the virtual environment:conda deactivate
To update the virtual environment (e.g. after adding packages to the environment.yml file)
```
$ conda env update -f environment.yml
```

There are also other options (venv, pipenv) for creating virtual environments with the python version and packages that we will be using. Or you can install packages, keeping track yourself of dependencies, using pip install.

Jupyter notebooks

Jupyter notebooks will be used extensively in this course. It is an open-source web application that allows you to create and share documents that contain live code, equations, visualizations and narrative text. Uses include: data cleaning and transformation, numerical simulation, statistical modeling, data visualization, machine learning, and much more.

Therefore, once the environment is set up and activated, you are encouraged to get acquainted with the notebook workflow by starting a jupyter notebook in the directory with the lecture contents. In the directory tree from the github repository:

$ cd doc/tif285-book/content/
$ jupyter notebook

The Jupyter Notebook will open in your default browser. It should show a list of the subdirectories. It is recommended that you start with the Jupyter-Python-NumPy exercise notebooks in the Intro directory. Just double-click on the first one to get started. Make sure to evaluate the cells with shift-return.

However, a word of caution: Since Jupyter Notebooks are not pure text files (they are basically json files), they do not integrate seamlessly with git version control. The action of evaluating a cell in a notebook, without changing any code, will register as a file update in git.

As a final note: Google's Colab is a free Jupyter notebook environment that requires no setup and runs entirely in the cloud. You are welcome to try it out, but we offer limited support.

Useful Python libraries

This is a list of important Python libraries that we will use during this course

NumPy is a highly popular library for large, multi-dimensional arrays and matrices, along with a large collection of high-level mathematical functions to operate on these arrays
The pandas library provides high-performance, easy-to-use data structures and data analysis tools
Scipy (pronounced “Sigh Pie”) is a Python-based ecosystem of open-source software for mathematics, science, and engineering.
Matplotlib is a Python 2D plotting library which produces publication quality figures in a variety of hardcopy formats and interactive environments across platforms.
SymPy is a Python library for symbolic mathematics.
scikit-learn has simple and efficient tools for machine learning, data mining and data analysis
TensorFlow is a Python library for fast numerical computing created and released by Google

We will also use some specialized libraries such as emcee. In addition, here are some other major libraries that we might not use in this course, but that can be very useful in the context of Bayesian data analysis and machine learning:

JAX is a Python library for accelerator-oriented array computation and program transformation, designed for high-performance numerical computing and large-scale machine learning. With its updated version of Autograd, JAX can automatically differentiate native Python and NumPy functions.
PyMC is a probabilistic programming package for Python that allows users to fit Bayesian models using a variety of numerical methods, most notably Markov chain Monte Carlo (MCMC) and variational inference (VI).
GPy is an advanced library for Gaussian Process modeling.
And many more such as pytorch, Theano etc