Created Wiki page with previous Github wiki pages and links. Added wiki entry on how to create new entries.

Author: richardvonmoos

config.toml

@@ -47,6 +47,11 @@ ignoreFiles = ['publications.md$']
   pageRef = "/contact"
   weight  = -70
 
+[[menu.main]]
+  name = "Wiki"
+  url = "/wiki/"
+  weight = -70
+
 # Ditto (see above), but for the footer.
 [params.footer.logos]
   text = """

content/wiki/Adding-wiki-entries.md

@@ -0,0 +1,46 @@
+---
+title: Adding wiki entries
+---
+### Adding new sections
+
+To add a new section of wiki entries, add a new folder <topic name> to content/wiki/. Then add a file to the folder
+with the name _index.md and add the lines:
+```
+---
+title: <Topic name>
+---
+```
+to the top of the file. This will create a new section in the wiki with the title <Topic name>.
+
+### Adding a new entry
+
+To add a wiki entry, drop a markdown file into content/wiki/<topic-name>. Add the lines 
+```
+---
+title: <Content title>
+---
+```
+To the top of the file. Now you can fill the markdown file with content.
+
+### Using figures
+
+If you are referencing figures in your markdown file, add a folder <content-title> to static/wiki/.
+Then, add your figures to the folder static/wiki/<content-title> that you just created.
+You can then reference these figures in your markdown file with the following command:
+
+```HTML
+<img src="/wiki/<content-title>/<figure-x>"
+alt="<figure x> not displayed correctly"
+style="width: 100%; height: auto;">
+```
+
+### Adding external links
+
+Add a file <external-link-name>.md to content/wiki/external-guides/ with the following content:
+```
+---
+title: <Content title>
+external_url: "<url>"
+---
+```
+.

content/wiki/Code/Computing-Infrastructure-Tips-and-Tricks.md

@@ -0,0 +1,55 @@
+---
+title: Computing-Infrastructure:-Tips-and-Tricks
+---
+(**Draft**)
+
+## Virtual Environments
+
+Whether you are working _locally_ or on a server, it is a good idea to use virtual environments
+for your Python projects.
+
+### Rationale
+
+My personal suggestion for using the cluster involves setting up `Miniconda` with a basic
+environment, which you can use to maintain compilers and support libraries. Nested within
+this environment, we use [`poetry`](https://python-poetry.org/), a great way for managing
+and maintaining virtual environments with Python.
+
+#### Advantages
+
+- In many projects, this setup provides a 'fire-and-forget' type solution that you may use
+  in other cluster environments as well.
+- Dependencies between packages are respected and reproducible builds may be produced.
+- `poetry` makes _publishing_ a proper Python package almost trivial.
+
+#### Drawbacks
+
+The integration with `pytorch` and other GPU-based packages is not optimal. However, the
+environment set up by `poetry` is a fully-fledged virtual environment. We can always use
+`pip` to install specific GPU-based packages here. While this is as little more complex,
+we still benefit from having different virtual environments for each project, which will
+prevent interference.
+
+#### Alternatives
+
+You can also set up and maintain virtual environments yourself, installing all packages
+via `pip`. In more recent versions of `pip`, the `pyproject.toml` used by `poetry` will
+be parsed as well.
+
+### Setting up `Miniconda`
+
+```bash
+$ wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
+# Use a local temporary directory to ensure that this can be installed in
+# all cases. This is probably not necessary in your case.
+$ mkdir tmp
+$ TMPDIR=$HOME/tmp bash Miniconda3-latest-Linux-x86_64.sh
+$ bash Miniconda3-latest-Linux-x86_64.sh
+# Follow the installer afterwards. My personal recommendation is to
+# install Miniconda in $HOME/.miniconda since it will then not show
+# up all the time when you issue an ls command.
+#
+# After the installation, log out and in again. Start bash if it is
+# not already your default shell.
+$ conda install -c conda-forge poetry
+```

content/wiki/Code/Loading-configs-in-python.md

@@ -0,0 +1,95 @@
+---
+title: Loading configs in Python
+---
+
+## Motivation 
+- The loading nested configurations can be difficult. 
+- Pythons yaml loader does not deal with it nicely. 
+- loading as dict -> key access, dot access would be nicer. 
+- many dependencies otherwise (Hydra, OmegaConf, ...)
+
+
+Simple solution for loading.
+- No external dependencies.
+- Allows dot access. 
+- Allows the use of `safe_load`.
+	- `yaml.load` poses security risks -> Loads arbitrary code. 
+
+
+Possible extensions: 
+- Add Pydantic for convenient validation of configs.
+- Add typing.
+
+```python
+import yaml 
+import json
+from types import SimpleNamespace
+
+def load_object(dct):
+    return SimpleNamespace(**dct)
+
+def load_config(path):
+    """
+    Loads the configuration yaml and parses it into an object with dot access.
+    """
+    with open(path, encoding="utf-8") as stream:
+        # Load dict
+        config_dict = yaml.safe_load(stream)
+
+        # Convert to namespace (access via config.data etc)
+        config = json.loads(json.dumps(config_dict), object_hook=load_object)
+    return config, config_dict
+```
+
+
+For typing one can use the following construction: 
+
+```python
+from dataclasses import dataclass
+
+@dataclass
+class MyModelConfig: 
+	module: models.mymodel
+	hidden_size: int 
+
+
+
+class MyModel: 
+	def __init__(self, config: MyModelConfig):
+		# Model def goes here.
+		# Typing allows autocomplete.
+		pass 
+	
+	...
+
+```
+
+
+# References in yaml
+
+- Yaml allows for references
+- Avoids duplicates. 
+- Great when configs need to be passed to multiple modules 
+	- Data and model for instance. 
+
+```yaml 
+  experimentconfig: &id-exp
+  name: MyCoolExperiment
+
+model: 
+  module: models.mymodel
+  hidden_size: 10 
+  expconfig: *id-exp
+
+data: 
+  module: data.mydata
+  root: ./data 
+  expconfig: *id-exp
+```
+
+
+
+Saving configs 
+- tbd
+
+

content/wiki/Code/_index.md

@@ -0,0 +1,3 @@
+------
+title: Code
+---