Merge branch 'pipeline-setup' of OperationSavta/SavtaDepth into master

.dvc/.gitignore

@@ -0,0 +1,3 @@
+/config.local
+/tmp
+/cache

.dvc/config

@@ -0,0 +1,5 @@
+[core]
+    analytics = false
+    remote = origin
+['remote "origin"']
+    url = https://dagshub.com/OperationSavta/SavtaDepth.dvc

.dvc/plots/confusion.json

@@ -0,0 +1,30 @@
+{
+    "$schema": "https://vega.github.io/schema/vega-lite/v4.json",
+    "data": {
+        "values": "<DVC_METRIC_DATA>"
+    },
+    "title": "<DVC_METRIC_TITLE>",
+    "mark": "rect",
+    "encoding": {
+        "x": {
+            "field": "<DVC_METRIC_X>",
+            "type": "nominal",
+            "sort": "ascending",
+            "title": "<DVC_METRIC_X_LABEL>"
+        },
+        "y": {
+            "field": "<DVC_METRIC_Y>",
+            "type": "nominal",
+            "sort": "ascending",
+            "title": "<DVC_METRIC_Y_LABEL>"
+        },
+        "color": {
+            "aggregate": "count",
+            "type": "quantitative"
+        },
+        "facet": {
+            "field": "rev",
+            "type": "nominal"
+        }
+    }
+}

.dvc/plots/default.json

@@ -0,0 +1,29 @@
+{
+    "$schema": "https://vega.github.io/schema/vega-lite/v4.json",
+    "data": {
+        "values": "<DVC_METRIC_DATA>"
+    },
+    "title": "<DVC_METRIC_TITLE>",
+    "mark": {
+        "type": "line"
+    },
+    "encoding": {
+        "x": {
+            "field": "<DVC_METRIC_X>",
+            "type": "quantitative",
+            "title": "<DVC_METRIC_X_LABEL>"
+        },
+        "y": {
+            "field": "<DVC_METRIC_Y>",
+            "type": "quantitative",
+            "title": "<DVC_METRIC_Y_LABEL>",
+            "scale": {
+                "zero": false
+            }
+        },
+        "color": {
+            "field": "rev",
+            "type": "nominal"
+        }
+    }
+}

.dvc/plots/scatter.json

@@ -0,0 +1,27 @@
+{
+    "$schema": "https://vega.github.io/schema/vega-lite/v4.json",
+    "data": {
+        "values": "<DVC_METRIC_DATA>"
+    },
+    "title": "<DVC_METRIC_TITLE>",
+    "mark": "point",
+    "encoding": {
+        "x": {
+            "field": "<DVC_METRIC_X>",
+            "type": "quantitative",
+            "title": "<DVC_METRIC_X_LABEL>"
+        },
+        "y": {
+            "field": "<DVC_METRIC_Y>",
+            "type": "quantitative",
+            "title": "<DVC_METRIC_Y_LABEL>",
+            "scale": {
+                "zero": false
+            }
+        },
+        "color": {
+            "field": "rev",
+            "type": "nominal"
+        }
+    }
+}

.dvc/plots/smooth.json

@@ -0,0 +1,39 @@
+{
+    "$schema": "https://vega.github.io/schema/vega-lite/v4.json",
+    "data": {
+        "values": "<DVC_METRIC_DATA>"
+    },
+    "title": "<DVC_METRIC_TITLE>",
+    "mark": {
+        "type": "line"
+    },
+    "encoding": {
+        "x": {
+            "field": "<DVC_METRIC_X>",
+            "type": "quantitative",
+            "title": "<DVC_METRIC_X_LABEL>"
+        },
+        "y": {
+            "field": "<DVC_METRIC_Y>",
+            "type": "quantitative",
+            "title": "<DVC_METRIC_Y_LABEL>",
+            "scale": {
+                "zero": false
+            }
+        },
+        "color": {
+            "field": "rev",
+            "type": "nominal"
+        }
+    },
+    "transform": [
+        {
+            "loess": "<DVC_METRIC_Y>",
+            "on": "<DVC_METRIC_X>",
+            "groupby": [
+                "rev"
+            ],
+            "bandwidth": 0.3
+        }
+    ]
+}

.dvcignore

@@ -0,0 +1,3 @@
+# Add patterns of files dvc should ignore, which could improve
+# the performance. Learn more at
+# https://dvc.org/doc/user-guide/dvcignore

.gitignore

@@ -0,0 +1,9 @@
+.vscode/
+.DS_Store
+.idea/
+.ipynb_checkpoints/
+.workspace/
+aws/
+google-cloud-sdk
+__pycache__/
+env/

Dockerfile

@@ -1,9 +0,0 @@
-FROM pytorch/pytorch
-
-RUN apt-get update && apt-get install -y software-properties-common && apt-get update
-RUN add-apt-repository -y ppa:git-core/ppa && apt-get update && apt-get install -y git libglib2.0-dev
-
-COPY requirements.txt ./
-RUN pip install -r requirements.txt
-
-RUN pip install jupyterlab

Makefile

@@ -0,0 +1,37 @@
+#################################################################################
+# GLOBALS                                                                       #
+#################################################################################
+
+PROJECT_DIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
+PROJECT_NAME = savta_depth
+PYTHON_INTERPRETER = python3
+
+ifeq (,$(shell which conda))
+HAS_CONDA=False
+else
+HAS_CONDA=True
+endif
+
+#################################################################################
+# COMMANDS                                                                      #
+#################################################################################
+
+env:
+ifeq (True,$(HAS_CONDA))
+	@echo ">>> Detected conda, creating conda environment."
+	conda create -y --name $(PROJECT_NAME) python=3.7.6 
+	@echo ">>> New conda env created. Activate with:\nconda activate $(PROJECT_NAME)"
+else
+	@echo ">>> No conda detected, creating venv environment."
+	$(PYTHON_INTERPRETER) -m venv env
+	@echo ">>> New virtual env created. Activate with:\nsource env/bin/activate ."
+endif
+
+load_requirements:
+	@echo ">>> Installing requirements. Make sure your virtual environment is activated."
+	$(PYTHON_INTERPRETER) -m pip install -U pip setuptools wheel
+	$(PYTHON_INTERPRETER) -m pip install -r requirements.txt
+
+save_requirements:
+	@echo ">>> Saving requirements."
+	pip list --format=freeze > requirements.txt

README.md

@@ -4,6 +4,12 @@ Savta Depth is a collaborative *O*pen *S*ource *D*ata *S*cience project for mono
 Here you will find the code for the project, but also the data, models, pipelines and experiments. This means that the project is easily reproducible on any machine, but also that you can contribute to it as a data scientist.
 
 Have a great idea for how to improve the model? Want to add data and metrics to make it more explainable/fair? We'd love to get your help.
+## Demo
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1XU4DgQ217_hUMU1dllppeQNw3pTRlHy1?usp=sharing)
+
+**You can use [this notebook](https://colab.research.google.com/drive/1XU4DgQ217_hUMU1dllppeQNw3pTRlHy1?usp=sharing) to load a model from the project and run it on an image you uploaded, to get the depth map. Once it has been saved, you can download it to use on platforms that support it (e.g. Facebook) to create 3d photos.**
+
+![](https://i.ibb.co/r20HKpQ/savtadepthex.png)
 
 ## Contributing Guide
 Here we'll list things we want to work on in the project as well as ways to start contributing.
@@ -11,23 +17,116 @@ If you'd like to take part, please follow the guide.
 
 ### Setting up your environment to contribute
 * To get started, fork the repository on DAGsHub
-* Next, clone the repository you just forked by typing the following command in your terminal:
-  ```bash
-  $ git clone https://dagshub.com/<your-dagshub-username>/SavtaDepth.git
-  $ dvc checkout #use this to get the data, models etc
-  ```
-* To get your environment up and running docker is the best way to go.
-  We created a dockerfile that has all you need in it and will install all requirements in the 'requirements.txt' file as well as run a jupyter lab instance.
-    * Just open the terminal in your project directory and type `docker build "savta_depth_dev" ."
-    * After the docker image is created run the following commands:
+* Now, you have 3 way to set up your environment: Google Colab, local or docker. If you're not sure which one to go with, we recommend using Colab.
+
+#### Google Colab
+Google Colab can be looked at as your web connected, GPU powered IDE. Below is a link to a well-documented Colab notebook, that will load the code and data from this repository, enabling you to modify the code and re-run training. Notice that you still need to modify the code within the `src/code/` folder, adding cells should be used only for testing things out.
+
+**You can also use this notebook to load a model from the project and run it on an image you uploaded, to get the depth map. Once it has been saved, you can download it to use on platforms that support it (e.g. Facebook) to create 3d photos.**
+
+
+In order to edit code files, you must save the notebook to your drive. You can do this by typing `ctrl+s` or `cmd+s` on mac.
+
+\>\> **[SavtaDepth Colab Environment](https://colab.research.google.com/drive/1XU4DgQ217_hUMU1dllppeQNw3pTRlHy1?usp=sharing)** \<\<
+
+**_NOTE: The downside of this method (if you are not familiar with Colab) is that Google Colab will limit the amount of time an instance can be live, so you might be limited in your ability to train models for longer periods of time._**
+
+This notebook is also a part of this project, in case it needs modification, in the `Notebooks` folder. You should not commit your version unless your contribution is an improvement to the environment.
+
+#### Local
+* Clone the repository you just forked by typing the following command in your terminal:
+
+    ```bash
+    $ git clone https://dagshub.com/<your-dagshub-username>/SavtaDepth.git
+    ```
+  
+* Create a virtual environment or Conda environment and activate it
+    ```bash
+    # Create the virtual environment
+    $ make env
+  
+    # Activate the virtual environment
+    # VENV
+    $ source env/bin/activate .
+  
+    # or Conda
+    $ source activate savta_depth
+    ```
+* Install the required libraries
+    ```bash
+    $ make load_requirements
+    ```
+  **_NOTE: Here I assume a setup without GPU. Otherwise, you might need to modify requirements, which is outside the scope of this readme (feel free to contribute to this)._**
+* Pull the dvc files to your workspace by typing:
+
+    ```bash
+    $ dvc pull -r origin
+    $ dvc checkout #use this to get the data, models etc
+    ```
+
+* After you are finished your modification, make sure to do the following:
+    * If you modified packages, make sure to update the `requirements.txt` file accordingly.
+
+    * Push your code to DAGsHub, and your dvc managed files to your dvc remote. For reference on the commands needed, please refer to the Google Colab notebook section – [Commiting Your Work and Pushing Back to DAGsHub](https://colab.research.google.com/drive/1XU4DgQ217_hUMU1dllppeQNw3pTRlHy1?authuser=1#scrollTo=PAxz-29WhN12&line=1&uniqifier=1).
+    
+#### Docker
+* Clone the repository you just forked by typing the following command in your terminal:
+  
     ```bash
-    $ chmod +x run_dev_env.sh
-    $ ./run_dev_env.sh
+    $ git clone https://dagshub.com/<your-dagshub-username>/SavtaDepth.git
     ```
-    * Open localhost:8888 and you are good to go
-* After you are finished your modification, don't forget to push your code to DAGsHub, and your dvc managed files to your dvc remote. In order to setup a dvc remote please refer to [this guide](https://dagshub.com/docs/getting-started/set-up-remote-storage-for-data-and-models/).
+  
+* To get your environment up and running docker is the best way to go. We use an instance of [MLWorkspace](https://github.com/ml-tooling/ml-workspace). 
+    * You can Just run the following commands to get it started.
+
+        ```bash
+        $ chmod +x run_dev_env.sh
+        $ ./run_dev_env.sh
+        ```
+
+    * Open localhost:8080 to see the workspace you have created. You will be asked for a token – enter `dagshub_savta`
+    * In the top right you have a menu called `Open Tool`. Click that button and choose terminal (alternatively open VSCode and open terminal there) and type in the following commands to install a virtualenv and dependencies:
+
+        ```bash
+        $ make env
+        $ source activate savta_depth
+        ```
+        
+        Now when we have an environment, let's install all of the required libraries.
+        
+        **Note**: If you don't have a GPU you will need to install pytorch separately and then run make requirements. You can install pytorch for computers without a gpu with the following command:
+
+        ```bash
+        $ conda install pytorch torchvision cpuonly -c pytorch
+        ```
+        
+        To install the required libraries run the following command:
+        
+        ```bash
+        $ make load_requirements
+        ```
+
+
+* Pull the dvc files to your workspace by typing:
+
+    ```bash
+    $ dvc pull -r dvc-remote
+    $ dvc checkout #use this to get the data, models etc
+    ```
+
+* After you are finished your modification, make sure to do the following:
+    * If you modified packages, make sure to update the `requirements.txt` file accordingly.
+
+    * Push your code to DAGsHub, and your dvc managed files to your dvc remote. For reference on the commands needed, please refer to the Google Colab notebook section – [Commiting Your Work and Pushing Back to DAGsHub](https://colab.research.google.com/drive/1XU4DgQ217_hUMU1dllppeQNw3pTRlHy1?authuser=1#scrollTo=PAxz-29WhN12&line=1&uniqifier=1).
+    
+---
+### After pushing code and data to DAGsHub
 * Create a Pull Request on DAGsHub!
+    * Explain what changes you are making.
+    * If your changes affect data or models, make sure they are pushed to your DAGsHub dvc remote, and are included in the PR.
+    * We will review your contribution ASAP, and merge it or start a discussion if needed.
 * 🐶
+
 ### TODO:
 - [ ] Web UI
 - [ ] Testing various datasets as basis for training

dvc.lock

@@ -0,0 +1,71 @@
+process_data:
+  cmd: python3 src/code/make_dataset.py src/data/raw/nyu_depth_v2_labeled.mat src/data/raw/splits.mat
+    src/data/processed
+  deps:
+  - path: src/code/make_dataset.py
+    md5: e069c7323c9be16baedd8f988375e145
+    size: 5256
+  - path: src/data/raw/nyu_depth_v2_labeled.mat
+    md5: 520609c519fba3ba5ac58c8fefcc3530
+    size: 2972037809
+  - path: src/data/raw/splits.mat
+    md5: 08e3c3aea27130ac7c01ffd739a4535f
+    size: 2626
+  outs:
+  - path: src/data/processed/
+    md5: 9a1f43f46e8b1c387532e994e721d57d.dir
+    size: 197717291
+    nfiles: 2898
+train:
+  cmd: python3 src/code/training.py src/data/processed/train
+  deps:
+  - path: src/code/custom_data_loading.py
+    md5: c94ea029ed76ca94bb1ad4c1655e5e68
+    size: 1916
+  - path: src/code/params.yml
+    md5: 2263ca2167c1bb4b0f53a9aedb5f238e
+    size: 217
+  - path: src/code/training.py
+    md5: e3dff7f4b59e4ebf818d7631d3e6803a
+    size: 1683
+  - path: src/data/processed/train
+    md5: 9956d748dcadc3abadd1ff966a6e2b92.dir
+    size: 109120921
+    nfiles: 1590
+  outs:
+  - path: logs/train_metrics.csv
+    md5: 437a06e6c6c5b4f6eec5e546c1ce6930
+    size: 103916
+  - path: logs/train_params.yml
+    md5: e06e92ac0f3ac1d367c22a10c28cccf9
+    size: 886
+  - path: src/models/
+    md5: fab42526c433987e0e6370db31a1869d.dir
+    size: 494927196
+    nfiles: 1
+eval:
+  cmd: python3 src/code/eval.py src/data/processed/test
+  deps:
+  - path: src/code/custom_data_loading.py
+    md5: c94ea029ed76ca94bb1ad4c1655e5e68
+    size: 1916
+  - path: src/code/eval.py
+    md5: fcc66ed80bb4466ab0438f556acd125c
+    size: 1775
+  - path: src/code/eval_metric_calculation.py
+    md5: 2fc866e1107042a996087d5716d44bf0
+    size: 2999
+  - path: src/code/params.yml
+    md5: 2263ca2167c1bb4b0f53a9aedb5f238e
+    size: 217
+  - path: src/data/processed/test
+    md5: bcccd66f3f561b53ba97c89a558c08a0.dir
+    size: 88596370
+    nfiles: 1308
+  - path: src/models/model.pth
+    md5: 2fd77305fd779eefd11e307ee3f201d7
+    size: 494927196
+  outs:
+  - path: logs/test_metrics.csv
+    md5: 0add355c58eb4dfa1ae7e28e47750d33
+    size: 340

dvc.yaml

@@ -0,0 +1,36 @@
+stages:
+  process_data:
+    cmd: python3 src/code/make_dataset.py src/data/raw/nyu_depth_v2_labeled.mat src/data/raw/splits.mat
+      src/data/processed
+    deps:
+    - src/code/make_dataset.py
+    - src/data/raw/nyu_depth_v2_labeled.mat
+    - src/data/raw/splits.mat
+    outs:
+    - src/data/processed/
+  train:
+    cmd: python3 src/code/training.py src/data/processed/train
+    deps:
+    - src/code/custom_data_loading.py
+    - src/code/params.yml
+    - src/code/training.py
+    - src/data/processed/train
+    outs:
+    - src/models/
+    - logs/train_params.yml:
+        cache: false
+    metrics:
+    - logs/train_metrics.csv:
+        cache: false
+  eval:
+    cmd: python3 src/code/eval.py src/data/processed/test
+    deps:
+    - src/code/params.yml
+    - src/code/custom_data_loading.py
+    - src/code/eval_metric_calculation.py
+    - src/code/eval.py
+    - src/models/model.pth
+    - src/data/processed/test
+    metrics:
+    - logs/test_metrics.csv:
+        cache: false

logs/test_metrics.csv

@@ -0,0 +1,10 @@
+Name,Value,Timestamp,Step
+"a1",0.056999333,1613824849186,1
+"a2",0.118539445,1613824849186,1
+"a3",0.19929159,1613824849186,1
+"abs_rel",2.5860002,1613824849186,1
+"sq_rel",15.912783,1613824849186,1
+"rmse",5.257741,1613824849186,1
+"rmse_log",1.2291939,1613824849186,1
+"log10",0.49469143,1613824849186,1
+"silog",43.5198,1613824849186,1

logs/train_params.yml

@@ -0,0 +1,25 @@
+DAGsHubLogger: true
+Learner: <fastai.learner.Learner object at 0x7f051ecfcac8>
+ParamScheduler: true
+ProgressCallback: true
+Recorder: {add_time: true, train_metrics: false, valid_metrics: true}
+TrainEvalCallback: true
+batch per epoch: 159
+batch size: 4
+dataset.tfms: '[Pipeline: PILBase.create, Pipeline: get_y_fn -> PILBase.create]'
+device: cuda
+dls.after_batch: "Pipeline: IntToFloatTensor -- {'div': 255.0, 'div_mask': 1} -> Normalize\
+  \ -- {'mean': tensor([[[[0.4850]],\n\n         [[0.4560]],\n\n         [[0.4060]]]],\
+  \ device='cuda:0'), 'std': tensor([[[[0.2290]],\n\n         [[0.2240]],\n\n    \
+  \     [[0.2250]]]], device='cuda:0'), 'axes': (0, 2, 3)}"
+dls.after_item: 'Pipeline: ToTensor'
+dls.before_batch: 'Pipeline: '
+frozen: true
+frozen idx: 2
+input 1 dim 1: 4
+input 1 dim 2: 3
+input 1 dim 3: 480
+input 1 dim 4: 640
+model parameters: 41221268
+n_inp: 1
+success: true

requirements.txt

@@ -0,0 +1,10 @@
+dvc==1.11.15
+fastai==2.2.5
+torch==1.7.0
+h5py==2.10.0
+opencv-python==4.4.0.42
+tqdm==4.52.0
+numpy==1.19.4
+scikit-learn==0.23.2
+dagshub==0.1.5
+tables==3.6.1

run_dev_env.sh

@@ -1,10 +1,7 @@
-docker run --rm -p 8888:8888 \
-  --ipc=host \
-  --volume="$PWD:/workspace" \
-  savta_depth_dev jupyter lab \
-    --ip=0.0.0.0 \
-    --port=8888 \
-    --allow-root \
-    --no-browser \
-    --NotebookApp.token='' \
-    --NotebookApp.password=''
+docker run -d \
+    -p 8080:8080 \
+    --name "dags-ml-workspace" -v "/${PWD}:/workspace" \
+    --env AUTHENTICATE_VIA_JUPYTER="dagshub_savta" \
+    --shm-size 2G \
+    --restart always \
+    dagshub/ml-workspace-minimal:latest

src/.gitignore

@@ -0,0 +1,2 @@
+/models
+/eval

src/code/custom_data_loading.py

@@ -0,0 +1,51 @@
+import yaml
+from fastai.vision.all import \
+    DataLoaders, \
+    delegates, \
+    DataBlock, \
+    ImageBlock, \
+    PILImage, \
+    PILImageBW, \
+    RandomSplitter, \
+    Path, \
+    get_files
+
+
+class ImageImageDataLoaders(DataLoaders):
+    """Basic wrapper around several `DataLoader`s with factory methods for Image to Image problems"""
+    @classmethod
+    @delegates(DataLoaders.from_dblock)
+    def from_label_func(cls, path, filenames, label_func, valid_pct=0.2, seed=None, item_transforms=None,
+                        batch_transforms=None, **kwargs):
+        """Create from list of `fnames` in `path`s with `label_func`."""
+        datablock = DataBlock(blocks=(ImageBlock(cls=PILImage), ImageBlock(cls=PILImageBW)),
+                              get_y=label_func,
+                              splitter=RandomSplitter(valid_pct, seed=seed),
+                              item_tfms=item_transforms,
+                              batch_tfms=batch_transforms)
+        res = cls.from_dblock(datablock, filenames, path=path, **kwargs)
+        return res
+
+
+def get_y_fn(x):
+    y = str(x.absolute()).replace('.jpg', '_depth.png')
+    y = Path(y)
+
+    return y
+
+
+def create_data(data_path):
+    with open(r"./src/code/params.yml") as f:
+        params = yaml.safe_load(f)
+
+    filenames = get_files(data_path, extensions='.jpg')
+    if len(filenames) == 0:
+        raise ValueError("Could not find any files in the given path")
+    dataset = ImageImageDataLoaders.from_label_func(data_path,
+                                                    seed=int(params['seed']),
+                                                    bs=int(params['batch_size']),
+                                                    num_workers=int(params['num_workers']),
+                                                    filenames=filenames,
+                                                    label_func=get_y_fn)
+
+    return dataset

src/code/eval.py

@@ -0,0 +1,52 @@
+import sys
+import yaml
+import torch
+from torchvision import transforms
+from fastai.vision.all import unet_learner, Path, resnet34, MSELossFlat, get_files, L, tuplify
+from custom_data_loading import create_data
+from eval_metric_calculation import compute_eval_metrics
+from dagshub import dagshub_logger
+from tqdm import tqdm
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("usage: %s <test_data_path>" % sys.argv[0], file=sys.stderr)
+        sys.exit(0)
+
+    with open(r"./src/code/params.yml") as f:
+        params = yaml.safe_load(f)
+
+    data_path = Path(sys.argv[1])
+    data = create_data(data_path)
+
+    arch = {'resnet34': resnet34}
+    loss = {'MSELossFlat': MSELossFlat()}
+
+    learner = unet_learner(data,
+                           arch.get(params['architecture']),
+                           n_out=int(params['num_outs']),
+                           loss_func=loss.get(params['loss_func']),
+                           path='src/',
+                           model_dir='models')
+    learner = learner.load('model')
+
+    filenames = get_files(Path(data_path), extensions='.jpg')
+    test_files = L([Path(i) for i in filenames])
+
+    for sample in tqdm(test_files.items, desc="Predicting on test images", total=len(test_files.items)):
+        pred = learner.predict(sample)[0]
+        pred = transforms.ToPILImage()(pred[:, :, :].type(torch.FloatTensor)).convert('L')
+        pred.save("src/eval/" + str(sample.stem) + "_pred.png")
+
+    print("Calculating metrics...")
+    metrics = compute_eval_metrics(test_files)
+
+    with dagshub_logger(
+            metrics_path="logs/test_metrics.csv",
+            should_log_hparams=False
+    ) as logger:
+        # Metric logging
+        logger.log_metrics(metrics)
+
+    print("Evaluation Done!")

src/code/eval_metric_calculation.py

@@ -0,0 +1,79 @@
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+
+def compute_errors(target, prediction):
+    thresh = np.maximum((target / prediction), (prediction / target))
+    a1 = (thresh < 1.25).mean()
+    a2 = (thresh < 1.25 ** 2).mean()
+    a3 = (thresh < 1.25 ** 3).mean()
+
+    abs_rel = np.mean(np.abs(target - prediction) / target)
+    sq_rel = np.mean(((target - prediction) ** 2) / target)
+
+    rmse = (target - prediction) ** 2
+    rmse = np.sqrt(rmse.mean())
+
+    rmse_log = (np.log(target) - np.log(prediction)) ** 2
+    rmse_log = np.sqrt(rmse_log.mean())
+
+    err = np.log(prediction) - np.log(target)
+    silog = np.sqrt(np.mean(err ** 2) - np.mean(err) ** 2) * 100
+
+    log_10 = (np.abs(np.log10(target) - np.log10(prediction))).mean()
+
+    return a1, a2, a3, abs_rel, sq_rel, rmse, rmse_log, silog, log_10
+
+
+def compute_eval_metrics(test_files):
+    min_depth_eval = 1e-3
+    max_depth_eval = 10
+
+    num_samples = len(test_files)
+
+    a1 = np.zeros(num_samples, np.float32)
+    a2 = np.zeros(num_samples, np.float32)
+    a3 = np.zeros(num_samples, np.float32)
+    abs_rel = np.zeros(num_samples, np.float32)
+    sq_rel = np.zeros(num_samples, np.float32)
+    rmse = np.zeros(num_samples, np.float32)
+    rmse_log = np.zeros(num_samples, np.float32)
+    silog = np.zeros(num_samples, np.float32)
+    log10 = np.zeros(num_samples, np.float32)
+
+    for i in tqdm(range(num_samples), desc="Calculating metrics for test data", total=num_samples):
+        sample_path = test_files[i]
+        target_path = str(sample_path.parent/(sample_path.stem + "_depth.png"))
+        pred_path = "src/eval/" + str(sample_path.stem) + "_pred.png"
+
+        target_image = Image.open(target_path)
+        pred_image = Image.open(pred_path)
+
+        target = np.asarray(target_image)
+        pred = np.asarray(pred_image)
+
+        target = target / 25.0
+        pred = pred / 25.0
+
+        pred[pred < min_depth_eval] = min_depth_eval
+        pred[pred > max_depth_eval] = max_depth_eval
+        pred[np.isinf(pred)] = max_depth_eval
+
+        target[np.isinf(target)] = 0
+        target[np.isnan(target)] = 0
+
+        valid_mask = np.logical_and(target > min_depth_eval, target < max_depth_eval)
+
+        a1[i], a2[i], a3[i], abs_rel[i], sq_rel[i], rmse[i], rmse_log[i], silog[i], log10[i] = \
+            compute_errors(target[valid_mask], pred[valid_mask])
+
+    print("{:>7}, {:>7}, {:>7}, {:>7}, {:>7}, {:>7}, {:>7}, {:>7}, {:>7}".format(
+        'd1', 'd2', 'd3', 'AbsRel', 'SqRel', 'RMSE', 'RMSElog', 'SILog', 'log10'))
+    print("{:7.3f}, {:7.3f}, {:7.3f}, {:7.3f}, {:7.3f}, {:7.3f}, {:7.3f}, {:7.3f}, {:7.3f}".format(
+        a1.mean(), a2.mean(), a3.mean(),
+        abs_rel.mean(), sq_rel.mean(), rmse.mean(), rmse_log.mean(), silog.mean(), log10.mean()))
+
+    return dict(a1=a1.mean(), a2=a2.mean(), a3=a3.mean(),
+                abs_rel=abs_rel.mean(), sq_rel=sq_rel.mean(),
+                rmse=rmse.mean(), rmse_log=rmse_log.mean(),
+                log10=log10.mean(), silog=silog.mean())

src/code/make_dataset.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#######################################################################################
+# The MIT License
+
+# Copyright (c) 2014       Hannes Schulz, University of Bonn  <schulz@ais.uni-bonn.de>
+# Copyright (c) 2013       Benedikt Waldvogel, University of Bonn <mail@bwaldvogel.de>
+# Copyright (c) 2008-2009  Sebastian Nowozin                       <nowozin@gmail.com>
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#######################################################################################
+#
+# See https://github.com/deeplearningais/curfil/wiki/Training-and-Prediction-with-the-NYU-Depth-v2-Dataset
+
+
+"""Helper script to convert the NYU Depth v2 dataset Matlab file into a set of PNG and JPEG images.
+Receives 3 Files from argparse:
+<h5_file> - Contains the original images, depths maps, and scene types
+<train_test_split> - contains two numpy arrays with the index of the
+                    images based on the split to train and test sets.
+<out_folder> - Name of the folder to save the original and depth images.
+
+Every image in the DB will have it's twine B&W image that indicates the depth
+in the image. the images will be read, converted by the convert_image function
+and finally saved to path based on train test split and Scene types.
+"""
+
+from __future__ import print_function
+
+import h5py
+import numpy as np
+import os
+import scipy.io
+import sys
+import cv2
+from tqdm import tqdm
+
+
+def convert_image(index, depth_map, img, output_folder):
+    """Processes data images and depth maps
+    :param index: int, image index
+    :param depth_map: numpy array, image depth - 2D array.
+    :param img: numpy array, the original RGB image - 3D array.
+    :param output_folder: path to save the image in.
+
+    Receives an image with it's relevant depth map.
+    Normalizes the depth map, and adds a 7 px boundary to the original image.
+    Saves both image and depth map to the appropriate processed data folder.
+    """
+
+    # Normalize the depth image
+    # normalized_depth = cv2.normalize(depth_map, None, 0, 255, cv2.NORM_MINMAX)
+    img_depth = depth_map * 25.0
+    cv2.imwrite("%s/%05d_depth.png" % (output_folder, index), img_depth)
+
+    # Adding black frame to original image
+    img = img[:, :, ::-1]  # Flipping the image from RGB to BGR for opencv
+    image_black_boundary = np.zeros(img.shape, dtype=np.uint8)
+    image_black_boundary[7:image_black_boundary.shape[0] - 6, 7:image_black_boundary.shape[1] - 6, :] = \
+        img[7:img.shape[0] - 6, 7:img.shape[1] - 6, :]
+    cv2.imwrite("%s/%05d.jpg" % (output_folder, index), image_black_boundary)
+
+
+if __name__ == "__main__":
+
+    # Check if got all needed input for argparse
+    if len(sys.argv) != 4:
+        print("usage: %s <h5_file> <train_test_split> <out_folder>" % sys.argv[0], file=sys.stderr)
+        sys.exit(0)
+
+    # load arguments to variables
+    h5_file = h5py.File(sys.argv[1], "r")
+    train_test = scipy.io.loadmat(sys.argv[2])  # h5py is not able to open that file. but scipy is
+    out_folder = sys.argv[3]
+
+    # Extract images *indexes* for train and test data sets
+    test_images = set([int(x) for x in train_test["testNdxs"]])
+    train_images = set([int(x) for x in train_test["trainNdxs"]])
+    print("%d training images" % len(train_images))
+    print("%d test images" % len(test_images))
+
+    # Grayscale
+    depth = h5_file['depths']
+    print("Reading", sys.argv[1])
+    images = h5_file['images']  # (num_channels, height, width)
+
+    # Extract all sceneTypes per image - "office", "classroom", etc.
+    scenes = [u''.join(chr(c[0]) for c in h5_file[obj_ref]) for obj_ref in h5_file['sceneTypes'][0]]
+
+    for i, image in tqdm(enumerate(images), desc="Processing images", total=len(images)):
+        idx = int(i) + 1
+        if idx in train_images:
+            train_test = "train"
+        else:
+            assert idx in test_images, "index %d neither found in training set nor in test set" % idx
+            train_test = "test"
+
+        # Create path to save image in
+        folder = "%s/%s/%s" % (out_folder, train_test, scenes[i])
+        if not os.path.exists(folder):
+            os.makedirs(folder)
+
+        convert_image(i, depth[i, :, :].T, image.T, folder)
+
+    print("Finished")

src/code/params.yml

@@ -0,0 +1,13 @@
+seed: 42
+data: nyu_depth_v2
+batch_size: 4
+num_workers: 0
+weight_decay: 1e-2
+learning_rate: 1e-3
+epochs: 1
+num_outs: 3
+source_dir: src
+model_dir: models
+architecture: resnet34
+loss_func: MSELossFlat
+train_metric: rmse

src/code/training.py

@@ -0,0 +1,44 @@
+"""Trains or fine-tunes a model for the task of monocular depth estimation
+Receives 1 arguments from argparse:
+  <data_path> - Path to the dataset which is split into 2 folders - train and test.
+"""
+import sys
+import yaml
+from fastai.vision.all import unet_learner, Path, resnet34, rmse, MSELossFlat
+from custom_data_loading import create_data
+from dagshub.fastai import DAGsHubLogger
+
+
+if __name__ == "__main__":
+    # Check if got all needed input for argparse
+    if len(sys.argv) != 2:
+        print("usage: %s <data_path>" % sys.argv[0], file=sys.stderr)
+        sys.exit(0)
+
+    with open(r"./src/code/params.yml") as f:
+        params = yaml.safe_load(f)
+
+    data = create_data(Path(sys.argv[1]))
+
+    metrics = {'rmse': rmse}
+    arch = {'resnet34': resnet34}
+    loss = {'MSELossFlat': MSELossFlat()}
+
+    learner = unet_learner(data,
+                           arch.get(params['architecture']),
+                           metrics=metrics.get(params['train_metric']),
+                           wd=float(params['weight_decay']),
+                           n_out=int(params['num_outs']),
+                           loss_func=loss.get(params['loss_func']),
+                           path=params['source_dir'],
+                           model_dir=params['model_dir'],
+                           cbs=DAGsHubLogger(
+                               metrics_path="logs/train_metrics.csv",
+                               hparams_path="logs/train_params.yml"))
+
+    print("Training model...")
+    learner.fine_tune(epochs=int(params['epochs']),
+                      base_lr=float(params['learning_rate']))
+    print("Saving model...")
+    learner.save('model')
+    print("Done!")

src/data/.gitignore

@@ -0,0 +1 @@
+/processed

src/data/raw/.gitignore

@@ -0,0 +1,2 @@
+/nyu_depth_v2_labeled.mat
+/splits.mat

src/data/raw/nyu_depth_v2_labeled.mat.dvc

@@ -0,0 +1,9 @@
+md5: d27a0ba6c898f981797a3388c26c2d0f
+frozen: true
+deps:
+- etag: '"b125b2b1-5aa5b95864fc7"'
+  path: http://horatio.cs.nyu.edu/mit/silberman/nyu_depth_v2/nyu_depth_v2_labeled.mat
+outs:
+- md5: 520609c519fba3ba5ac58c8fefcc3530
+  path: nyu_depth_v2_labeled.mat
+  size: 2972037809

src/data/raw/splits.mat.dvc

@@ -0,0 +1,9 @@
+md5: 26011289311c18b92781de66654223a4
+frozen: true
+deps:
+- etag: '"a42-4cb6a5fad2fc0"'
+  path: http://horatio.cs.nyu.edu/mit/silberman/indoor_seg_sup/splits.mat
+outs:
+- md5: 08e3c3aea27130ac7c01ffd739a4535f
+  path: splits.mat
+  size: 2626