diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..6bedce7 Binary files /dev/null and b/.DS_Store differ diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile new file mode 100644 index 0000000..165dae7 --- /dev/null +++ b/.devcontainer/Dockerfile @@ -0,0 +1,6 @@ +ARG VARIANT="3.11-bookworm" +# INFO, full list of python devcontainers available: + # https://mcr.microsoft.com/v2/vscode/devcontainers/python/tags/list +FROM mcr.microsoft.com/vscode/devcontainers/python:${VARIANT} + +ENV PATH="/home/vscode/.local/bin:${PATH}" diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 0000000..31b0c3e --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,54 @@ +{ +"name": "Python 3", +"build": { +"dockerfile": "Dockerfile", +"context": "..", +"args": { +"VARIANT": "3.11-bookworm" +} +}, +"customizations": { +"vscode": { +"settings": { +"python.defaultInterpreterPath": "/workspaces/tutorial-group-1/.venv/bin/python", +"python.terminal.activateEnvironment": true, +"python.testing.pytestArgs": [ +"tests" +], +"python.testing.pytestEnabled": true, +"python.testing.unittestEnabled": false, +"python.testing.pytestPath": "/workspaces/tutorial-group-1/.venv/bin/pytest" +}, +"extensions": [ +"bierner.markdown-mermaid", +"charliermarsh.ruff", +"EditorConfig.EditorConfig", +"github.vscode-github-actions", +"ms-toolsai.jupyter", +"ms-toolsai.jupyter-keymap", +"ms-toolsai.jupyter-renderers", +"ms-python.python", +"ms-python.vscode-pylance", +"ms-toolsai.vscode-jupyter-cell-tags", +"ms-toolsai.vscode-jupyter-slideshow", +"ms-vsliveshare.vsliveshare", +"ryanluker.vscode-coverage-gutters" +] +} +}, +"forwardPorts": [ +8888 +], +"portsAttributes": { +"8888": { +"label": "Jupyter Notebook" +} +}, +"updateContentCommand": "git config --global --add safe.directory /workspaces/tutorial-group-1; make create_venv; echo 'NOTE: PyTorch is NOT installed by default. To install PyTorch (CPU-only), run: source .venv/bin/activate && make install-torch'", +"postCreateCommand": "echo 'source /workspaces/tutorial-group-1/.venv/bin/activate' >> ~/.bashrc; echo 'echo -e \"\\nāš ļø IMPORTANT: PyTorch is not installed by default due to size constraints.\"' >> ~/.bashrc; echo 'echo \"To install PyTorch (CPU-only ~730MB), run:\"' >> ~/.bashrc; echo 'echo \" source .venv/bin/activate && make install-torch\"' >> ~/.bashrc", +"remoteUser": "root", +"features": { +"git": "latest", +"github-cli": "latest" +} +} diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..dfe0770 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +# Auto detect text files and perform LF normalization +* text=auto diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml new file mode 100644 index 0000000..4611cd4 --- /dev/null +++ b/.github/workflows/main.yml @@ -0,0 +1,35 @@ +name: Linting +on: + push: + branches: + - main + pull_request: + branches: + - main + +permissions: + contents: read + +jobs: + lint: + name: Linting (Python ${{ matrix.python-version }}) + runs-on: ubuntu-latest + strategy: + fail-fast: true + matrix: + python-version: ['3.11'] + steps: + - name: Checkout repository + uses: actions/checkout@v4 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python3 -m pip install --upgrade pip + pip install -e .[dev] + # Install PyTorch CPU-only version for CI + pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu + - name: Linting with pre-commit + run: pre-commit run --all-files diff --git a/.github/workflows/render-notebook.yml b/.github/workflows/render-notebook.yml new file mode 100644 index 0000000..fcc41ce --- /dev/null +++ b/.github/workflows/render-notebook.yml @@ -0,0 +1,57 @@ +name: Render Notebook to HTML + +on: + push: + branches: + - main + paths: + - 'notebooks/tutorial_few_shot_learning.ipynb' + pull_request: + branches: + - main + paths: + - 'notebooks/tutorial_few_shot_learning.ipynb' + workflow_dispatch: + +permissions: + contents: write + +jobs: + render: + runs-on: ubuntu-latest + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Setup Python + uses: actions/setup-python@v5 + with: + python-version: '3.11' + + - name: Install dependencies + run: | + python3 -m pip install --upgrade pip + pip install nbconvert jupyter + + - name: Convert notebook to HTML + run: | + jupyter nbconvert \ + --to html \ + notebooks/tutorial_few_shot_learning.ipynb \ + --output tutorial_few_shot_learning.html \ + --output-dir docs/ + + # Only commit on push to main, NOT on PRs + - name: Commit rendered HTML + if: github.event_name == 'push' && github.ref == 'refs/heads/main' + run: | + git config --local user.email "github-actions[bot]@users.noreply.github.com" + git config --local user.name "github-actions[bot]" + git add docs/tutorial_few_shot_learning.html + if ! git diff --staged --quiet; then + git commit -m "Auto-render notebook to HTML [skip ci]" + git push + else + echo "No changes to commit" + fi diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..06109db --- /dev/null +++ b/.gitignore @@ -0,0 +1,153 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..b47f163 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,52 @@ +# pre-commit: A framework for managing and maintaining multi-language pre-commit hooks +# after configuration is complete, do these steps: + # pre-commit install + # pre-commit run --all-files +# to skip pre-commmit-config when git-committing in terminal, add this: "--no-verify" option. + +ci: + autoupdate_commit_msg: "chore: update pre-commit hooks" + autofix_commit_msg: "style: pre-commit fixes" + +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.5.0 + hooks: + - id: check-added-large-files + - id: check-case-conflict + - id: check-merge-conflict + - id: check-symlinks + - id: mixed-line-ending + - id: name-tests-test + args: [--pytest-test-first] + # pygrep-hooks: a collection of fast, cheap, regex based pre-commit hooks + - repo: https://github.com/pre-commit/pygrep-hooks + rev: v1.10.0 + hooks: + - id: python-no-log-warn + - id: python-no-eval + exclude: ^src/few_shot_utils/(train|evaluate)\.py$ + - id: rst-directive-colons + - id: rst-inline-touching-normal + # check-manifest: This makes sense only if you have MANIFEST.in (TODO:review) + - repo: https://github.com/mgedmin/check-manifest + rev: "0.47" + hooks: + - id: check-manifest + stages: [manual] + # pip audit to check for known pip vulnerabilities, supports pyproject.toml + - repo: https://github.com/pypa/pip-audit + rev: v2.7.1 + hooks: + - id: pip-audit + #Ruff linter and formatter + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.8.2 + hooks: + # Recommended to run linter first of automatic fixes are enabled (as some linting fixes might require reformatting) + - id: ruff + #Automatic linting fixes + types_or: [ python, pyi, jupyter ] + args: [ --fix ] + - id: ruff-format + types_or: [ python, pyi, jupyter ] diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..f0738b5 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,12 @@ +{ + "files.trimTrailingWhitespace": true, + "git.autofetch": true, + "[jsonc]": {"editor.defaultFormatter": "vscode.json-language-features"}, + "[python]": { + "editor.defaultFormatter": "charliermarsh.ruff", + "editor.formatOnSave": false + }, + "[jupyter]": { + "editor.defaultFormatter": "charliermarsh.ruff" + } +} diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 0000000..72c37e1 --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,30 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "create_venv", + "type": "shell", + "command": "make", + "args": ["create_venv"], + "group": { + "kind": "build", + "isDefault": true + }, + "presentation": { + "reveal": "always", + "panel": "new" + } + }, + { + "label": "run_tests", + "type": "shell", + "command": "make", + "args": ["run_pytest_with_cov"], + "group": "test", + "presentation": { + "reveal": "always", + "panel": "new" + } + } + ] +} diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..727a39b --- /dev/null +++ b/Makefile @@ -0,0 +1,36 @@ +SHELL := /bin/bash + +.PHONY: create_venv install install-torch lint help + +help: + @echo "Available targets:" + @echo " create_venv - Create virtual environment and install dependencies (without torch)" + @echo " install - Install package with dev dependencies (without torch)" + @echo " install-torch - Install PyTorch CPU-only version" + @echo " lint - Run pre-commit hooks on all files" + +create_venv: + @echo "Creating virtual environment..." + python3 -m venv .venv + @echo "Installing dependencies (without torch)..." + .venv/bin/python3 -m pip install --upgrade pip + .venv/bin/pip install -e .[dev] + @echo "" + @echo "Virtual environment created successfully!" + @echo "To install PyTorch (CPU-only), run: make install-torch" + @echo "Or manually install with:" + @echo " pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu" + +install: + python3 -m pip install --upgrade pip + pip install -e .[dev] + @echo "Dependencies installed (without torch)." + @echo "To install PyTorch (CPU-only), run: make install-torch" + +install-torch: + @echo "Installing PyTorch CPU-only version..." + pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu + @echo "PyTorch installed successfully!" + +lint: + pre-commit run --all-files diff --git a/README.md b/README.md index 0418de9..b3bbc14 100644 --- a/README.md +++ b/README.md @@ -1,37 +1,104 @@ -[![Review Assignment Due Date](https://classroom.github.com/assets/deadline-readme-button-22041afd0340ce965d47ae6ef1cefeee28c7c493a6346c4f15d667ab976d596c.svg)](https://classroom.github.com/a/15CTOpCR) -# Deep Learning E1394 - Tutorial - -## Submitting your work - -Once the deadline has passed, you are not able to push to your repository anymore or update it in any other way and all changes on the main branch will be considered for grading. In other words, there is no "submit" button which you need to press. You just need to ensure that all your work has been pushed / uploaded to GitHub before the deadline. - -Uploading a new or edited file to GitHub involves three steps: -1. Add the file to the staging area: - ``` - git add - ``` -2. Create a commit: - ``` - git commit -m - ``` -3. Push the local commit to GitHub: - ``` - git push - ``` - -To avoid conflicts when multiple people are working on the same file, we recommend to push your changes as frequently as possible and always pull the latest changes from GitHub before you start working. Also, as a nice teammate, test your changes before you push them and use meaninful commit messages to make it easy to understand your changes. - -## Asking for help - -If you have important questions or believe to have spotted an error, please open an issue on your repository and mention the teaching assistant with @chiara-fb and @henrycgbaker. - -## Useful Links -* Git best practices: https://gist.github.com/luismts/495d982e8c5b1a0ced4a57cf3d93cf60 -* How to write a good git commit message: https://cbea.ms/git-commit/ -* Book "Dive into Deep Learning": https://d2l.ai/ -* Tutorial on pushing and submitting work with GitHub classroom: https://www.youtube.com/watch?v=jXpT8eOzzCM -* Neural network from scratch: - * https://towardsdatascience.com/math-neural-network-from-scratch-in-python-d6da9f29ce65 - * https://pythonalgos.com/create-a-neural-network-from-scratch-in-python-3/ - * https://github.com/casperbh96/Neural-Network-From-Scratch/blob/master/NN_From_Scratch.ipynb - * https://www.codingame.com/playgrounds/59631/neural-network-xor-example-from-scratch-no-libs +# Few-Shot Learning for Rooftop Detection in Satellite Imagery +### GRAD-E1394 Deep Learning + +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/hertie-data-science-lab/tutorial-new-tutorial-group-1/blob/elena-setup/notebooks/tutorial_few_shot_learning.ipynb) + + +**Author(s):** Elena Dreyer, Giorgio Coppola, Nadine Daum, Nicolas Reichardt + +## Tutorial Overview + +This tutorial demonstrates few-shot learning techniques for semantic segmentation of satellite imagery. The dataset contains high-resolution satellite images of Geneva, Switzerland, with corresponding segmentation labels for rooftop detection. + +šŸ““ **[View Tutorial Notebook (HTML)](docs/tutorial_few_shot_learning.html)** + +### Learning Outcomes +- Understanding few-shot learning concepts for image segmentation +- Working with satellite imagery and segmentation masks +- Implementing and evaluating few-shot learning models for rooftop detection + +## Video Tutorial + + +[![Tutorial Video](https://img.youtube.com/vi/VIDEO_ID/0.jpg)](https://www.youtube.com/watch?v=VIDEO_ID) + +*Click the image above to watch the tutorial video* + +## Quick Start + +### Installation + +```bash +# Clone the repository +git clone https://github.com/hertie-data-science-lab/tutorial-new-tutorial-group-1.git +cd tutorial-group-1 + +# Create virtual environment +python3 -m venv .venv +source .venv/bin/activate + +# Install the package (without PyTorch) +pip install -e . + +# Install PyTorch (CPU-only version recommended to save disk space) +# CPU-only: ~730MB vs CUDA version: ~7GB +pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu + +# Or use the Makefile +make install +make install-torch +``` + +**Note:** PyTorch is not installed by default due to its large size. The CPU-only version is recommended for most use cases and saves significant disk space. + +### Running the Tutorial + +Open the main tutorial notebook: +```bash +jupyter notebook notebooks/tutorial_few_shot_learning.ipynb +``` + +## Project Structure + +``` +ā”œā”€ā”€ notebooks/ +│ └── tutorial_few_shot_learning.ipynb # Main tutorial notebook +ā”œā”€ā”€ src/few_shot_utils/ +│ ā”œā”€ā”€ __init__.py # Package initialization +│ ā”œā”€ā”€ data.py # Data loading utilities +│ ā”œā”€ā”€ models.py # Model architectures +│ ā”œā”€ā”€ train.py # Training functions +│ └── evaluate.py # Evaluation metrics +└── docs/ # Documentation +``` + +## Dataset Description + +The dataset consists of: +- **Satellite Images**: High-resolution RGB satellite images of Geneva, Switzerland +- **Segmentation Labels**: Binary masks indicating rooftop locations +- **Resolution**: Images at various resolutions suitable for few-shot learning + +## Development + +### Linting and Formatting + +This project uses [Ruff](https://docs.astral.sh/ruff/) for linting and formatting, including Jupyter notebooks. + +```bash +# Run linting with automatic fixes +ruff check . --fix +ruff format . + +# Run pre-commit hooks +pre-commit run --all-files +``` + +## References + +- +- + +## License + +This project is licensed under the MIT License - see the LICENSE file for details. diff --git a/docs/_config.yml b/docs/_config.yml new file mode 100644 index 0000000..f4755dc --- /dev/null +++ b/docs/_config.yml @@ -0,0 +1,9 @@ +title: Few-Shot Learning Tutorial +description: Few-shot learning for rooftop detection in satellite imagery +theme: jekyll-theme-primer +baseurl: "/tutorial-group-1" +url: "https://elenaivadreyer.github.io" + +# remote_theme: pages-themes/primer@v0.6.0 +# plugins: +# - jekyll-remote-theme # add this line to the plugins list if you already have one \ No newline at end of file diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..2175fad --- /dev/null +++ b/docs/index.md @@ -0,0 +1,54 @@ +--- +layout: default +title: Few-Shot Learning for Rooftop Detection +--- + +# Few-Shot Learning for Rooftop Detection in Satellite Imagery + +Welcome to the tutorial on few-shot learning for semantic segmentation of satellite imagery, focusing on rooftop detection in Geneva, Switzerland. + +## Tutorial Overview + +This tutorial demonstrates: +- Few-shot learning concepts for image segmentation +- Working with satellite imagery and segmentation masks +- Implementing and evaluating few-shot learning models for rooftop detection + +## Getting Started + +### Prerequisites +- Python 3.11+ +- PyTorch 2.0+ + +### Installation + +```bash +git clone https://github.com/hertie-data-science-lab/tutorial-new-tutorial-group-1.git +cd tutorial-group-1 +pip install -e . +``` + +### Running the Tutorial + +Open the main tutorial notebook: +```bash +jupyter notebook notebooks/tutorial_few_shot_learning.ipynb +``` + +## Video Tutorial + + +*Video coming soon...* + +## Dataset + +The dataset contains high-resolution satellite imagery of Geneva, Switzerland, with corresponding segmentation labels for rooftop detection. + +## Resources + +- [GitHub Repository](https://github.com/hertie-data-science-lab/tutorial-new-tutorial-group-1) +- [Tutorial Notebook](https://github.com/hertie-data-science-lab/tutorial-new-tutorial-group-1/blob/main/notebooks/tutorial_few_shot_learning.ipynb) + +## License + +This project is licensed under the MIT License. diff --git a/docs/installation.md b/docs/installation.md new file mode 100644 index 0000000..129e277 --- /dev/null +++ b/docs/installation.md @@ -0,0 +1,111 @@ +# Installation Guide + +This guide explains how to set up the tutorial environment. + +## Quick Start + +### Using Makefile (Recommended) + +```bash +# Create virtual environment and install dependencies +make create_venv + +# Activate virtual environment +source .venv/bin/activate + +# Install PyTorch (CPU-only) +make install-torch +``` + +### Manual Installation + +```bash +# Create and activate virtual environment +python3 -m venv .venv +source .venv/bin/activate + +# Install package dependencies (without PyTorch) +pip install -e . + +# Install PyTorch CPU-only version +pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu +``` + +## Why PyTorch is Optional + +PyTorch is not included as a direct dependency because: + +1. **Size**: The CUDA version is ~7GB, which can cause disk space issues +2. **CPU-only alternative**: The CPU-only version is ~730MB and sufficient for this tutorial +3. **Flexibility**: Users can choose between CPU and GPU versions based on their needs + +## PyTorch Installation Options + +### CPU-only (Recommended for most users) +```bash +pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu +``` + +### CUDA (If you have an NVIDIA GPU) +```bash +# For CUDA 11.8 +pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118 + +# For CUDA 12.1 +pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121 +``` + +For more installation options, see the [official PyTorch installation guide](https://pytorch.org/get-started/locally/). + +## Development Setup + +### Pre-commit Hooks + +This project uses pre-commit hooks for code quality. To set them up: + +```bash +# Install development dependencies +pip install -e .[dev] + +# Install pre-commit hooks +pre-commit install + +# Run hooks manually on all files +pre-commit run --all-files +``` + +### Makefile Targets + +- `make help` - Show available targets +- `make create_venv` - Create virtual environment and install dependencies +- `make install` - Install package with dev dependencies +- `make install-torch` - Install PyTorch CPU-only version +- `make lint` - Run pre-commit hooks on all files + +## Devcontainer Setup + +If you're using VS Code with devcontainers: + +1. Open the repository in VS Code +2. Click "Reopen in Container" when prompted +3. The container will build and install dependencies automatically +4. **Important**: PyTorch is not installed by default. To install it, run: + ```bash + source .venv/bin/activate && make install-torch + ``` + +## Troubleshooting + +### Disk Space Issues + +If you encounter disk space issues during installation: +- Make sure you're using the CPU-only version of PyTorch +- Clear pip cache: `pip cache purge` +- Consider using a cloud development environment with more storage + +### Import Errors + +If you get import errors for torch: +- Make sure PyTorch is installed: `pip list | grep torch` +- Verify you're using the correct virtual environment: `which python` +- Reinstall if necessary: `make install-torch` diff --git a/docs/memo.md b/docs/memo.md new file mode 100644 index 0000000..ecb89f8 --- /dev/null +++ b/docs/memo.md @@ -0,0 +1,7 @@ +Few-shot learning for satellite image segmentation is crucial for urban planning and disaster response. Traditional deep learning requires thousands of labeled samples, but few-shot learning enables rapid adaptation to new geographic regions with minimal labeled data. + +**Policy Applications:** +- Urban development monitoring +- Disaster damage assessment +- Property tax assessment +- Solar panel installation planning \ No newline at end of file diff --git a/docs/tutorial_few_shot_learning.html b/docs/tutorial_few_shot_learning.html new file mode 100644 index 0000000..f6a0408 --- /dev/null +++ b/docs/tutorial_few_shot_learning.html @@ -0,0 +1,8050 @@ + + + + + +tutorial_few_shot_learning + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ + diff --git a/notebooks/class_template.ipynb b/notebooks/class_template.ipynb new file mode 100644 index 0000000..67fda1b --- /dev/null +++ b/notebooks/class_template.ipynb @@ -0,0 +1,489 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "13i7KQ9t-CV8" + }, + "source": [ + "# Tutorial Notebook Template\n", + "## GRAD-E1394 Deep Learning -- Assignment 3\n", + "Author(s):\n", + "* Author, Email\n", + "\n", + "This serves as a template for Assignment 3.\n", + "\n", + "To get started, replace the tutorial notebook title and author information accordingly (one bullet point per group member). Replace the information in this cell with a brief summary of the tutorial as well as users' expected learning outcomes.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yNv0ANr5WcD_" + }, + "source": [ + "# Table of Contents\n", + "\n", + "\n", + "* [Memo](#memo)\n", + "* [Overview](#overview)\n", + "* [Background & Prerequisites](#background-and-prereqs)\n", + "* [Software Requirements](#software-requirements)\n", + "* [Data Description](#data-description)\n", + "* [Methodology](#methodology)\n", + "* [Results & Discussion](#results-and-discussion)\n", + "* [References](#references)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rqD_ftUYJE1n" + }, + "source": [ + "# General Guidelines\n", + "*(Please remove this and other guideline sections from your final tutorial submission.)*\n", + "\n", + "This template should help you create your tutorial. You may introduce modifications and extensions but adhere to the general principles for writing the tutorial:\n", + "\n", + "* Be brief.\n", + " * Keep it short and simple. Avoid unnecessary complexity.\n", + "* Clearly illustrate how the content relates to public policy.\n", + " * Identify the ways in which this tutorial would help the users (your collegues) in their work.\n", + "* Provide enough context.\n", + " * Explain important concepts directly in the tutorial notebook, but feel free to direct users to external resources when necessary. \n", + "* Avoid or minimize the use of jargon.\n", + " * Ideally, the content can be understood by both an ML audience and by people who are relatively new to ML and deep learning.\n", + "* Focus on readability and usability.\n", + " * Interleave code cells with explanatory text, keeping your audience in mind.\n", + "* Follow guidelines to avoid plagiarism.\n", + " * Any verbatim text needs to be put in quotation marks.\n", + " * Do not copy code.\n", + " * Clearly reference ideas and work of others.\n", + " * [Hertie School Code of Conduct](https://hertieschool-f4e6.kxcdn.com/fileadmin/5_WhoWeAre/Code_of_Conduct.pdf)\n", + "* Ensure reproducibility.\n", + " * Ensure that your notebook can be rerun by somebody else on a different machine in a reasonable amount of time. If the task is computationally expensive, provide an additional, smaller data sample for fast reproduction, and use that in your tutorial.\n", + "\n", + "## Additional Instructions\n", + "We highly recommend that you follow the [Ten simple rules for writing and sharing computational analyses using Jupyter Notebooks](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1007007). We summarize the ten rules as follows:\n", + "\n", + "
\n", + "\n", + "Rule, Adam, et al. \"Ten simple rules for writing and sharing computational analyses in Jupyter Notebooks.\" PLoS computational biology 15.7 (2019).
\n", + "\n", + "### Rule 1: Tell a story for an audience\n", + "* Interleave explanatory text and code to tell a compelling story.\n", + "* Describe not just what you did but why you did it.\n", + "* How you tell your story depends on your goal and your audience.\n", + "\n", + "### Rule 2: Document the process, not just the results\n", + "* Document relevant interactive explorations.\n", + "* Don't wait until the end to add explanatory text.\n", + "* Generate publication-ready version of figures from the get-go.\n", + "\n", + "### Rule 3: Use cell divisions to make steps clear\n", + "* Each cell should perform one meaningful step in the analysis.\n", + "* Think one cell = one paragraph, function, or task (e.g. creating a plot).\n", + "* Avoid long cells (50+ lines)\n", + "* Organize your notebook into sections/subsections. \n", + "\n", + "### Rule 4: Modularize code\n", + "* Avoid duplicate code (no copy-pasting!)\n", + "* Wrap the code that you want to reuse in a function.\n", + "* Use descriptive and meaningful variable and function names.\n", + "\n", + "### Rule 5: Record dependencies\n", + "* Manage your dependencies using a package or environment manager (e.g. pip,conda)\n", + "* Feel free to use tools like Binder or Docker to generate a \"container\" for better reproducibility.\n", + "\n", + "### Rule 6: Use version control\n", + "- Google colab allows you to view revision history.\n", + "- You can also opt to use Git and Github for version control.\n", + "- As Jupyter uses JSON for serialization, tracking raw changes on GitHub is difficult. [ReviewNB](https://www.reviewnb.com/) and [nbdime](https://github.com/jupyter/nbdime) can help to generate human-readable diffs.\n", + "\n", + "### Rule 7: Build a pipeline\n", + "* A well-designed notebook can be generalized into a pipeline.\n", + "* Place key variable declarations at the top/beginning of the notebook.\n", + "* Make a habit of regularly restarting your kernel and rerunning all cells.\n", + "* Before submitting, reinstall all dependencies and rerun all cells in a new enviroment to ensure reproducibility.\n", + "\n", + "### Rule 8: Share and explain your data\n", + "* Properly reference the data you use.\n", + "* If using your own data, make your data or a sample of your data publicly available along with the notebook.\n", + "* You can opt to host public copies of your data.\n", + "\n", + "### Rule 9: Design your notebooks to be read, run, and explored\n", + "* Read: For code hosted in a public repository, add README and LICENSE files.\n", + "* Run: Consider using Google Colab, Binder, or Docker for seamless replication.\n", + "* Explore: Consider how you can design your notebook so future users can built on top of your work.\n", + "\n", + "### Rule 10: Advocate for open research" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QH81wjfsJsv1" + }, + "source": [ + "\n", + "# Memo\n", + "\n", + "Write a memo for the leadership explaining in layman's terms why this topic is relevant for public policy. Discuss relevant research works, real-world examples of successful applications, and/or organizations and governments that apply such approaches for policy making.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e2u40fYe3EOL" + }, + "source": [ + "\n", + "# Overview\n", + "\n", + "In this section, provide a summary of the main contributions of the tutorial notebook. Note that the tutorial should introduce or demonstrate the use of a method, dataset, tool, or technology to address a problem related to public policy. Be clear on the goal of the tutorial and the expected learning outcomes for the users.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gQgijl46pYzn" + }, + "source": [ + "\n", + "# Background & Prerequisites\n", + "\n", + "You will need to specify the prerequisites and basic knowledge required for the tutorial. Afterwards, please provide a brief explanation of the most important concepts necessary for the users to follow the tutorial." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ag9dvWcxqmEq" + }, + "source": [ + "## Videos\n", + "You may also opt to include short videos explaining relevant concepts.\n", + "\n", + "Example:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "E4aK3MI9qhfJ", + "outputId": "044bd042-37c7-43d2-8a19-78dbc2dd6e46" + }, + "outputs": [ + { + "data": { + "image/jpeg": "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\n", + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import YouTubeVideo\n", + "\n", + "YouTubeVideo(\"aircAruvnKk\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7BpQklEEIFDD" + }, + "source": [ + "## Reading materials\n", + "Please include additional resources (e.g. research papers, blog posts, textbooks) for the readers to further study the topic of your tutorial.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rSRCNgYzUwaf" + }, + "source": [ + "\n", + "# Software Requirements\n", + "Include in this section the software requirements, setup instructions, and library imports.\n", + "\n", + "Example:\n", + "\n", + "This notebook requires Python >= 3.7. The following libraries are required:\n", + "* pandas\n", + "* numpy\n", + "* matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "jObV5LtDk0Vm" + }, + "outputs": [], + "source": [ + "!pip install pandas numpy matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "xVzk4V7qUu2R" + }, + "outputs": [], + "source": [ + "# Data visualization\n", + "\n", + "# Data manipulation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jXoiLncsU3pe" + }, + "source": [ + "\n", + "# Data Description\n", + "\n", + "In this section, kindly provide a brief description of the dataset that you will use in this tutorial. Specify information such as the data type or file format (e.g. text, image, video, tabular), size, spatial resolution, temporal resolution, labels or categories, etc. Explicitly name the source of your dataset. If you are introducing a new dataset, feel free to include additional information (e.g. field survey sampling methods, dataset annotation efforts, etc.) or provide external links and resources that discuss the specific details of the dataset.\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PoF-BxSM5Jkc" + }, + "source": [ + "## Data Download\n", + "Provide instructions on how to retrieve the necessary data.\n", + "\n", + "This may include bash scripts, Python scripts, or other means of downloading the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Qh5FKi6Nopbr" + }, + "outputs": [], + "source": [ + "# Insert data download code here, e.g.\n", + "# !wget .zip -O data.zip" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bSt6h_Q-oqjK" + }, + "source": [ + "## Data Preprocessing\n", + "Additionally, you can include any data preprocessing steps and exploratory data analyses (e.g. visualize data distributions, impute missing values, etc.) in this section to allow the users to better understand the dataset.\n", + "\n", + "In this section, you might also want to describe the different input and output variables, the train/val/test splits, and any data transformations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "0aBJ5aLZosk-" + }, + "outputs": [], + "source": [ + "# Insert data pre-processing and exploratory data analysis\n", + "# code here. Feel free to break this up into several code\n", + "# cells, interleaved with explanatory text." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qa9Iuu2GU52Z" + }, + "source": [ + "\n", + "# Methodology\n", + "\n", + "In this section, describe a step-by-step walkthrough of the methodology, in the form of code cells. Feel free to make use of markdown headings to break this section up into smaller subsections, preferrably one section per task.\n", + "\n", + "Reminders:\n", + "* Split the code into small, digestible chunks.\n", + "* Use text cells to describe each code block.\n", + "* Avoid duplicate code through modularization.\n", + "* Focus on learning outcomes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yWXsiZ5freTG" + }, + "source": [ + "## Subtask Heading 1\n", + "Replace the heading with the appropriate title for each subtask." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "6CeKQHfyrU7k" + }, + "outputs": [], + "source": [ + "# Insert code here. Feel free to break this up into several code\n", + "# cells, interleaved with explanatory text." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "o8L28axZ4NVj" + }, + "source": [ + "## Subtask Heading 2\n", + "Replace the heading with the appropriate title for each subtask." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "_6HotiSW4Pe8" + }, + "outputs": [], + "source": [ + "# Insert code here. Feel free to break this up into several code\n", + "# cells, interleaved with explanatory text." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZhkmytKNU_Z2" + }, + "source": [ + "\n", + "# Results & Discussion\n", + "\n", + "In this section, describe and contextualize the results shown in the tutorial. Briefly describe the performance metrics and cross validation techniques used." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "8LWo6UQzwj37" + }, + "outputs": [], + "source": [ + "# Insert code here. Feel free to break this up into several code\n", + "# cells, interleaved with explanatory text." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oHIjM6eMwlXY" + }, + "source": [ + "Finally, include a discussion on the limitations and important takeaways from the exercise.\n", + "\n", + "## Limitations\n", + "* The tutorial is focused on education and learning. Explain all the simplifications you have made compared to applying a similar approach in the real world (for instance, if you have reduced your training data and performance).\n", + "* ML algorithms and datasets can reinforce or reflect unfair biases. Reflect on the potential biases in the dataset and/or analysis presented in your tutorial, including its potential societal impact, and discuss how readers might go about addressing this challenge." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CLLCQpv14Gsx" + }, + "source": [ + "## Next Steps\n", + "* What do you recommend would be the next steps for your readers after finishing your tutorial?\n", + "* Discuss other potential policy- and government-related applications for the method or tool discussed in the tutorial.\n", + "* List anything else that you would want the reader to take away as they move on from the tutorial." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PkKqewK_-ZLD" + }, + "source": [ + "\n", + "# References\n", + "\n", + "Include all references used.\n", + "\n", + "For example, in this template:\n", + "\n", + "* EarthCube Notebook Template: https://github.com/earthcube/NotebookTemplates\n", + "* Earth Engine Community Tutorials Style Guide: https://developers.google.com/earth-engine/tutorials/community/styleguide#colab\n", + "* Google Cloud Community Tutorial Style Guide: https://cloud.google.com/community/tutorials/styleguide\n", + "* Rule A, Birmingham A, Zuniga C, Altintas I, Huang S-C, Knight R, et al. (2019) Ten simple rules for writing and sharing computational analyses in Jupyter Notebooks. PLoS Comput Biol 15(7): e1007007. https://doi.org/10.1371/journal.pcbi.1007007\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YguJayU8RBmd" + }, + "source": [ + "## Acknowledgement\n", + "\n", + "These guidelines are heavily based on the Climate Change AI template for the for the tutorials track at the [NeurIPS 2021 Workshop on Tackling Climate Change with Machine Learning](https://www.climatechange.ai/events/neurips2021)." + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/notebooks/tutorial_few_shot_learning.ipynb b/notebooks/tutorial_few_shot_learning.ipynb new file mode 100644 index 0000000..f9cb2f7 --- /dev/null +++ b/notebooks/tutorial_few_shot_learning.ipynb @@ -0,0 +1,463 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Few-Shot Learning for Rooftop Detection in Satellite Imagery\n", + "### GRAD-E1394 Deep Learning\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/hertie-data-science-lab/tutorial-new-tutorial-group-1/blob/main/notebooks/tutorial_few_shot_learning.ipynb)\n", + "\n", + "This tutorial demonstrates few-shot learning techniques for semantic segmentation of satellite imagery. We focus on rooftop detection using high-resolution satellite images of Geneva, Switzerland.\n", + "\n", + "### Learning Outcomes\n", + "- Understanding few-shot learning concepts for image segmentation\n", + "- Working with satellite imagery and segmentation masks\n", + "- Implementing and evaluating few-shot learning models for rooftop detection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Table of Contents\n", + "\n", + "* [Memo](#memo)\n", + "* [Overview](#overview)\n", + "* [Background & Prerequisites](#background-and-prereqs)\n", + "* [Software Requirements](#software-requirements)\n", + "* [Data Description](#data-description)\n", + "* [Methodology](#methodology)\n", + "* [Results & Discussion](#results-and-discussion)\n", + "* [References](#references)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Memo\n", + "\n", + "Few-shot learning for satellite image segmentation is crucial for urban planning and disaster response. Traditional deep learning requires thousands of labeled samples, but few-shot learning enables rapid adaptation to new geographic regions with minimal labeled data.\n", + "\n", + "**Policy Applications:**\n", + "- Urban development monitoring\n", + "- Disaster damage assessment\n", + "- Property tax assessment\n", + "- Solar panel installation planning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Overview\n", + "\n", + "This tutorial introduces a few-shot learning approach for semantic segmentation of satellite imagery. We demonstrate how to:\n", + "\n", + "1. Load and preprocess satellite imagery\n", + "2. Build a few-shot segmentation model\n", + "3. Train using episodic learning\n", + "4. Evaluate segmentation performance\n", + "\n", + "By the end, you will understand how to apply few-shot learning to detect rooftops in new satellite images with only a few labeled examples." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Background & Prerequisites\n", + "\n", + "### Prerequisites\n", + "- Basic Python programming\n", + "- Familiarity with PyTorch\n", + "- Understanding of convolutional neural networks\n", + "\n", + "### Key Concepts\n", + "\n", + "**Few-Shot Learning:** Learning from a small number of labeled examples by leveraging prior knowledge.\n", + "\n", + "**Semantic Segmentation:** Classifying each pixel in an image into predefined categories.\n", + "\n", + "**Prototypical Networks:** Learning class representations (prototypes) and classifying based on distance to prototypes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Software Requirements" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Install dependencies (if needed)\n", + "# !pip install torch torchvision numpy matplotlib pillow scikit-learn tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Import standard libraries\n", + "from pathlib import Path\n", + "import os\n", + "import sys\n", + "\n", + "sys.path.append(os.path.abspath(\"..\"))\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Import PyTorch\n", + "import torch\n", + "\n", + "# Import tutorial package functions\n", + "from src.few_shot_utils import (\n", + " FewShotSegmentationModel,\n", + " load_dataset,\n", + " create_dataloader,\n", + " preprocess_image,\n", + ")\n", + "\n", + "# Set random seeds for reproducibility\n", + "torch.manual_seed(42)\n", + "np.random.seed(42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Data Description\n", + "\n", + "The dataset consists of high-resolution satellite imagery of Geneva, Switzerland with corresponding binary segmentation masks for rooftop detection.\n", + "\n", + "**Dataset Properties:**\n", + "- Image Type: RGB satellite imagery\n", + "- Labels: Binary masks (0 = background, 1 = rooftop)\n", + "- Resolution: Variable, resized to 256x256 for training" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Download\n", + "\n", + "Download the dataset from šŸ¤— and store it in cache." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/elena/miniconda3/envs/.venv-dl-ps1/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "Fetching 2111 files: 100%|ā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆ| 2111/2111 [00:00<00:00, 47765.91it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "420 52 53\n", + "(8, 250, 250, 3) (8, 250, 250, 3)\n" + ] + } + ], + "source": [ + "from huggingface_hub import snapshot_download\n", + "\n", + "# 1. Download dataset\n", + "HF_TOKEN = \"XXX\" # Replace with your Hugging Face token if needed\n", + "\n", + "dataset_path = snapshot_download(\n", + " repo_id=\"raphaelattias/overfitteam-geneva-satellite-images\",\n", + " repo_type=\"dataset\",\n", + " token=HF_TOKEN,\n", + ")\n", + "\n", + "\n", + "# 2. Load splits\n", + "train_data = load_dataset(dataset_path, split=\"train\", category=\"all\")\n", + "val_data = load_dataset(dataset_path, split=\"val\", category=\"all\")\n", + "test_data = load_dataset(dataset_path, split=\"test\", category=\"all\")\n", + "\n", + "print(len(train_data[\"images\"]), len(val_data[\"images\"]), len(test_data[\"images\"]))\n", + "\n", + "# 3. Create simple numpy-based \"dataloaders\"\n", + "train_batches = create_dataloader(train_data, batch_size=8, shuffle=True)\n", + "first_batch = train_batches[0]\n", + "print(first_batch[\"images\"].shape, first_batch[\"masks\"].shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show example image and mask\n", + "plt.figure(figsize=(10, 5))\n", + "plt.subplot(1, 2, 1)\n", + "plt.title(\"Example Image\")\n", + "plt.imshow(first_batch[\"images\"][0])\n", + "plt.axis(\"off\")\n", + "plt.subplot(1, 2, 2)\n", + "plt.title(\"Example Mask\")\n", + "plt.imshow(first_batch[\"masks\"][0], cmap=\"gray\")\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Demonstrate preprocessing on sample image\n", + "# TODO" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Methodology\n", + "\n", + "We implement a few-shot segmentation approach using prototypical networks. The model learns to segment rooftops by:\n", + "\n", + "1. Extracting features using a CNN backbone\n", + "2. Computing class prototypes from support examples\n", + "3. Classifying query pixels based on distance to prototypes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model Architecture" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create the few-shot segmentation model\n", + "model = FewShotSegmentationModel(backbone_name=\"resnet18\", num_classes=2, pretrained=True)\n", + "\n", + "print(\"Model architecture:\")\n", + "print(\" Backbone: ResNet-18\")\n", + "print(\" Number of classes: 2 (background, rooftop)\")\n", + "print(f\" Total parameters: {sum(p.numel() for p in model.parameters()):,}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create synthetic data for demonstration\n", + "# In practice, use actual satellite imagery\n", + "synthetic_dataset = {\n", + " \"images\": [np.random.rand(256, 256, 3).astype(np.float32) for _ in range(16)],\n", + " \"masks\": [np.random.randint(0, 2, (256, 256)).astype(np.int64) for _ in range(16)],\n", + "}\n", + "\n", + "# Create data loaders\n", + "train_loader = create_dataloader(synthetic_dataset, batch_size=4, shuffle=True)\n", + "val_loader = create_dataloader(synthetic_dataset, batch_size=4, shuffle=False)\n", + "\n", + "print(f\"Number of training batches: {len(train_loader)}\")\n", + "print(f\"Number of validation batches: {len(val_loader)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Training configuration\n", + "# Note: Using small number of epochs for demonstration\n", + "NUM_EPOCHS = 2\n", + "LEARNING_RATE = 1e-4\n", + "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "print(f\"Training device: {DEVICE}\")\n", + "\n", + "# Train the model\n", + "# history = train_model(\n", + "# model=model,\n", + "# train_dataloader=train_loader,\n", + "# val_dataloader=val_loader,\n", + "# num_epochs=NUM_EPOCHS,\n", + "# learning_rate=LEARNING_RATE,\n", + "# device=DEVICE\n", + "# )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Results & Discussion" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Evaluate model\n", + "# results = evaluate_model(\n", + "# model=model,\n", + "# dataloader=val_loader,\n", + "# device=DEVICE,\n", + "# num_classes=2\n", + "# )\n", + "# print(f\"Mean IoU: {results['mean_iou']:.4f}\")\n", + "# print(f\"Pixel Accuracy: {results['pixel_accuracy']:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Visualize predictions\n", + "def visualize_prediction(image, mask, prediction):\n", + " \"\"\"Visualize image, ground truth, and prediction.\"\"\"\n", + " fig, axes = plt.subplots(1, 3, figsize=(12, 4))\n", + "\n", + " axes[0].imshow(image)\n", + " axes[0].set_title(\"Satellite Image\")\n", + " axes[0].axis(\"off\")\n", + "\n", + " axes[1].imshow(mask, cmap=\"gray\")\n", + " axes[1].set_title(\"Ground Truth\")\n", + " axes[1].axis(\"off\")\n", + "\n", + " axes[2].imshow(prediction, cmap=\"gray\")\n", + " axes[2].set_title(\"Prediction\")\n", + " axes[2].axis(\"off\")\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "# Example visualization with synthetic data\n", + "sample_image = np.random.rand(256, 256, 3)\n", + "sample_mask = np.random.randint(0, 2, (256, 256))\n", + "sample_prediction = np.random.randint(0, 2, (256, 256))\n", + "\n", + "visualize_prediction(sample_image, sample_mask, sample_prediction)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Limitations\n", + "\n", + "- This tutorial uses synthetic data for demonstration purposes\n", + "- Real satellite imagery would require more extensive preprocessing\n", + "- Performance depends on the quality and quantity of support examples\n", + "\n", + "## Next Steps\n", + "\n", + "- Collect and annotate real satellite imagery of Geneva\n", + "- Experiment with different backbone architectures\n", + "- Apply to other geographic regions and segmentation tasks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# References\n", + "\n", + "- ...\n", + "- ...\n", + "- ..." + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": ".venv-dl-ps1", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..90c024c --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,154 @@ +[build-system] +requires = ["setuptools >= 69.1.0"] +build-backend = "setuptools.build_meta" + +[project] +name = "few_shot_utils" +version = "0.0.1" +description = "DL Tutorial 2025: Few-shot learning tutorial on satellite imagery for rooftop detection." +readme = "README.md" +authors = [ + {name = "Tutorial Group 1"}, +] +maintainers = [{name = "Tutorial Group 1"}] +classifiers = [ + "Development Status :: 3 - Alpha", + "Intended Audience :: Developers", + "Intended Audience :: Education", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: 3.11", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + "Topic :: Scientific/Engineering :: Image Processing" +] +requires-python = ">=3.11" +dependencies = [ + 'numpy>=1.24.0', + 'pandas>=2.1.0', + 'matplotlib>=3.8.0', + 'Pillow>=10.0.0', + 'scikit-learn>=1.3.0', + 'tqdm>=4.66.0', +] + +[project.optional-dependencies] +dev = [ + "ruff==0.8.2", + "ipykernel==6.29.3", + "nbformat>=5.9.0", + "pre-commit==3.6.0", +] +torch = [ + "torch>=2.0.0", + "torchvision>=0.15.0", +] + +[project.urls] +Documentation = "https://elenaivadreyer.github.io/tutorial-group-1/" +Source = "https://github.com/hertie-data-science-lab/tutorial-new-tutorial-group-1" +Tracker = "https://github.com/hertie-data-science-lab/tutorial-new-tutorial-group-1/issues" + +#Global ruff configuration +[tool.ruff] + +#global exlusions as defined in original template version +exclude = [ + ".git", + ".hg", + ".mypy_cache", + ".eggs", + ".cache", + ".tox", + "venv", + ".venv", + ".env", + "_build", + "buck-out", + "build", + "__pycache__", + "dist", + "nssm", + "obj", + "out", + "packages", + "pywin32", + "swagger_client" +] + + +# Line length configuration +line-length = 120 + +# Ruff linting configuration +[tool.ruff.lint] +select = [ + "E", # Pycodestyle errors (PEP8 style) + "F", # Pyflakes (code errors and issues) + "W", # Pycodestyle warnings + "I", # Import sorting (isort replacement) + "D", # Pydocstyle (PEP257 docstring conventions) + "ANN", # flake8-annotations (function type annotations) + "UP", # Pyupgrade (modern Python syntax) + "B", # flake8-bugbear (likely bugs) + "S", # Security checks (bandit replacement) + "N", # Naming conventions (PEP8) + "PL", # Pylint rules +] + +ignore = [ + # Docstring requirements - relaxed for flexibility + "D100", "D101", "D102", "D103", "D104", "D105", "D106", "D107", + + # Docstring formatting - avoid conflicts + "D211", # Conflicts with D203 + "D212", # Conflicts with D213 + + # Style preferences + "COM812", # Conflicts with formatter + "D203", # Conflicts with formatter +] + +# Allow underscore-prefixed unused variables +dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$" + +# Per-file exceptions +[tool.ruff.lint.per-file-ignores] +"scripts/*" = ["S"] # Disable security checks in scripts + +# Jupyter notebooks - relaxed rules for exploratory work +"*.ipynb" = [ + "T201", # Allow print statements + "ANN", # No annotation requirements + "E501", # Allow long lines + "F401", # Allow unused imports + "I001", # Relaxed import sorting + "PLC0415", # Allow imports outside top-level + "PLR0913", # Allow many function arguments + "S105", # Allow hardcoded passwords (often placeholder values in tutorials) +] + +# Training/evaluation modules +"src/few_shot_utils/train.py" = ["T201", "PLR0913"] +"src/few_shot_utils/evaluate.py" = ["T201"] +"src/few_shot_utils/models.py" = ["PLC0415"] + +# Import sorting configuration +[tool.ruff.lint.isort] +split-on-trailing-comma = true + +# Pylint-compatible settings +[tool.ruff.lint.pylint] +max-args = 5 +max-branches = 12 +max-locals = 15 +max-returns = 6 +max-statements = 50 + +# Ruff formatter (Black replacement) +[tool.ruff.format] +quote-style = "double" +indent-style = "space" +skip-magic-trailing-comma = false +line-ending = "auto" +docstring-code-format = true +docstring-code-line-length = "dynamic" \ No newline at end of file diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/few_shot_utils/__init__.py b/src/few_shot_utils/__init__.py new file mode 100644 index 0000000..af16e7c --- /dev/null +++ b/src/few_shot_utils/__init__.py @@ -0,0 +1,55 @@ +"""Tutorial Group 1: Few-Shot Learning for Rooftop Detection in Satellite Imagery.""" + +from typing import Any + +# Relative import from the same package +from .data import create_dataloader, load_dataset, preprocess_image + +NAME = "few_shot_utils" + +# What this package exposes at top level +__all__ = [ + "NAME", + "FewShotSegmentationModel", + "create_dataloader", + "evaluate_model", + "get_backbone", + "load_dataset", + "preprocess_image", + "train_episode", + "train_model", + "calculate_iou", + "calculate_dice", + "print_evaluation_results", +] + + +def __getattr__(name: str) -> Any: # noqa: ANN401 + """ + Lazy import for torch-dependent modules. + + This is called when an attribute is accessed on the package that + isn't already defined above. + """ + if name in ("FewShotSegmentationModel", "get_backbone", "create_model"): + from . import models # relative import + + return getattr(models, name) + + if name in ("train_episode", "train_model"): + from . import train # relative import + + return getattr(train, name) + + if name in ( + "calculate_iou", + "calculate_dice", + "evaluate_model", + "print_evaluation_results", + ): + from . import evaluate # relative import + + return getattr(evaluate, name) + + msg = f"module {__name__!r} has no attribute {name!r}" + raise AttributeError(msg) diff --git a/src/few_shot_utils/data.py b/src/few_shot_utils/data.py new file mode 100644 index 0000000..101f1af --- /dev/null +++ b/src/few_shot_utils/data.py @@ -0,0 +1,122 @@ +"""Data loading and preprocessing utilities for satellite imagery.""" + +from pathlib import Path +from typing import Any + +import numpy as np +from PIL import Image + + +def load_dataset( + data_path: str | Path, + split: str = "train", + category: str = "all", +) -> dict[str, Any]: + """ + Load Geneva rooftop satellite imagery dataset. + + Args: + data_path: Path to the root dataset directory (e.g. snapshot_download path). + split: One of 'train', 'val', or 'test'. + category: One of 'all', 'industrial', or 'residencial'. + + Returns: + Dictionary containing: + - "images": list of HxWxC numpy arrays (RGB) + - "masks": list of HxW numpy arrays (label masks) + - "filenames": list of image file names (optional convenience) + + """ + data_path = Path(data_path) + + # Geneva dataset layout: + # //images//*.png + # //labels//*_label.png + image_dir = data_path / split / "images" / category + mask_dir = data_path / split / "labels" / category + + images: list[np.ndarray] = [] + masks: list[np.ndarray] = [] + filenames: list[str] = [] + + if not image_dir.exists(): + raise FileNotFoundError(f"Image directory not found: {image_dir}") + if not mask_dir.exists(): + raise FileNotFoundError(f"Label directory not found: {mask_dir}") + + for img_path in sorted(image_dir.glob("*.png")): + # Build corresponding label filename: add "_label" before .png + label_name = img_path.stem + "_label.png" + mask_path = mask_dir / label_name + + if not mask_path.exists(): + raise FileNotFoundError(f"Mask not found for {img_path.name}: {mask_path}") + + image = Image.open(img_path).convert("RGB") + mask = Image.open(mask_path) + + images.append(np.array(image)) + masks.append(np.array(mask)) + filenames.append(img_path.name) + + return {"images": images, "masks": masks, "filenames": filenames} + + +def preprocess_image( + image: np.ndarray, + target_size: tuple[int, int] = (256, 256), + normalize: bool = True, +) -> np.ndarray: + """ + Preprocess satellite image for model input. + + Args: + image: Input image as numpy array. + target_size: Target size for resizing (height, width). + normalize: Whether to normalize the image values. + + Returns: + Preprocessed image. + + """ + img = Image.fromarray(image) + img = img.resize(target_size[::-1]) # PIL uses (width, height) + result = np.array(img) + + return result + + +def create_dataloader( + dataset: dict[str, Any], + batch_size: int = 4, + shuffle: bool = True, +) -> list[dict[str, np.ndarray]]: + """ + Create data batches from dataset. + + Args: + dataset: Dataset dictionary with images and masks. + batch_size: Number of samples per batch. + shuffle: Whether to shuffle the data. + + Returns: + List of batch dictionaries. + + """ + images = dataset["images"] + masks = dataset["masks"] + + indices = np.arange(len(images)) + if shuffle: + np.random.shuffle(indices) + + batches = [] + for i in range(0, len(indices), batch_size): + batch_indices = indices[i : i + batch_size] + batch = { + "images": np.array([images[j] for j in batch_indices]), + "masks": np.array([masks[j] for j in batch_indices]), + } + batches.append(batch) + + return batches diff --git a/src/few_shot_utils/evaluate.py b/src/few_shot_utils/evaluate.py new file mode 100644 index 0000000..af0d62e --- /dev/null +++ b/src/few_shot_utils/evaluate.py @@ -0,0 +1,3 @@ +"""Evaluation metrics for segmentation models.""" + +# TODO: Implement evaluation metrics such as IoU, Dice coefficient, etc. diff --git a/src/few_shot_utils/models.py b/src/few_shot_utils/models.py new file mode 100644 index 0000000..f0818f0 --- /dev/null +++ b/src/few_shot_utils/models.py @@ -0,0 +1,174 @@ +"""Model architectures for few-shot segmentation.""" + +from typing import Any + +import torch +from torch import nn + + +def get_backbone(name: str = "resnet18", pretrained: bool = True) -> nn.Module: + """ + Get a backbone network for feature extraction. + + Args: + name: Name of the backbone architecture. + pretrained: Whether to use pretrained weights. + + Returns: + Backbone neural network module. + + """ + from torchvision import models + + if name == "resnet18": + backbone = models.resnet18(weights=models.ResNet18_Weights.DEFAULT if pretrained else None) + # Remove the final fully connected layer + backbone = nn.Sequential(*list(backbone.children())[:-2]) + elif name == "resnet34": + backbone = models.resnet34(weights=models.ResNet34_Weights.DEFAULT if pretrained else None) + backbone = nn.Sequential(*list(backbone.children())[:-2]) + else: + msg = f"Unknown backbone: {name}" + raise ValueError(msg) + + return backbone + + +class FewShotSegmentationModel(nn.Module): + """Few-shot segmentation model for rooftop detection.""" + + def __init__( + self, + backbone_name: str = "resnet18", + num_classes: int = 2, + pretrained: bool = True, + ) -> None: + """ + Initialize the few-shot segmentation model. + + Args: + backbone_name: Name of the backbone network. + num_classes: Number of output classes. + pretrained: Whether to use pretrained backbone. + + """ + super().__init__() + self.backbone = get_backbone(backbone_name, pretrained) + self.num_classes = num_classes + + # Feature dimension from backbone (ResNet variants) + feature_dim_map = { + "resnet18": 512, + "resnet34": 512, + } + feature_dim = feature_dim_map.get(backbone_name, 512) + + # Decoder + self.decoder = nn.Sequential( + nn.ConvTranspose2d(feature_dim, 256, kernel_size=2, stride=2), + nn.ReLU(inplace=True), + nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2), + nn.ReLU(inplace=True), + nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2), + nn.ReLU(inplace=True), + nn.ConvTranspose2d(64, 32, kernel_size=2, stride=2), + nn.ReLU(inplace=True), + nn.ConvTranspose2d(32, num_classes, kernel_size=2, stride=2), + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """ + Forward pass. + + Args: + x: Input tensor of shape (B, C, H, W). + + Returns: + Output segmentation tensor of shape (B, num_classes, H, W). + + """ + features = self.backbone(x) + output = self.decoder(features) + return output + + def extract_support_features( + self, + support_images: torch.Tensor, + support_masks: torch.Tensor, + ) -> torch.Tensor: + """ + Extract features from support set for few-shot learning. + + Args: + support_images: Support set images. + support_masks: Support set masks. + + Returns: + Prototype features for each class. + + """ + features = self.backbone(support_images) + # Compute class prototypes by masked average pooling + prototypes = [] + for c in range(self.num_classes): + mask = (support_masks == c).float().unsqueeze(1) + # Resize mask to feature size + mask = nn.functional.interpolate(mask, size=features.shape[-2:], mode="nearest") + masked_features = features * mask + prototype = masked_features.sum(dim=(0, 2, 3)) / (mask.sum() + 1e-8) + prototypes.append(prototype) + return torch.stack(prototypes) + + def predict_with_prototypes( + self, + query_images: torch.Tensor, + prototypes: torch.Tensor, + ) -> torch.Tensor: + """ + Predict segmentation using class prototypes. + + Args: + query_images: Query images to segment. + prototypes: Class prototype features. + + Returns: + Predicted segmentation masks. + + """ + features = self.backbone(query_images) + # Compute distance to prototypes for each spatial location + distances = [] + for prototype in prototypes: + dist = ((features - prototype.view(1, -1, 1, 1)) ** 2).sum(dim=1) + distances.append(dist) + distances = torch.stack(distances, dim=1) + # Return class with minimum distance + predictions = distances.argmin(dim=1) + # Resize to input size + predictions = nn.functional.interpolate( + predictions.unsqueeze(1).float(), + size=query_images.shape[-2:], + mode="nearest", + ).squeeze(1) + return predictions.long() + + +def create_model(config: dict[str, Any] | None = None) -> FewShotSegmentationModel: + """ + Create a few-shot segmentation model from configuration. + + Args: + config: Model configuration dictionary. + + Returns: + Initialized model. + + """ + if config is None: + config = {} + + return FewShotSegmentationModel( + backbone_name=config.get("backbone", "resnet18"), + num_classes=config.get("num_classes", 2), + pretrained=config.get("pretrained", True), + ) diff --git a/src/few_shot_utils/train.py b/src/few_shot_utils/train.py new file mode 100644 index 0000000..1693a83 --- /dev/null +++ b/src/few_shot_utils/train.py @@ -0,0 +1,209 @@ +"""Training functions for few-shot segmentation.""" + +from typing import Any + +import torch +from torch import nn +from tqdm import tqdm + + +def train_episode( + model: nn.Module, + support_images: torch.Tensor, + support_masks: torch.Tensor, + query_images: torch.Tensor, + query_masks: torch.Tensor, + optimizer: torch.optim.Optimizer, + criterion: nn.Module, +) -> dict[str, float]: + """ + Train on a single few-shot episode. + + This function implements episodic training where the model first extracts + prototypes from the support set and then uses them to segment the query set. + + Args: + model: The few-shot segmentation model. + support_images: Support set images for prototype extraction. + support_masks: Support set masks for prototype extraction. + query_images: Query set images to segment. + query_masks: Query set ground truth masks. + optimizer: Optimizer for updating model weights. + criterion: Loss function. + + Returns: + Dictionary containing loss and metrics. + + """ + model.train() + optimizer.zero_grad() + + # Extract prototypes from support set if model supports it + if hasattr(model, "extract_support_features"): + prototypes = model.extract_support_features(support_images, support_masks) + # Use prototypes for query prediction (prototype-based few-shot learning) + # For now, we use standard forward pass for training + _ = prototypes # Prototypes can be used in more advanced implementations + + # Forward pass on query set + outputs = model(query_images) + + # Compute loss + loss = criterion(outputs, query_masks) + + # Backward pass + loss.backward() + optimizer.step() + + # Compute accuracy + predictions = outputs.argmax(dim=1) + accuracy = (predictions == query_masks).float().mean().item() + + return {"loss": loss.item(), "accuracy": accuracy} + + +def train_model( + model: nn.Module, + train_dataloader: list[dict[str, Any]], + val_dataloader: list[dict[str, Any]] | None = None, + num_epochs: int = 10, + learning_rate: float = 1e-4, + device: str = "cuda", +) -> dict[str, list[float]]: + """ + Train the few-shot segmentation model. + + Args: + model: The model to train. + train_dataloader: Training data batches. + val_dataloader: Validation data batches. + num_epochs: Number of training epochs. + learning_rate: Learning rate for optimizer. + device: Device to train on ('cuda' or 'cpu'). + + Returns: + Dictionary containing training history. + + Raises: + ValueError: If train_dataloader is empty. + + """ + if not train_dataloader: + msg = "train_dataloader cannot be empty" + raise ValueError(msg) + + if not torch.cuda.is_available() and device == "cuda": + device = "cpu" + + model = model.to(device) + optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) + criterion = nn.CrossEntropyLoss() + + history = {"train_loss": [], "train_acc": [], "val_loss": [], "val_acc": []} + + for epoch in range(num_epochs): + # Training + model.train() + epoch_loss = 0.0 + epoch_acc = 0.0 + num_batches = 0 + + for batch in tqdm(train_dataloader, desc=f"Epoch {epoch + 1}/{num_epochs}"): + images = torch.from_numpy(batch["images"]).float().permute(0, 3, 1, 2) + masks = torch.from_numpy(batch["masks"]).long() + + images = images.to(device) + masks = masks.to(device) + + optimizer.zero_grad() + outputs = model(images) + + # Resize outputs to match mask size if needed + if outputs.shape[-2:] != masks.shape[-2:]: + outputs = nn.functional.interpolate( + outputs, size=masks.shape[-2:], mode="bilinear", align_corners=False + ) + + loss = criterion(outputs, masks) + loss.backward() + optimizer.step() + + predictions = outputs.argmax(dim=1) + accuracy = (predictions == masks).float().mean().item() + + epoch_loss += loss.item() + epoch_acc += accuracy + num_batches += 1 + + avg_loss = epoch_loss / max(num_batches, 1) + avg_acc = epoch_acc / max(num_batches, 1) + history["train_loss"].append(avg_loss) + history["train_acc"].append(avg_acc) + + # Validation + if val_dataloader is not None: + val_metrics = _validate(model, val_dataloader, criterion, device) + history["val_loss"].append(val_metrics["loss"]) + history["val_acc"].append(val_metrics["accuracy"]) + print( + f"Epoch {epoch + 1}: Train Loss={avg_loss:.4f}, " + f"Train Acc={avg_acc:.4f}, Val Loss={val_metrics['loss']:.4f}, " + f"Val Acc={val_metrics['accuracy']:.4f}" + ) + else: + print(f"Epoch {epoch + 1}: Train Loss={avg_loss:.4f}, Train Acc={avg_acc:.4f}") + + return history + + +def _validate( + model: nn.Module, + dataloader: list[dict[str, Any]], + criterion: nn.Module, + device: str, +) -> dict[str, float]: + """ + Validate the model. + + Args: + model: The model to validate. + dataloader: Validation data batches. + criterion: Loss function. + device: Device to run on. + + Returns: + Dictionary containing validation metrics. + + """ + model.eval() + total_loss = 0.0 + total_acc = 0.0 + num_batches = 0 + + with torch.no_grad(): + for batch in dataloader: + images = torch.from_numpy(batch["images"]).float().permute(0, 3, 1, 2) + masks = torch.from_numpy(batch["masks"]).long() + + images = images.to(device) + masks = masks.to(device) + + outputs = model(images) + + if outputs.shape[-2:] != masks.shape[-2:]: + outputs = nn.functional.interpolate( + outputs, size=masks.shape[-2:], mode="bilinear", align_corners=False + ) + + loss = criterion(outputs, masks) + predictions = outputs.argmax(dim=1) + accuracy = (predictions == masks).float().mean().item() + + total_loss += loss.item() + total_acc += accuracy + num_batches += 1 + + return { + "loss": total_loss / max(num_batches, 1), + "accuracy": total_acc / max(num_batches, 1), + }