From 34969818f9b2d57a2245abc9df022815df8f7bb5 Mon Sep 17 00:00:00 2001
From: Charles Zaloom <38677807+czaloom@users.noreply.github.com>
Date: Mon, 16 Sep 2024 16:25:08 -0400
Subject: [PATCH] Numpy-based Object Detection for Bounding Boxes (#748)

---
 .github/workflows/build-and-publish.yml       |  17 +
 .../workflows/lite-benchmark-evaluations.yml  |  38 +
 .github/workflows/lite-tests-and-coverage.yml |  35 +
 .../client/metrics/test_detection.py          |   2 +-
 lite/LICENSE                                  |  21 +
 lite/README.md                                |   1 +
 lite/benchmarks/.gitignore                    |   2 +
 lite/benchmarks/benchmark_objdet.py           | 330 +++++++
 lite/examples/.gitignore                      |   1 +
 lite/examples/coco-yolo.ipynb                 | 442 +++++++++
 lite/pyproject.toml                           |  38 +
 lite/tests/detection/__init__.py              |   0
 lite/tests/detection/conftest.py              | 504 ++++++++++
 .../tests/detection/test_average_precision.py | 623 +++++++++++++
 lite/tests/detection/test_average_recall.py   | 246 +++++
 lite/tests/detection/test_counts.py           | 457 +++++++++
 lite/tests/detection/test_dataloader.py       |  34 +
 .../tests/detection/test_detailed_pr_curve.py | 882 ++++++++++++++++++
 lite/tests/detection/test_evaluator.py        |  31 +
 lite/tests/detection/test_filtering.py        | 401 ++++++++
 lite/tests/detection/test_iou.py              |  30 +
 lite/tests/detection/test_pr_curve.py         | 177 ++++
 lite/tests/detection/test_precision.py        | 389 ++++++++
 lite/tests/detection/test_recall.py           | 389 ++++++++
 lite/tests/detection/test_schemas.py          | 105 +++
 lite/tests/detection/test_stability.py        |  87 ++
 lite/valor_lite/__init__.py                   |   0
 lite/valor_lite/detection/__init__.py         |  56 ++
 lite/valor_lite/detection/annotation.py       |  54 ++
 lite/valor_lite/detection/computation.py      | 506 ++++++++++
 lite/valor_lite/detection/manager.py          | 845 +++++++++++++++++
 lite/valor_lite/detection/metric.py           | 357 +++++++
 lite/valor_lite/schemas.py                    |  15 +
 33 files changed, 7114 insertions(+), 1 deletion(-)
 create mode 100644 .github/workflows/lite-benchmark-evaluations.yml
 create mode 100644 .github/workflows/lite-tests-and-coverage.yml
 create mode 100644 lite/LICENSE
 create mode 100644 lite/README.md
 create mode 100644 lite/benchmarks/.gitignore
 create mode 100644 lite/benchmarks/benchmark_objdet.py
 create mode 100644 lite/examples/.gitignore
 create mode 100644 lite/examples/coco-yolo.ipynb
 create mode 100644 lite/pyproject.toml
 create mode 100644 lite/tests/detection/__init__.py
 create mode 100644 lite/tests/detection/conftest.py
 create mode 100644 lite/tests/detection/test_average_precision.py
 create mode 100644 lite/tests/detection/test_average_recall.py
 create mode 100644 lite/tests/detection/test_counts.py
 create mode 100644 lite/tests/detection/test_dataloader.py
 create mode 100644 lite/tests/detection/test_detailed_pr_curve.py
 create mode 100644 lite/tests/detection/test_evaluator.py
 create mode 100644 lite/tests/detection/test_filtering.py
 create mode 100644 lite/tests/detection/test_iou.py
 create mode 100644 lite/tests/detection/test_pr_curve.py
 create mode 100644 lite/tests/detection/test_precision.py
 create mode 100644 lite/tests/detection/test_recall.py
 create mode 100644 lite/tests/detection/test_schemas.py
 create mode 100644 lite/tests/detection/test_stability.py
 create mode 100644 lite/valor_lite/__init__.py
 create mode 100644 lite/valor_lite/detection/__init__.py
 create mode 100644 lite/valor_lite/detection/annotation.py
 create mode 100644 lite/valor_lite/detection/computation.py
 create mode 100644 lite/valor_lite/detection/manager.py
 create mode 100644 lite/valor_lite/detection/metric.py
 create mode 100644 lite/valor_lite/schemas.py

diff --git a/.github/workflows/build-and-publish.yml b/.github/workflows/build-and-publish.yml
index 7063fd297..cf8a1b267 100644
--- a/.github/workflows/build-and-publish.yml
+++ b/.github/workflows/build-and-publish.yml
@@ -23,6 +23,23 @@ jobs:
         with:
           password: ${{ secrets.PYPI_API_TOKEN }}
           packages-dir: ./client/dist
+  build-and-publish-py-lite-package:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./lite
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+      - name: Build wheel
+        run: pip install build && python -m build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.VALOR_LITE_PYPI_API_TOKEN }}
+          packages-dir: ./lite/dist
   build-and-publish-ts-package:
     runs-on: ubuntu-latest
     defaults:
diff --git a/.github/workflows/lite-benchmark-evaluations.yml b/.github/workflows/lite-benchmark-evaluations.yml
new file mode 100644
index 000000000..7debf7a05
--- /dev/null
+++ b/.github/workflows/lite-benchmark-evaluations.yml
@@ -0,0 +1,38 @@
+name: Run valor-lite benchmarks
+
+on:
+  push:
+    branches: "**"
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  run-benchmarks:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+      - name: install lite
+        run: pip install -e .
+        working-directory: ./lite
+      # - name: run classification benchmarks
+      #   run: python benchmark_script.py
+      #   working-directory: ./lite/benchmarks/classification
+      # - name: print classification results
+      #   run: |
+      #     export BENCHMARK_RESULTS=$(python -c "import os;import json;print(json.dumps(json.load(open('results.json', 'r')), indent=4));")
+      #     echo "$BENCHMARK_RESULTS"
+      #   working-directory: ./lite/benchmarks/classification
+      - name: run object detection benchmarks
+        run: python benchmark_objdet.py
+        working-directory: ./lite/benchmarks/
+      - name: print object detection results
+        run: |
+          export BENCHMARK_RESULTS=$(python -c "import os;import json;print(json.dumps(json.load(open('manager_results.json', 'r')), indent=4));")
+          echo "$BENCHMARK_RESULTS"
+        working-directory: ./lite/benchmarks/
+      - run: make stop-env
diff --git a/.github/workflows/lite-tests-and-coverage.yml b/.github/workflows/lite-tests-and-coverage.yml
new file mode 100644
index 000000000..e1e238263
--- /dev/null
+++ b/.github/workflows/lite-tests-and-coverage.yml
@@ -0,0 +1,35 @@
+name: Run valor-lite code coverage report
+
+on:
+  push:
+    branches: "**"
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  lite-tests:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: .
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+      - name: run object detection tests and report coverage
+        run: |
+          pip install -e ".[test]"
+          COVERAGE_FILE=.coverage.functional python -m coverage run --omit "tests/*"  -m pytest -v tests/detection/
+          python -m coverage combine
+          python -m coverage report -m
+          python -m coverage json
+          export TOTAL=$(python -c "import json;print(json.load(open('coverage.json'))['totals']['percent_covered_display'])")
+          echo "total=$TOTAL" >> $GITHUB_ENV
+          if (( $TOTAL < 90 )); then
+            echo "Coverage is below 90%"
+            exit 1
+          fi
+        working-directory: ./lite
diff --git a/integration_tests/client/metrics/test_detection.py b/integration_tests/client/metrics/test_detection.py
index 780be8616..8c4bc36bf 100644
--- a/integration_tests/client/metrics/test_detection.py
+++ b/integration_tests/client/metrics/test_detection.py
@@ -2481,7 +2481,7 @@ def test_evaluate_detection_false_negatives_two_images_one_only_with_different_c
 ):
     """In this test we have
         1. An image with a matching groundtruth and prediction (same class, `"value"`, and high IOU)
-        2. A second image with a groundtruth annotation with clas `"other value"` and a prediction with higher confidence
+        2. A second image with a groundtruth annotation with class `"other value"` and a prediction with higher confidence
         then the prediction on the first image.
 
     In this case, the AP for class `"value"` should be 0.5 since the false positive has higher confidence than the true positive.
diff --git a/lite/LICENSE b/lite/LICENSE
new file mode 100644
index 000000000..2965db998
--- /dev/null
+++ b/lite/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Striveworks
+
+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.
diff --git a/lite/README.md b/lite/README.md
new file mode 100644
index 000000000..4bfbcd0a8
--- /dev/null
+++ b/lite/README.md
@@ -0,0 +1 @@
+# valor-lite: Compute classification, object detection, and segmentation metrics locally.
diff --git a/lite/benchmarks/.gitignore b/lite/benchmarks/.gitignore
new file mode 100644
index 000000000..945e26b14
--- /dev/null
+++ b/lite/benchmarks/.gitignore
@@ -0,0 +1,2 @@
+*.json
+*.jsonl
\ No newline at end of file
diff --git a/lite/benchmarks/benchmark_objdet.py b/lite/benchmarks/benchmark_objdet.py
new file mode 100644
index 000000000..43423f355
--- /dev/null
+++ b/lite/benchmarks/benchmark_objdet.py
@@ -0,0 +1,330 @@
+import json
+import os
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from time import time
+
+import requests
+from tqdm import tqdm
+from valor_lite.detection import DataLoader
+
+
+class AnnotationType(str, Enum):
+    NONE = "none"
+    BOX = "box"
+    POLYGON = "polygon"
+    MULTIPOLYGON = "multipolygon"
+    RASTER = "raster"
+
+
+def time_it(fn):
+    def wrapper(*args, **kwargs):
+        start = time()
+        results = fn(*args, **kwargs)
+        return (time() - start, results)
+
+    return wrapper
+
+
+def download_data_if_not_exists(
+    file_name: str,
+    file_path: Path,
+    url: str,
+):
+    """Download the data from a public bucket if it doesn't exist locally."""
+
+    if not os.path.exists(file_path):
+        response = requests.get(url, stream=True)
+        if response.status_code == 200:
+            total_size = int(response.headers.get("content-length", 0))
+            with open(file_path, "wb") as f:
+                with tqdm(
+                    total=total_size,
+                    unit="B",
+                    unit_scale=True,
+                    unit_divisor=1024,
+                    desc=file_name,
+                ) as pbar:
+                    for chunk in response.iter_content(chunk_size=1024):
+                        if chunk:
+                            f.write(chunk)
+                            pbar.update(1024)
+        else:
+            raise RuntimeError(response)
+    else:
+        print(f"{file_name} already exists locally.")
+
+    # sort file by datum uid
+    with open(file_path, "r") as f:
+        lines = [x for x in f]
+    with open(file_path, "w") as f:
+        for line in sorted(
+            lines, key=lambda x: int(json.loads(x)["datum"]["uid"])
+        ):
+            f.write(line)
+
+
+def write_results_to_file(write_path: Path, results: list[dict]):
+    """Write results to manager_results.json"""
+    current_datetime = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
+    if os.path.isfile(write_path):
+        with open(write_path, "r") as file:
+            file.seek(0)
+            data = json.load(file)
+    else:
+        data = {}
+
+    data[current_datetime] = results
+
+    with open(write_path, "w+") as file:
+        json.dump(data, file, indent=4)
+
+
+@time_it
+def ingest(
+    manager: DataLoader,
+    gt_path: Path,
+    pd_path: Path,
+    limit: int,
+    chunk_size: int,
+):
+    accumulated_time = 0.0
+    with open(gt_path, "r") as gf:
+        with open(pd_path, "r") as pf:
+
+            count = 0
+            groundtruths = []
+            predictions = []
+            for gline, pline in zip(gf, pf):
+
+                # groundtruth
+                gt_dict = json.loads(gline)
+                groundtruths.append(gt_dict)
+
+                # prediction
+                pd_dict = json.loads(pline)
+                predictions.append(pd_dict)
+
+                count += 1
+                if count >= limit and limit > 0:
+                    break
+                elif len(groundtruths) < chunk_size or chunk_size == -1:
+                    continue
+
+                timer, _ = time_it(manager.add_data_from_valor_dict)(
+                    zip(groundtruths, predictions), True
+                )
+                accumulated_time += timer
+                groundtruths = []
+                predictions = []
+
+            if groundtruths:
+                timer, _ = time_it(manager.add_data_from_valor_dict)(
+                    zip(groundtruths, predictions), True
+                )
+                accumulated_time += timer
+
+    return accumulated_time
+
+
+@dataclass
+class Benchmark:
+    limit: int
+    n_datums: int
+    n_groundtruths: int
+    n_predictions: int
+    n_labels: int
+    gt_type: AnnotationType
+    pd_type: AnnotationType
+    chunk_size: int
+    ingestion: float
+    preprocessing: float
+    precomputation: float
+    evaluation: float
+    detailed_curves: list[tuple[int, float]]
+
+    def result(self) -> dict:
+        return {
+            "limit": self.limit,
+            "n_datums": self.n_datums,
+            "n_groundtruths": self.n_groundtruths,
+            "n_predictions": self.n_predictions,
+            "n_labels": self.n_labels,
+            "dtype": {
+                "groundtruth": self.gt_type.value,
+                "prediction": self.pd_type.value,
+            },
+            "chunk_size": self.chunk_size,
+            "ingestion": {
+                "loading_from_file": f"{round(self.ingestion - self.preprocessing, 2)} seconds",
+                "numpy_conversion + IoU": f"{round(self.preprocessing, 2)} seconds",
+                "ranking_pairs": f"{round(self.precomputation, 2)} seconds",
+                "total": f"{round(self.ingestion + self.precomputation, 2)} seconds",
+            },
+            "base_evaluation": f"{round(self.evaluation, 2)} seconds",
+            "detailed_pr_curve": [
+                {
+                    "n_points": 10,
+                    "n_examples": curve[0],
+                    "computation": f"{round(curve[1], 2)} seconds",
+                }
+                for curve in self.detailed_curves
+            ],
+        }
+
+
+def run_benchmarking_analysis(
+    limits_to_test: list[int],
+    combinations: list[tuple[AnnotationType, AnnotationType]] | None = None,
+    results_file: str = "manager_results.json",
+    chunk_size: int = -1,
+    compute_pr: bool = True,
+    compute_detailed: bool = True,
+    ingestion_timeout=30,
+    evaluation_timeout=30,
+):
+    """Time various function calls and export the results."""
+    current_directory = Path(__file__).parent
+    write_path = current_directory / Path(results_file)
+
+    gt_box_filename = "gt_objdet_coco_bbox.jsonl"
+    gt_polygon_filename = "gt_objdet_coco_polygon.jsonl"
+    gt_multipolygon_filename = "gt_objdet_coco_raster_multipolygon.jsonl"
+    gt_raster_filename = "gt_objdet_coco_raster_bitmask.jsonl"
+    pd_box_filename = "pd_objdet_yolo_bbox.jsonl"
+    pd_polygon_filename = "pd_objdet_yolo_polygon.jsonl"
+    pd_multipolygon_filename = "pd_objdet_yolo_multipolygon.jsonl"
+    pd_raster_filename = "pd_objdet_yolo_raster.jsonl"
+
+    groundtruth_caches = {
+        AnnotationType.BOX: gt_box_filename,
+        AnnotationType.POLYGON: gt_polygon_filename,
+        AnnotationType.MULTIPOLYGON: gt_multipolygon_filename,
+        AnnotationType.RASTER: gt_raster_filename,
+    }
+    prediction_caches = {
+        AnnotationType.BOX: pd_box_filename,
+        AnnotationType.POLYGON: pd_polygon_filename,
+        AnnotationType.MULTIPOLYGON: pd_multipolygon_filename,
+        AnnotationType.RASTER: pd_raster_filename,
+    }
+
+    # default is to perform all combinations
+    if combinations is None:
+        combinations = [
+            (gt_type, pd_type)
+            for gt_type in groundtruth_caches
+            for pd_type in prediction_caches
+        ]
+
+    # cache data locally
+    filenames = [
+        *list(groundtruth_caches.values()),
+        *list(prediction_caches.values()),
+    ]
+    for filename in filenames:
+        file_path = current_directory / Path(filename)
+        url = f"https://pub-fae71003f78140bdaedf32a7c8d331d2.r2.dev/{filename}"
+        download_data_if_not_exists(
+            file_name=filename, file_path=file_path, url=url
+        )
+
+    # iterate through datum limits
+    results = list()
+    for limit in limits_to_test:
+        for gt_type, pd_type in combinations:
+
+            gt_filename = groundtruth_caches[gt_type]
+            pd_filename = prediction_caches[pd_type]
+
+            # === Base Evaluation ===
+            manager = DataLoader()
+
+            # ingest + preprocess
+            (ingest_time, preprocessing_time,) = ingest(
+                manager=manager,
+                gt_path=current_directory / Path(gt_filename),
+                pd_path=current_directory / Path(pd_filename),
+                limit=limit,
+                chunk_size=chunk_size,
+            )  # type: ignore - time_it wrapper
+
+            finalization_time, evaluator = time_it(manager.finalize)()
+
+            if ingest_time > ingestion_timeout and ingestion_timeout != -1:
+                raise TimeoutError(
+                    f"Base precomputation timed out with limit of {limit}."
+                )
+
+            # test detailed pr curve with no samples
+            detailed_pr_curve_time_no_samples, _ = time_it(
+                evaluator.compute_detailed_pr_curve
+            )()
+
+            # test detailed pr curve with 3 samples
+            detailed_pr_curve_time_three_samples, _ = time_it(
+                evaluator.compute_detailed_pr_curve
+            )(n_samples=3)
+
+            # evaluate
+            eval_time, metrics = time_it(evaluator.evaluate)()
+            # print(metrics)
+            if eval_time > evaluation_timeout and evaluation_timeout != -1:
+                raise TimeoutError(
+                    f"Base evaluation timed out with {evaluator.n_datums} datums."
+                )
+
+            results.append(
+                Benchmark(
+                    limit=limit,
+                    n_datums=evaluator.n_datums,
+                    n_groundtruths=evaluator.n_groundtruths,
+                    n_predictions=evaluator.n_predictions,
+                    n_labels=evaluator.n_labels,
+                    gt_type=gt_type,
+                    pd_type=pd_type,
+                    chunk_size=chunk_size,
+                    ingestion=ingest_time,
+                    preprocessing=preprocessing_time,
+                    precomputation=finalization_time,
+                    evaluation=eval_time,
+                    detailed_curves=[
+                        (0, detailed_pr_curve_time_no_samples),
+                        (3, detailed_pr_curve_time_three_samples),
+                    ],
+                ).result()
+            )
+
+    write_results_to_file(write_path=write_path, results=results)
+
+
+if __name__ == "__main__":
+
+    # run bounding box benchmark
+    run_benchmarking_analysis(
+        combinations=[
+            (AnnotationType.BOX, AnnotationType.BOX),
+        ],
+        limits_to_test=[5000, 5000],
+        compute_detailed=False,
+    )
+
+    # # run polygon benchmark
+    # run_benchmarking_analysis(
+    #     combinations=[
+    #         (AnnotationType.POLYGON, AnnotationType.POLYGON),
+    #     ],
+    #     limits_to_test=[5000, 5000],
+    #     compute_detailed=False,
+    # )
+
+    # # run raster benchmark
+    # run_benchmarking_analysis(
+    #     combinations=[
+    #         (AnnotationType.RASTER, AnnotationType.RASTER),
+    #     ],
+    #     limits_to_test=[500, 500],
+    #     compute_detailed=False,
+    # )
diff --git a/lite/examples/.gitignore b/lite/examples/.gitignore
new file mode 100644
index 000000000..7bc897f92
--- /dev/null
+++ b/lite/examples/.gitignore
@@ -0,0 +1 @@
+!*.ipynb
\ No newline at end of file
diff --git a/lite/examples/coco-yolo.ipynb b/lite/examples/coco-yolo.ipynb
new file mode 100644
index 000000000..aa681d913
--- /dev/null
+++ b/lite/examples/coco-yolo.ipynb
@@ -0,0 +1,442 @@
+{
+  "cells": [
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "38ec8ecc",
+      "metadata": {},
+      "source": [
+        "# Object Detection Example\n",
+        "\n",
+        "## Introduction\n",
+        "\n",
+        "In this notebook, we'll walk through a detailed example of how you can use Valor to evaluate object detections made on [the COCO Panoptic dataset](https://cocodataset.org/#home). We'll use Ultralytics' `YOLOv8` model to predict what objects exist in various COCO photographs and compare performance between bounding box and image segmentation results.\n",
+        "\n",
+        "For a conceptual introduction to Valor, [check out our project overview](https://striveworks.github.io/valor/). For a higher-level example notebook, [check out our \"Getting Started\" notebook](https://github.com/Striveworks/valor/blob/main/examples/getting_started.ipynb).\n",
+        "\n",
+        "Before using this notebook, please ensure that the Valor service is running on your machine (for start-up instructions, [click here](https://striveworks.github.io/valor/getting_started/)). To connect to a non-local instance of Valor, update `client = Client(\"http://0.0.0.0:8000\")` in the first code block to point to the correct URL."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "ff9b26ec",
+      "metadata": {},
+      "source": [
+        "## Defining Our Datasets\n",
+        "\n",
+        "We start by fetching our dataset and uploading it to Valor."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "id": "a4d0a509-7500-44ba-b951-3566d4a4fac1",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "%matplotlib inline\n",
+        "\n",
+        "import os\n",
+        "import json\n",
+        "import builtins\n",
+        "import requests\n",
+        "\n",
+        "from tqdm import tqdm\n",
+        "from pathlib import Path\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "from valor_lite.detection import DataLoader, MetricType"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "a28f5e66",
+      "metadata": {},
+      "source": [
+        "The modules included in `./integrations` are helper modules that demonstrate how to ingest datasets and model inferences into Valor. The depth of each integration varies depending on the use case. \n",
+        "\n",
+        "The `coco_integration` is designed to download, extract, and upload all in one command as you are starting off with all the the data. \n",
+        "\n",
+        "The `yolo_integration` is much simpler; it is a collection of parser functions that convert YOLO model results into Valor types."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "id": "3ea11c76",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "gt_objdet_coco_bbox.jsonl already exists locally.\n",
+            "pd_objdet_yolo_bbox.jsonl already exists locally.\n"
+          ]
+        }
+      ],
+      "source": [
+        "def download_data_if_not_exists(\n",
+        "    file_name: str,\n",
+        "    file_path: Path,\n",
+        "    url: str,\n",
+        "):\n",
+        "    \"\"\"Download the data from a public bucket if it doesn't exist locally.\"\"\"\n",
+        "\n",
+        "    if not os.path.exists(file_path):\n",
+        "        response = requests.get(url, stream=True)\n",
+        "        if response.status_code == 200:\n",
+        "            total_size = int(response.headers.get(\"content-length\", 0))\n",
+        "            with open(file_path, \"wb\") as f:\n",
+        "                with tqdm(\n",
+        "                    total=total_size,\n",
+        "                    unit=\"B\",\n",
+        "                    unit_scale=True,\n",
+        "                    unit_divisor=1024,\n",
+        "                    desc=file_name,\n",
+        "                ) as pbar:\n",
+        "                    for chunk in response.iter_content(chunk_size=1024):\n",
+        "                        if chunk:\n",
+        "                            f.write(chunk)\n",
+        "                            pbar.update(1024)\n",
+        "        else:\n",
+        "            raise RuntimeError(response)\n",
+        "    else:\n",
+        "        print(f\"{file_name} already exists locally.\")\n",
+        "\n",
+        "    # sort file by datum uid\n",
+        "    with open(file_path, \"r\") as f:\n",
+        "        lines = [x for x in f]\n",
+        "    with open(file_path, \"w\") as f:\n",
+        "        for line in sorted(\n",
+        "            lines, key=lambda x: int(json.loads(x)[\"datum\"][\"uid\"])\n",
+        "        ):\n",
+        "            f.write(line)\n",
+        "\n",
+        "groundtruth_file = \"gt_objdet_coco_bbox.jsonl\"\n",
+        "prediction_file = \"pd_objdet_yolo_bbox.jsonl\"\n",
+        "\n",
+        "# cache data locally\n",
+        "current_directory = Path(os.getcwd())\n",
+        "for filename in [groundtruth_file, prediction_file]:\n",
+        "    file_path = current_directory / Path(filename)\n",
+        "    url = f\"https://pub-fae71003f78140bdaedf32a7c8d331d2.r2.dev/{filename}\"\n",
+        "    download_data_if_not_exists(\n",
+        "        file_name=filename, file_path=file_path, url=url\n",
+        "    )\n",
+        "\n",
+        "gt_path = current_directory / Path(groundtruth_file)\n",
+        "pd_path = current_directory / Path(prediction_file)\n",
+        "\n",
+        "gf = builtins.open(gt_path, \"r\")\n",
+        "groundtruths = [\n",
+        "    json.loads(gline)\n",
+        "    for gline in gf\n",
+        "]\n",
+        "gf.close()\n",
+        "\n",
+        "pf = builtins.open(pd_path, \"r\")\n",
+        "predictions = [\n",
+        "    json.loads(pline)\n",
+        "    for pline in pf\n",
+        "]\n",
+        "pf.close()"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "db64b6c6",
+      "metadata": {},
+      "source": [
+        "# Creating an Evaluator"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "94798123",
+      "metadata": {},
+      "source": [
+        "This block utilizes `get_instance_groundtruths` from `integrations/coco_integration.py` to download, extract, and upload the COCO Panoptic validation dataset to Valor."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "id": "89ddd815",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "5000it [00:00, 5679.12it/s]\n"
+          ]
+        }
+      ],
+      "source": [
+        "loader = DataLoader()\n",
+        "loader.add_data_from_valor_dict(zip(groundtruths, predictions), show_progress=True)\n",
+        "evaluator = loader.finalize()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "id": "b2c78827",
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "{'n_datums': 5000,\n",
+              " 'n_groundtruths': 36536,\n",
+              " 'n_predictions': 27092,\n",
+              " 'n_labels': 94,\n",
+              " 'ignored_prediction_labels': [],\n",
+              " 'missing_prediction_labels': [('supercategory', 'person'),\n",
+              "  ('supercategory', 'accessory'),\n",
+              "  ('iscrowd', '0'),\n",
+              "  ('supercategory', 'furniture'),\n",
+              "  ('supercategory', 'electronic'),\n",
+              "  ('supercategory', 'kitchen'),\n",
+              "  ('supercategory', 'appliance'),\n",
+              "  ('supercategory', 'food'),\n",
+              "  ('supercategory', 'indoor'),\n",
+              "  ('supercategory', 'animal'),\n",
+              "  ('iscrowd', '1'),\n",
+              "  ('supercategory', 'vehicle'),\n",
+              "  ('supercategory', 'outdoor'),\n",
+              "  ('supercategory', 'sports'),\n",
+              "  ('name', 'hair drier')]}"
+            ]
+          },
+          "execution_count": 4,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "evaluator.metadata"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "3e8e7aab",
+      "metadata": {},
+      "source": [
+        "## Evaluating Performance\n",
+        "\n",
+        "With our `Dataset` and `Model` defined, we're ready to evaluate our performance and display the results. Note that we use the `wait_for_completion` method since all evaluations run as background tasks; this method ensures that the evaluation finishes before we display the results.\n",
+        "\n",
+        "Sometimes, we may only want to calculate metrics for a subset of our data (i.e., we may only want to see how well our model performed at a specific type of detection). To accomplish this task, we can use the `filters` parameter of `evaluation_detection` to specify what types of data to evaluate performance for.\n",
+        "\n",
+        "We will be running and comparing two different evaluations investigating the performance difference of YOLOv8's bounding box and raster outputs."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "id": "50f5d932",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "metrics = evaluator.evaluate(\n",
+        "    iou_thresholds=[0.25],\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "id": "81dce63d",
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "[AP(value=0.0, iou=0.25, label=('supercategory', 'person')),\n",
+              " AP(value=0.034964121945004485, iou=0.25, label=('name', 'person')),\n",
+              " AP(value=0.0, iou=0.25, label=('iscrowd', '0')),\n",
+              " AP(value=0.0, iou=0.25, label=('supercategory', 'furniture')),\n",
+              " AP(value=0.0055361585101038925, iou=0.25, label=('name', 'chair')),\n",
+              " AP(value=0.012869301715994604, iou=0.25, label=('name', 'potted plant')),\n",
+              " AP(value=0.10866229353693777, iou=0.25, label=('name', 'dining table')),\n",
+              " AP(value=0.0, iou=0.25, label=('supercategory', 'electronic')),\n",
+              " AP(value=0.02314849593109984, iou=0.25, label=('name', 'tv')),\n",
+              " AP(value=0.0, iou=0.25, label=('supercategory', 'appliance')),\n",
+              " AP(value=0.0873892652423137, iou=0.25, label=('name', 'microwave')),\n",
+              " AP(value=0.07156154587928347, iou=0.25, label=('name', 'refrigerator')),\n",
+              " AP(value=0.0, iou=0.25, label=('supercategory', 'indoor')),\n",
+              " AP(value=0.0, iou=0.25, label=('name', 'book')),\n",
+              " AP(value=0.01678316083256647, iou=0.25, label=('name', 'clock')),\n",
+              " AP(value=0.014015775501818683, iou=0.25, label=('name', 'vase')),\n",
+              " AP(value=0.0, iou=0.25, label=('supercategory', 'animal')),\n",
+              " AP(value=0.231753782860388, iou=0.25, label=('name', 'bear')),\n",
+              " AP(value=0.19525677806009462, iou=0.25, label=('name', 'bed')),\n",
+              " AP(value=0.0, iou=0.25, label=('iscrowd', '1')),\n",
+              " AP(value=0.0006028705915087995, iou=0.25, label=('name', 'bottle')),\n",
+              " AP(value=0.0, iou=0.25, label=('supercategory', 'vehicle')),\n",
+              " AP(value=0.0024033740498041, iou=0.25, label=('name', 'car')),\n",
+              " AP(value=0.059802019119639865, iou=0.25, label=('name', 'truck')),\n",
+              " AP(value=0.0, iou=0.25, label=('supercategory', 'outdoor')),\n",
+              " AP(value=0.12696681676449215, iou=0.25, label=('name', 'stop sign')),\n",
+              " AP(value=0.12695275463693767, iou=0.25, label=('name', 'teddy bear')),\n",
+              " AP(value=0.0, iou=0.25, label=('supercategory', 'sports')),\n",
+              " AP(value=0.0007519739315703722, iou=0.25, label=('name', 'skis')),\n",
+              " AP(value=0.027301028578575685, iou=0.25, label=('name', 'oven')),\n",
+              " AP(value=0.0007072135785007071, iou=0.25, label=('name', 'sports ball')),\n",
+              " AP(value=0.014991066775850518, iou=0.25, label=('name', 'baseball glove')),\n",
+              " AP(value=0.010214586772126536, iou=0.25, label=('name', 'tennis racket')),\n",
+              " AP(value=0.0, iou=0.25, label=('supercategory', 'accessory')),\n",
+              " AP(value=0.0020844189682126106, iou=0.25, label=('name', 'backpack')),\n",
+              " AP(value=0.0012280297797221582, iou=0.25, label=('name', 'handbag')),\n",
+              " AP(value=0.013443055499235678, iou=0.25, label=('name', 'boat')),\n",
+              " AP(value=0.02472893969494828, iou=0.25, label=('name', 'bird')),\n",
+              " AP(value=0.009243715069181337, iou=0.25, label=('name', 'cell phone')),\n",
+              " AP(value=0.21514217763688503, iou=0.25, label=('name', 'train')),\n",
+              " AP(value=0.0, iou=0.25, label=('supercategory', 'kitchen')),\n",
+              " AP(value=0.030281021162493073, iou=0.25, label=('name', 'bowl')),\n",
+              " AP(value=0.0, iou=0.25, label=('supercategory', 'food')),\n",
+              " AP(value=0.08771008312142972, iou=0.25, label=('name', 'sandwich')),\n",
+              " AP(value=0.008624009780546994, iou=0.25, label=('name', 'cup')),\n",
+              " AP(value=0.0016891419565576583, iou=0.25, label=('name', 'surfboard')),\n",
+              " AP(value=0.04972058716145529, iou=0.25, label=('name', 'laptop')),\n",
+              " AP(value=0.003592328379843429, iou=0.25, label=('name', 'mouse')),\n",
+              " AP(value=0.0077222703965693675, iou=0.25, label=('name', 'keyboard')),\n",
+              " AP(value=0.0015763816845228704, iou=0.25, label=('name', 'traffic light')),\n",
+              " AP(value=0.14803132929413712, iou=0.25, label=('name', 'bus')),\n",
+              " AP(value=0.19463347439123024, iou=0.25, label=('name', 'cat')),\n",
+              " AP(value=0.06197253140976744, iou=0.25, label=('name', 'airplane')),\n",
+              " AP(value=0.11098807002863581, iou=0.25, label=('name', 'zebra')),\n",
+              " AP(value=0.0, iou=0.25, label=('name', 'tie')),\n",
+              " AP(value=0.01789546873590162, iou=0.25, label=('name', 'apple')),\n",
+              " AP(value=0.00497941318169436, iou=0.25, label=('name', 'baseball bat')),\n",
+              " AP(value=0.008054041938151662, iou=0.25, label=('name', 'wine glass')),\n",
+              " AP(value=0.0013656538067599864, iou=0.25, label=('name', 'knife')),\n",
+              " AP(value=0.028903897960834195, iou=0.25, label=('name', 'cake')),\n",
+              " AP(value=0.0010068803490518544, iou=0.25, label=('name', 'spoon')),\n",
+              " AP(value=0.004558789212254558, iou=0.25, label=('name', 'snowboard')),\n",
+              " AP(value=0.032493461301708465, iou=0.25, label=('name', 'banana')),\n",
+              " AP(value=0.06007451642097835, iou=0.25, label=('name', 'donut')),\n",
+              " AP(value=0.04444354398000359, iou=0.25, label=('name', 'toilet')),\n",
+              " AP(value=0.004502686909260146, iou=0.25, label=('name', 'sink')),\n",
+              " AP(value=0.03680123352285498, iou=0.25, label=('name', 'broccoli')),\n",
+              " AP(value=0.012761324967124905, iou=0.25, label=('name', 'skateboard')),\n",
+              " AP(value=0.01976429998256282, iou=0.25, label=('name', 'bench')),\n",
+              " AP(value=0.0027046607099734366, iou=0.25, label=('name', 'fork')),\n",
+              " AP(value=0.006694106628751388, iou=0.25, label=('name', 'carrot')),\n",
+              " AP(value=0.029851407442426727, iou=0.25, label=('name', 'couch')),\n",
+              " AP(value=0.0005351886540005352, iou=0.25, label=('name', 'remote')),\n",
+              " AP(value=0.016878142346284875, iou=0.25, label=('name', 'bicycle')),\n",
+              " AP(value=0.06534653465346534, iou=0.25, label=('name', 'scissors')),\n",
+              " AP(value=0.043602866009579126, iou=0.25, label=('name', 'orange')),\n",
+              " AP(value=0.023613502704789624, iou=0.25, label=('name', 'sheep')),\n",
+              " AP(value=0.14258072068496863, iou=0.25, label=('name', 'elephant')),\n",
+              " AP(value=0.009255151266686511, iou=0.25, label=('name', 'frisbee')),\n",
+              " AP(value=0.046454982301241954, iou=0.25, label=('name', 'umbrella')),\n",
+              " AP(value=0.10096759191399589, iou=0.25, label=('name', 'horse')),\n",
+              " AP(value=0.08258136367068454, iou=0.25, label=('name', 'motorcycle')),\n",
+              " AP(value=0.11613747307594723, iou=0.25, label=('name', 'dog')),\n",
+              " AP(value=0.016052361400942596, iou=0.25, label=('name', 'kite')),\n",
+              " AP(value=0.100066969572512, iou=0.25, label=('name', 'pizza')),\n",
+              " AP(value=0.030910998396653174, iou=0.25, label=('name', 'cow')),\n",
+              " AP(value=0.06492906623800135, iou=0.25, label=('name', 'fire hydrant')),\n",
+              " AP(value=0.04156939318188106, iou=0.25, label=('name', 'suitcase')),\n",
+              " AP(value=0.16491634254279497, iou=0.25, label=('name', 'giraffe')),\n",
+              " AP(value=0.0206312990102997, iou=0.25, label=('name', 'hot dog')),\n",
+              " AP(value=0.02254763291455196, iou=0.25, label=('name', 'parking meter')),\n",
+              " AP(value=0.0, iou=0.25, label=('name', 'toothbrush')),\n",
+              " AP(value=0.0, iou=0.25, label=('name', 'toaster')),\n",
+              " AP(value=0.0, iou=0.25, label=('name', 'hair drier'))]"
+            ]
+          },
+          "execution_count": 6,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "metrics[MetricType.AP]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "id": "8a3bc015",
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "[mAP(value=-1.0, iou=0.25, label_key='supercategory'),\n",
+              " mAP(value=0.04520859389645013, iou=0.25, label_key='name'),\n",
+              " mAP(value=-1.0, iou=0.25, label_key='iscrowd')]"
+            ]
+          },
+          "execution_count": 7,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "metrics[MetricType.mAP]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "id": "ec56ab6e",
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 2400x2400 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "plt.rcParams['figure.figsize'] = [24, 24]\n",
+        "plt.figure()\n",
+        "recall = [x / 100 for x in range(0,101)]\n",
+        "for curve in metrics[MetricType.PrecisionRecallCurve]:\n",
+        "    if curve.label[0] != \"name\":\n",
+        "        continue\n",
+        "    plt.plot(recall, curve.precision, label=curve.label[1])\n",
+        "plt.title(\"Precision-Recall Curve\")\n",
+        "plt.legend()\n",
+        "plt.show()"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": ".env-valor",
+      "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.12"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
diff --git a/lite/pyproject.toml b/lite/pyproject.toml
new file mode 100644
index 000000000..20ec83e03
--- /dev/null
+++ b/lite/pyproject.toml
@@ -0,0 +1,38 @@
+[project]
+name = "valor-lite"
+dynamic = ["version"]
+description = "Compute valor metrics directly in your client."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { file = "LICENSE" }
+dependencies = [
+    "Pillow >= 9.1.0",
+    "importlib_metadata; python_version < '3.8'",
+    "tqdm",
+    "requests",
+    "numpy",
+]
+
+[project.urls]
+homepage = "https://www.striveworks.com"
+
+[build-system]
+requires = ["setuptools>=61.0", "setuptools_scm[toml]>=6.2"]
+build-backend = "setuptools.build_meta"
+
+[project.optional-dependencies]
+test = ["pytest", "coverage"]
+
+[tool.black]
+line-length = 79
+
+[tool.isort]
+line_length = 79
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+use_parentheses = true
+ensure_newline_before_comments = true
+
+[tool.setuptools_scm]
+root = ".."
diff --git a/lite/tests/detection/__init__.py b/lite/tests/detection/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/lite/tests/detection/conftest.py b/lite/tests/detection/conftest.py
new file mode 100644
index 000000000..a6a500338
--- /dev/null
+++ b/lite/tests/detection/conftest.py
@@ -0,0 +1,504 @@
+import pytest
+from valor_lite.detection import BoundingBox, Detection
+
+
+@pytest.fixture
+def rect1() -> tuple[float, float, float, float]:
+    """Box with area = 1500."""
+    return (10.0, 60.0, 10.0, 40.0)
+
+
+@pytest.fixture
+def rect2() -> tuple[float, float, float, float]:
+    """Box with area = 1100."""
+    return (15.0, 70.0, 0.0, 20.0)
+
+
+@pytest.fixture
+def rect3() -> tuple[float, float, float, float]:
+    """Box with area = 57,510."""
+    return (87.0, 158.0, 10.0, 820.0)
+
+
+@pytest.fixture
+def rect4() -> tuple[float, float, float, float]:
+    """Box with area = 90."""
+    return (1.0, 10.0, 10.0, 20.0)
+
+
+@pytest.fixture
+def rect5() -> tuple[float, float, float, float]:
+    """Box with partial overlap to rect3."""
+    return (87, 158, 10, 400)
+
+
+@pytest.fixture
+def basic_detections(
+    rect1: tuple[float, float, float, float],
+    rect2: tuple[float, float, float, float],
+    rect3: tuple[float, float, float, float],
+) -> list[Detection]:
+    return [
+        Detection(
+            uid="uid1",
+            groundtruths=[
+                BoundingBox(
+                    xmin=rect1[0],
+                    xmax=rect1[1],
+                    ymin=rect1[2],
+                    ymax=rect1[3],
+                    labels=[("k1", "v1")],
+                ),
+                BoundingBox(
+                    xmin=rect3[0],
+                    xmax=rect3[1],
+                    ymin=rect3[2],
+                    ymax=rect3[3],
+                    labels=[("k2", "v2")],
+                ),
+            ],
+            predictions=[
+                BoundingBox(
+                    xmin=rect1[0],
+                    xmax=rect1[1],
+                    ymin=rect1[2],
+                    ymax=rect1[3],
+                    labels=[("k1", "v1")],
+                    scores=[0.3],
+                ),
+            ],
+        ),
+        Detection(
+            uid="uid2",
+            groundtruths=[
+                BoundingBox(
+                    xmin=rect2[0],
+                    xmax=rect2[1],
+                    ymin=rect2[2],
+                    ymax=rect2[3],
+                    labels=[("k1", "v1")],
+                ),
+            ],
+            predictions=[
+                BoundingBox(
+                    xmin=rect2[0],
+                    xmax=rect2[1],
+                    ymin=rect2[2],
+                    ymax=rect2[3],
+                    labels=[("k2", "v2")],
+                    scores=[0.98],
+                ),
+            ],
+        ),
+    ]
+
+
+@pytest.fixture
+def torchmetrics_detections() -> list[Detection]:
+    """Creates a model called "test_model" with some predicted
+    detections on the dataset "test_dataset". These predictions are taken
+    from a torchmetrics unit test (see test_metrics.py)
+    """
+
+    # predictions for four images taken from
+    # https://github.com/Lightning-AI/metrics/blob/107dbfd5fb158b7ae6d76281df44bd94c836bfce/tests/unittests/detection/test_map.py#L59
+
+    groundtruths = [
+        {"boxes": [[214.1500, 41.2900, 562.4100, 285.0700]], "labels": ["4"]},
+        {
+            "boxes": [
+                [13.00, 22.75, 548.98, 632.42],
+                [1.66, 3.32, 270.26, 275.23],
+            ],
+            "labels": ["2", "2"],
+        },
+        {
+            "boxes": [
+                [61.87, 276.25, 358.29, 379.43],
+                [2.75, 3.66, 162.15, 316.06],
+                [295.55, 93.96, 313.97, 152.79],
+                [326.94, 97.05, 340.49, 122.98],
+                [356.62, 95.47, 372.33, 147.55],
+                [462.08, 105.09, 493.74, 146.99],
+                [277.11, 103.84, 292.44, 150.72],
+            ],
+            "labels": ["4", "1", "0", "0", "0", "0", "0"],
+        },
+        {
+            "boxes": [
+                [72.92, 45.96, 91.23, 80.57],
+                [50.17, 45.34, 71.28, 79.83],
+                [81.28, 47.04, 98.66, 78.50],
+                [63.96, 46.17, 84.35, 80.48],
+                [75.29, 23.01, 91.85, 50.85],
+                [56.39, 21.65, 75.66, 45.54],
+                [73.14, 1.10, 98.96, 28.33],
+                [62.34, 55.23, 78.14, 79.57],
+                [44.17, 45.78, 63.99, 78.48],
+                [58.18, 44.80, 66.42, 56.25],
+            ],
+            "labels": [
+                "49",
+                "49",
+                "49",
+                "49",
+                "49",
+                "49",
+                "49",
+                "49",
+                "49",
+                "49",
+            ],
+        },
+    ]
+    predictions = [
+        {
+            "boxes": [[258.15, 41.29, 606.41, 285.07]],
+            "scores": [0.236],
+            "labels": ["4"],
+        },
+        {
+            "boxes": [
+                [61.00, 22.75, 565.00, 632.42],
+                [12.66, 3.32, 281.26, 275.23],
+            ],
+            "scores": [0.318, 0.726],
+            "labels": ["3", "2"],
+        },
+        {
+            "boxes": [
+                [87.87, 276.25, 384.29, 379.43],
+                [0.00, 3.66, 142.15, 316.06],
+                [296.55, 93.96, 314.97, 152.79],
+                [328.94, 97.05, 342.49, 122.98],
+                [356.62, 95.47, 372.33, 147.55],
+                [464.08, 105.09, 495.74, 146.99],
+                [276.11, 103.84, 291.44, 150.72],
+            ],
+            "scores": [0.546, 0.3, 0.407, 0.611, 0.335, 0.805, 0.953],
+            "labels": ["4", "1", "0", "0", "0", "0", "0"],
+        },
+        {
+            "boxes": [
+                [72.92, 45.96, 91.23, 80.57],
+                [45.17, 45.34, 66.28, 79.83],
+                [82.28, 47.04, 99.66, 78.50],
+                [59.96, 46.17, 80.35, 80.48],
+                [75.29, 23.01, 91.85, 50.85],
+                [71.14, 1.10, 96.96, 28.33],
+                [61.34, 55.23, 77.14, 79.57],
+                [41.17, 45.78, 60.99, 78.48],
+                [56.18, 44.80, 64.42, 56.25],
+            ],
+            "scores": [
+                0.532,
+                0.204,
+                0.782,
+                0.202,
+                0.883,
+                0.271,
+                0.561,
+                0.204,
+                0.349,
+            ],
+            "labels": ["49", "49", "49", "49", "49", "49", "49", "49", "49"],
+        },
+    ]
+
+    return [
+        Detection(
+            uid=str(idx),
+            groundtruths=[
+                BoundingBox(
+                    xmin=box[0],
+                    ymin=box[1],
+                    xmax=box[2],
+                    ymax=box[3],
+                    labels=[("class", label_value)],
+                )
+                for box, label_value in zip(gt["boxes"], gt["labels"])
+            ],
+            predictions=[
+                BoundingBox(
+                    xmin=box[0],
+                    ymin=box[1],
+                    xmax=box[2],
+                    ymax=box[3],
+                    labels=[("class", label_value)],
+                    scores=[score],
+                )
+                for box, label_value, score in zip(
+                    pd["boxes"], pd["labels"], pd["scores"]
+                )
+            ],
+        )
+        for idx, (gt, pd) in enumerate(zip(groundtruths, predictions))
+    ]
+
+
+@pytest.fixture
+def false_negatives_single_datum_baseline_detections() -> list[Detection]:
+    return [
+        Detection(
+            uid="uid1",
+            groundtruths=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                )
+            ],
+            predictions=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                    scores=[0.8],
+                ),
+                BoundingBox(
+                    xmin=100,
+                    xmax=110,
+                    ymin=100,
+                    ymax=200,
+                    labels=[("key", "value")],
+                    scores=[0.7],
+                ),
+            ],
+        )
+    ]
+
+
+@pytest.fixture
+def false_negatives_single_datum_detections() -> list[Detection]:
+    return [
+        Detection(
+            uid="uid1",
+            groundtruths=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                )
+            ],
+            predictions=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                    scores=[0.8],
+                ),
+                BoundingBox(
+                    xmin=100,
+                    xmax=110,
+                    ymin=100,
+                    ymax=200,
+                    labels=[("key", "value")],
+                    scores=[0.9],
+                ),
+            ],
+        )
+    ]
+
+
+@pytest.fixture
+def false_negatives_two_datums_one_empty_low_confidence_of_fp_detections() -> list[
+    Detection
+]:
+
+    return [
+        Detection(
+            uid="uid1",
+            groundtruths=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                )
+            ],
+            predictions=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                    scores=[0.8],
+                ),
+            ],
+        ),
+        Detection(
+            uid="uid2",
+            groundtruths=[],
+            predictions=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                    scores=[0.7],
+                ),
+            ],
+        ),
+    ]
+
+
+@pytest.fixture
+def false_negatives_two_datums_one_empty_high_confidence_of_fp_detections() -> list[
+    Detection
+]:
+
+    return [
+        Detection(
+            uid="uid1",
+            groundtruths=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                )
+            ],
+            predictions=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                    scores=[0.8],
+                ),
+            ],
+        ),
+        Detection(
+            uid="uid2",
+            groundtruths=[],
+            predictions=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                    scores=[0.9],
+                ),
+            ],
+        ),
+    ]
+
+
+@pytest.fixture
+def false_negatives_two_datums_one_only_with_different_class_low_confidence_of_fp_detections() -> list[
+    Detection
+]:
+
+    return [
+        Detection(
+            uid="uid1",
+            groundtruths=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                )
+            ],
+            predictions=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                    scores=[0.8],
+                ),
+            ],
+        ),
+        Detection(
+            uid="uid2",
+            groundtruths=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "other value")],
+                )
+            ],
+            predictions=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                    scores=[0.7],
+                ),
+            ],
+        ),
+    ]
+
+
+@pytest.fixture
+def false_negatives_two_images_one_only_with_different_class_high_confidence_of_fp_detections() -> list[
+    Detection
+]:
+
+    return [
+        Detection(
+            uid="uid1",
+            groundtruths=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                )
+            ],
+            predictions=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                    scores=[0.8],
+                ),
+            ],
+        ),
+        Detection(
+            uid="uid2",
+            groundtruths=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "other value")],
+                )
+            ],
+            predictions=[
+                BoundingBox(
+                    xmin=10,
+                    xmax=20,
+                    ymin=10,
+                    ymax=20,
+                    labels=[("key", "value")],
+                    scores=[0.9],
+                ),
+            ],
+        ),
+    ]
diff --git a/lite/tests/detection/test_average_precision.py b/lite/tests/detection/test_average_precision.py
new file mode 100644
index 000000000..21e01ecaa
--- /dev/null
+++ b/lite/tests/detection/test_average_precision.py
@@ -0,0 +1,623 @@
+import numpy as np
+from valor_lite.detection import (
+    DataLoader,
+    Detection,
+    MetricType,
+    compute_metrics,
+)
+
+
+def test__compute_average_precision():
+
+    sorted_pairs = np.array(
+        [
+            # dt,  gt,  pd,  iou,  gl,  pl, score,
+            [0.0, 0.0, 2.0, 0.25, 0.0, 0.0, 0.95],
+            [0.0, 0.0, 3.0, 0.33333, 0.0, 0.0, 0.9],
+            [0.0, 0.0, 4.0, 0.66667, 0.0, 0.0, 0.65],
+            [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.1],
+            [0.0, 0.0, 1.0, 0.5, 0.0, 0.0, 0.01],
+        ]
+    )
+
+    label_counts = np.array([[1, 5, 0]])
+    iou_thresholds = np.array([0.1, 0.6])
+    score_thresholds = np.array([0.0])
+
+    (results, _, _, _,) = compute_metrics(
+        sorted_pairs,
+        label_counts=label_counts,
+        iou_thresholds=iou_thresholds,
+        score_thresholds=score_thresholds,
+    )
+    (
+        average_precision,
+        mean_average_precision,
+        average_precision_averaged_over_ious,
+        mean_average_precision_averaged_over_ious,
+    ) = results
+
+    expected_ap = np.array(
+        [
+            [1.0],  # iou = 0.1
+            [1 / 3],  # iou = 0.6
+        ]
+    )
+    assert expected_ap.shape == average_precision.shape
+    assert np.isclose(average_precision, expected_ap).all()
+
+    # since only one class, ap == map
+    assert expected_ap.shape == mean_average_precision.shape
+    assert np.isclose(mean_average_precision, expected_ap).all()
+
+    expected_average = np.array([2 / 3])
+
+    assert average_precision_averaged_over_ious.shape == expected_average.shape
+    assert np.isclose(
+        average_precision_averaged_over_ious, expected_average
+    ).all()
+
+    # since only one class, ap == map
+    assert (
+        mean_average_precision_averaged_over_ious.shape
+        == expected_average.shape
+    )
+    assert np.isclose(
+        mean_average_precision_averaged_over_ious, expected_average
+    ).all()
+
+
+def test_ap_metrics(basic_detections: list[Detection]):
+    """
+    Basic object detection test.
+
+    groundtruths
+        datum uid1
+            box 1 - label (k1, v1) - tp
+            box 3 - label (k2, v2) - fn missing prediction
+        datum uid2
+            box 2 - label (k1, v1) - fn misclassification
+
+    predictions
+        datum uid1
+            box 1 - label (k1, v1) - score 0.3 - tp
+        datum uid2
+            box 2 - label (k2, v2) - score 0.98 - fp
+    """
+
+    manager = DataLoader()
+    manager.add_data(basic_detections)
+    evaluator = manager.finalize()
+
+    metrics = evaluator.evaluate(
+        iou_thresholds=[0.1, 0.6],
+    )
+
+    assert evaluator.ignored_prediction_labels == []
+    assert evaluator.missing_prediction_labels == []
+    assert evaluator.n_datums == 2
+    assert evaluator.n_labels == 2
+    assert evaluator.n_groundtruths == 3
+    assert evaluator.n_predictions == 2
+
+    # test AP
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.AP]]
+    expected_metrics = [
+        {
+            "type": "AP",
+            "value": 0.504950495049505,
+            "parameters": {
+                "iou": 0.1,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+        {
+            "type": "AP",
+            "value": 0.504950495049505,
+            "parameters": {
+                "iou": 0.6,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+        {
+            "type": "AP",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.1,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+        {
+            "type": "AP",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.6,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+    # test mAP
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.mAP]]
+    expected_metrics = [
+        {
+            "type": "mAP",
+            "value": 0.504950495049505,
+            "parameters": {
+                "iou": 0.1,
+                "label_key": "k1",
+            },
+        },
+        {
+            "type": "mAP",
+            "value": 0.504950495049505,
+            "parameters": {
+                "iou": 0.6,
+                "label_key": "k1",
+            },
+        },
+        {
+            "type": "mAP",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.1,
+                "label_key": "k2",
+            },
+        },
+        {
+            "type": "mAP",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.6,
+                "label_key": "k2",
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+    # test AP Averaged Over IoUs
+    actual_metrics = [
+        m.to_dict() for m in metrics[MetricType.APAveragedOverIOUs]
+    ]
+    expected_metrics = [
+        {
+            "type": "APAveragedOverIOUs",
+            "value": 0.504950495049505,
+            "parameters": {
+                "ious": [0.1, 0.6],
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+        {
+            "type": "APAveragedOverIOUs",
+            "value": 0.0,
+            "parameters": {
+                "ious": [0.1, 0.6],
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+    # test mAP Averaged Over IoUs
+    actual_metrics = [
+        m.to_dict() for m in metrics[MetricType.mAPAveragedOverIOUs]
+    ]
+    expected_metrics = [
+        {
+            "type": "mAPAveragedOverIOUs",
+            "value": 0.504950495049505,
+            "parameters": {
+                "ious": [0.1, 0.6],
+                "label_key": "k1",
+            },
+        },
+        {
+            "type": "mAPAveragedOverIOUs",
+            "value": 0.0,
+            "parameters": {
+                "ious": [0.1, 0.6],
+                "label_key": "k2",
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+
+def test_ap_using_torch_metrics_example(
+    torchmetrics_detections: list[Detection],
+):
+    """
+    cf with torch metrics/pycocotools results listed here:
+    https://github.com/Lightning-AI/metrics/blob/107dbfd5fb158b7ae6d76281df44bd94c836bfce/tests/unittests/detection/test_map.py#L231
+    """
+    manager = DataLoader()
+    manager.add_data(torchmetrics_detections)
+    evaluator = manager.finalize()
+
+    assert evaluator.ignored_prediction_labels == [("class", "3")]
+    assert evaluator.missing_prediction_labels == []
+    assert evaluator.n_datums == 4
+    assert evaluator.n_labels == 6
+    assert evaluator.n_groundtruths == 20
+    assert evaluator.n_predictions == 19
+
+    metrics = evaluator.evaluate(
+        iou_thresholds=[0.5, 0.75],
+    )
+
+    # test AP
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.AP]]
+    expected_metrics = [
+        {
+            "type": "AP",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.5,
+                "label": {"key": "class", "value": "0"},
+            },
+        },
+        {
+            "type": "AP",
+            "value": 0.7227722772277229,
+            "parameters": {
+                "iou": 0.75,
+                "label": {"key": "class", "value": "0"},
+            },
+        },
+        {
+            "type": "AP",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.5,
+                "label": {"key": "class", "value": "1"},
+            },
+        },
+        {
+            "type": "AP",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.75,
+                "label": {"key": "class", "value": "1"},
+            },
+        },
+        {
+            "type": "AP",
+            "value": 0.504950495049505,
+            "parameters": {
+                "iou": 0.5,
+                "label": {"key": "class", "value": "2"},
+            },
+        },
+        {
+            "type": "AP",
+            "value": 0.504950495049505,
+            "parameters": {
+                "iou": 0.75,
+                "label": {"key": "class", "value": "2"},
+            },
+        },
+        {
+            "type": "AP",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.5,
+                "label": {"key": "class", "value": "4"},
+            },
+        },
+        {
+            "type": "AP",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.75,
+                "label": {"key": "class", "value": "4"},
+            },
+        },
+        {
+            "type": "AP",
+            "value": 0.7909790979097909,
+            "parameters": {
+                "iou": 0.5,
+                "label": {"key": "class", "value": "49"},
+            },
+        },
+        {
+            "type": "AP",
+            "value": 0.5756718528995757,
+            "parameters": {
+                "iou": 0.75,
+                "label": {"key": "class", "value": "49"},
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+    # test mAP
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.mAP]]
+    expected_metrics = [
+        {
+            "type": "mAP",
+            "value": 0.8591859185918592,
+            "parameters": {
+                "iou": 0.5,
+                "label_key": "class",
+            },
+        },
+        {
+            "type": "mAP",
+            "value": 0.7606789250353607,
+            "parameters": {
+                "iou": 0.75,
+                "label_key": "class",
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+
+def test_ap_false_negatives_single_datum_baseline(
+    false_negatives_single_datum_baseline_detections: list[Detection],
+):
+    """This is the baseline for the below test. In this case there are two predictions and
+    one groundtruth, but the highest confident prediction overlaps sufficiently with the groundtruth
+    so there is not a penalty for the false negative so the AP is 1
+    """
+
+    manager = DataLoader()
+    manager.add_data(false_negatives_single_datum_baseline_detections)
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.AP]]
+    expected_metrics = [
+        {
+            "type": "AP",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.5,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        }
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_ap_false_negatives_single_datum(
+    false_negatives_single_datum_detections: list[Detection],
+):
+    """Tests where high confidence false negative was not being penalized. The
+    difference between this test and the above is that here the prediction with higher confidence
+    does not sufficiently overlap the groundtruth and so is penalized and we get an AP of 0.5
+    """
+
+    manager = DataLoader()
+    manager.add_data(false_negatives_single_datum_detections)
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.AP]]
+    expected_metrics = [
+        {
+            "type": "AP",
+            "value": 0.5,
+            "parameters": {
+                "iou": 0.5,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        }
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_ap_false_negatives_two_datums_one_empty_low_confidence_of_fp(
+    false_negatives_two_datums_one_empty_low_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class and high IOU)
+        2. A second image with empty groundtruth annotation but a prediction with lower confidence
+        then the prediction on the first image.
+
+    In this case, the AP should be 1.0 since the false positive has lower confidence than the true positive
+
+    """
+
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_datums_one_empty_low_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.AP]]
+    expected_metrics = [
+        {
+            "type": "AP",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.5,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        }
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_ap_false_negatives_two_datums_one_empty_high_confidence_of_fp(
+    false_negatives_two_datums_one_empty_high_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class and high IOU)
+        2. A second image with empty groundtruth annotation and a prediction with higher confidence
+        then the prediction on the first image.
+
+    In this case, the AP should be 0.5 since the false positive has higher confidence than the true positive
+    """
+
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_datums_one_empty_high_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.AP]]
+    expected_metrics = [
+        {
+            "type": "AP",
+            "value": 0.5,
+            "parameters": {
+                "iou": 0.5,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        }
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_ap_false_negatives_two_datums_one_only_with_different_class_low_confidence_of_fp(
+    false_negatives_two_datums_one_only_with_different_class_low_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class, `"value"`, and high IOU)
+        2. A second image with a groundtruth annotation with class `"other value"` and a prediction with lower confidence
+        then the prediction on the first image.
+
+    In this case, the AP for class `"value"` should be 1 since the false positive has lower confidence than the true positive.
+    AP for class `"other value"` should be 0 since there is no prediction for the `"other value"` groundtruth
+    """
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_datums_one_only_with_different_class_low_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.AP]]
+    expected_metrics = [
+        {
+            "type": "AP",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.5,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+        {
+            "type": "AP",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.5,
+                "label": {
+                    "key": "key",
+                    "value": "other value",
+                },
+            },
+        },
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_ap_false_negatives_two_datums_one_only_with_different_class_high_confidence_of_fp(
+    false_negatives_two_images_one_only_with_different_class_high_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class, `"value"`, and high IOU)
+        2. A second image with a groundtruth annotation with class `"other value"` and a prediction with higher confidence
+        then the prediction on the first image.
+
+    In this case, the AP for class `"value"` should be 0.5 since the false positive has higher confidence than the true positive.
+    AP for class `"other value"` should be 0 since there is no prediction for the `"other value"` groundtruth
+    """
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_images_one_only_with_different_class_high_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.AP]]
+    expected_metrics = [
+        {
+            "type": "AP",
+            "value": 0.5,
+            "parameters": {
+                "iou": 0.5,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+        {
+            "type": "AP",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.5,
+                "label": {
+                    "key": "key",
+                    "value": "other value",
+                },
+            },
+        },
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
diff --git a/lite/tests/detection/test_average_recall.py b/lite/tests/detection/test_average_recall.py
new file mode 100644
index 000000000..c793d726c
--- /dev/null
+++ b/lite/tests/detection/test_average_recall.py
@@ -0,0 +1,246 @@
+import numpy as np
+from valor_lite.detection import (
+    DataLoader,
+    Detection,
+    MetricType,
+    compute_metrics,
+)
+
+
+def test__compute_average_recall():
+
+    sorted_pairs = np.array(
+        [
+            # dt,  gt,  pd,  iou,  gl,  pl, score,
+            [0.0, 0.0, 2.0, 0.25, 0.0, 0.0, 0.95],
+            [0.0, 1.0, 3.0, 0.33333, 0.0, 0.0, 0.9],
+            [0.0, 0.0, 4.0, 0.66667, 0.0, 0.0, 0.65],
+            [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.1],
+            [0.0, 0.0, 1.0, 0.5, 0.0, 0.0, 0.01],
+            [0.0, 2.0, 5.0, 0.5, 1.0, 1.0, 0.95],
+        ]
+    )
+
+    label_counts = np.array([[2, 5, 0], [1, 1, 0]])
+    iou_thresholds = np.array([0.1, 0.6])
+    score_thresholds = np.array([0.5, 0.93, 0.98])
+
+    (_, results, _, _,) = compute_metrics(
+        sorted_pairs,
+        label_counts=label_counts,
+        iou_thresholds=iou_thresholds,
+        score_thresholds=score_thresholds,
+    )
+    (
+        average_recall,
+        mean_average_recall,
+        average_recall_averaged_over_scores,
+        mean_average_recall_averaged_over_scores,
+    ) = results
+
+    expected = np.array(
+        [
+            [0.75, 0.5],
+            [0.25, 0.5],
+            [0.0, 0.0],
+        ]
+    )
+    assert expected.shape == average_recall.shape
+    assert np.isclose(average_recall, expected).all()
+
+    expected = np.array(
+        [
+            [(0.75 + 0.5) / 2.0],
+            [(0.25 + 0.5) / 2.0],
+            [0.0],
+        ]
+    )
+    assert expected.shape == mean_average_recall.shape
+    assert np.isclose(mean_average_recall, expected).all()
+
+    expected = np.array(
+        [1 / 3, 1 / 3],
+    )
+    assert expected.shape == average_recall_averaged_over_scores.shape
+    assert np.isclose(average_recall_averaged_over_scores, expected).all()
+
+    expected = np.array(
+        [1 / 3],
+    )
+    assert expected.shape == mean_average_recall_averaged_over_scores.shape
+    assert np.isclose(mean_average_recall_averaged_over_scores, expected).all()
+
+
+def test_ar_using_torch_metrics_example(
+    torchmetrics_detections: list[Detection],
+):
+    """
+    cf with torch metrics/pycocotools results listed here:
+    https://github.com/Lightning-AI/metrics/blob/107dbfd5fb158b7ae6d76281df44bd94c836bfce/tests/unittests/detection/test_map.py#L231
+    """
+    manager = DataLoader()
+    manager.add_data(torchmetrics_detections)
+    evaluator = manager.finalize()
+
+    assert evaluator.ignored_prediction_labels == [("class", "3")]
+    assert evaluator.missing_prediction_labels == []
+    assert evaluator.n_datums == 4
+    assert evaluator.n_labels == 6
+    assert evaluator.n_groundtruths == 20
+    assert evaluator.n_predictions == 19
+
+    score_thresholds = [0.0]
+    iou_thresholds = [0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95]
+
+    metrics = evaluator.evaluate(
+        iou_thresholds=iou_thresholds,
+        score_thresholds=score_thresholds,
+    )
+
+    # test AR
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.AR]]
+    expected_metrics = [
+        {
+            "type": "AR",
+            "value": 0.45,
+            "parameters": {
+                "ious": iou_thresholds,
+                "score": 0.0,
+                "label": {"key": "class", "value": "2"},
+            },
+        },
+        {
+            "type": "AR",
+            "value": 0.5800000000000001,
+            "parameters": {
+                "ious": iou_thresholds,
+                "score": 0.0,
+                "label": {"key": "class", "value": "49"},
+            },
+        },
+        {
+            "type": "AR",
+            "value": 0.78,
+            "parameters": {
+                "ious": iou_thresholds,
+                "score": 0.0,
+                "label": {"key": "class", "value": "0"},
+            },
+        },
+        {
+            "type": "AR",
+            "value": 0.8,
+            "parameters": {
+                "ious": iou_thresholds,
+                "score": 0.0,
+                "label": {"key": "class", "value": "1"},
+            },
+        },
+        {
+            "type": "AR",
+            "value": 0.65,
+            "parameters": {
+                "ious": iou_thresholds,
+                "score": 0.0,
+                "label": {"key": "class", "value": "4"},
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+    # test mAR
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.mAR]]
+    expected_metrics = [
+        {
+            "type": "mAR",
+            "value": 0.652,
+            "parameters": {
+                "ious": iou_thresholds,
+                "score": 0.0,
+                "label_key": "class",
+            },
+        }
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+    # test ARAveragedOverScores
+    actual_metrics = [
+        m.to_dict() for m in metrics[MetricType.ARAveragedOverScores]
+    ]
+    expected_metrics = [
+        {
+            "type": "ARAveragedOverScores",
+            "value": 0.45,
+            "parameters": {
+                "ious": iou_thresholds,
+                "scores": [0.0],
+                "label": {"key": "class", "value": "2"},
+            },
+        },
+        {
+            "type": "ARAveragedOverScores",
+            "value": 0.5800000000000001,
+            "parameters": {
+                "ious": iou_thresholds,
+                "scores": [0.0],
+                "label": {"key": "class", "value": "49"},
+            },
+        },
+        {
+            "type": "ARAveragedOverScores",
+            "value": 0.78,
+            "parameters": {
+                "ious": iou_thresholds,
+                "scores": [0.0],
+                "label": {"key": "class", "value": "0"},
+            },
+        },
+        {
+            "type": "ARAveragedOverScores",
+            "value": 0.8,
+            "parameters": {
+                "ious": iou_thresholds,
+                "scores": [0.0],
+                "label": {"key": "class", "value": "1"},
+            },
+        },
+        {
+            "type": "ARAveragedOverScores",
+            "value": 0.65,
+            "parameters": {
+                "ious": iou_thresholds,
+                "scores": [0.0],
+                "label": {"key": "class", "value": "4"},
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+    # test mARAveragedOverScores
+    actual_metrics = [
+        m.to_dict() for m in metrics[MetricType.mARAveragedOverScores]
+    ]
+    expected_metrics = [
+        {
+            "type": "mARAveragedOverScores",
+            "value": 0.652,
+            "parameters": {
+                "ious": iou_thresholds,
+                "scores": [0.0],
+                "label_key": "class",
+            },
+        }
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
diff --git a/lite/tests/detection/test_counts.py b/lite/tests/detection/test_counts.py
new file mode 100644
index 000000000..4ff066412
--- /dev/null
+++ b/lite/tests/detection/test_counts.py
@@ -0,0 +1,457 @@
+from valor_lite.detection import DataLoader, Detection, MetricType
+
+
+def test_counts_metrics(basic_detections: list[Detection]):
+    """
+    Basic object detection test.
+
+    groundtruths
+        datum uid1
+            box 1 - label (k1, v1) - tp
+            box 3 - label (k2, v2) - fn missing prediction
+        datum uid2
+            box 2 - label (k1, v1) - fn misclassification
+
+    predictions
+        datum uid1
+            box 1 - label (k1, v1) - score 0.3 - tp
+        datum uid2
+            box 2 - label (k2, v2) - score 0.98 - fp
+    """
+
+    manager = DataLoader()
+    manager.add_data(basic_detections)
+    evaluator = manager.finalize()
+
+    metrics = evaluator.evaluate(
+        iou_thresholds=[0.1, 0.6],
+        score_thresholds=[0.0, 0.5],
+    )
+
+    assert evaluator.ignored_prediction_labels == []
+    assert evaluator.missing_prediction_labels == []
+    assert evaluator.n_datums == 2
+    assert evaluator.n_labels == 2
+    assert evaluator.n_groundtruths == 3
+    assert evaluator.n_predictions == 2
+
+    # test Counts
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Counts]]
+    expected_metrics = [
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 0,
+                "fp": 1,
+                "fn": 1,
+            },
+            "parameters": {
+                "iou": 0.1,
+                "score": 0.0,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 0,
+                "fp": 1,
+                "fn": 1,
+            },
+            "parameters": {
+                "iou": 0.6,
+                "score": 0.0,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 1,
+                "fp": 0,
+                "fn": 1,
+            },
+            "parameters": {
+                "iou": 0.1,
+                "score": 0.0,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 1,
+                "fp": 0,
+                "fn": 1,
+            },
+            "parameters": {
+                "iou": 0.6,
+                "score": 0.0,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 0,
+                "fp": 1,
+                "fn": 1,
+            },
+            "parameters": {
+                "iou": 0.1,
+                "score": 0.5,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 0,
+                "fp": 1,
+                "fn": 1,
+            },
+            "parameters": {
+                "iou": 0.6,
+                "score": 0.5,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 0,
+                "fp": 0,
+                "fn": 2,
+            },
+            "parameters": {
+                "iou": 0.1,
+                "score": 0.5,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 0,
+                "fp": 0,
+                "fn": 2,
+            },
+            "parameters": {
+                "iou": 0.6,
+                "score": 0.5,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+
+def test_counts_false_negatives_single_datum_baseline(
+    false_negatives_single_datum_baseline_detections: list[Detection],
+):
+    """This is the baseline for the below test. In this case there are two predictions and
+    one groundtruth, but the highest confident prediction overlaps sufficiently with the groundtruth
+    so there is not a penalty for the false negative so the AP is 1
+    """
+
+    manager = DataLoader()
+    manager.add_data(false_negatives_single_datum_baseline_detections)
+    evaluator = manager.finalize()
+
+    metrics = evaluator.evaluate(
+        iou_thresholds=[0.5], score_thresholds=[0.0, 0.9]
+    )
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Counts]]
+    expected_metrics = [
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 1,
+                "fp": 1,
+                "fn": 0,
+            },
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 0,
+                "fp": 0,
+                "fn": 1,
+            },
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.9,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+
+def test_counts_false_negatives_single_datum(
+    false_negatives_single_datum_detections: list[Detection],
+):
+    """Tests where high confidence false negative was not being penalized. The
+    difference between this test and the above is that here the prediction with higher confidence
+    does not sufficiently overlap the groundtruth and so is penalized and we get an AP of 0.5
+    """
+
+    manager = DataLoader()
+    manager.add_data(false_negatives_single_datum_detections)
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Counts]]
+    expected_metrics = [
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 1,
+                "fp": 1,
+                "fn": 0,
+            },
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        }
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+
+def test_counts_false_negatives_two_datums_one_empty_low_confidence_of_fp(
+    false_negatives_two_datums_one_empty_low_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class and high IOU)
+        2. A second image with empty groundtruth annotation but a prediction with lower confidence
+        then the prediction on the first image.
+
+    In this case, the AP should be 1.0 since the false positive has lower confidence than the true positive
+
+    """
+
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_datums_one_empty_low_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Counts]]
+    expected_metrics = [
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 1,
+                "fp": 1,
+                "fn": 0,
+            },
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        }
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_counts_false_negatives_two_datums_one_empty_high_confidence_of_fp(
+    false_negatives_two_datums_one_empty_high_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class and high IOU)
+        2. A second image with empty groundtruth annotation and a prediction with higher confidence
+        then the prediction on the first image.
+
+    In this case, the AP should be 0.5 since the false positive has higher confidence than the true positive
+    """
+
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_datums_one_empty_high_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Counts]]
+    expected_metrics = [
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 1,
+                "fp": 1,
+                "fn": 0,
+            },
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        }
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_counts_false_negatives_two_datums_one_only_with_different_class_low_confidence_of_fp(
+    false_negatives_two_datums_one_only_with_different_class_low_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class, `"value"`, and high IOU)
+        2. A second image with a groundtruth annotation with class `"other value"` and a prediction with lower confidence
+        then the prediction on the first image.
+
+    In this case, the AP for class `"value"` should be 1 since the false positive has lower confidence than the true positive.
+    AP for class `"other value"` should be 0 since there is no prediction for the `"other value"` groundtruth
+    """
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_datums_one_only_with_different_class_low_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Counts]]
+    expected_metrics = [
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 1,
+                "fp": 1,
+                "fn": 0,
+            },
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 0,
+                "fp": 0,
+                "fn": 1,
+            },
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "other value",
+                },
+            },
+        },
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_counts_false_negatives_two_datums_one_only_with_different_class_high_confidence_of_fp(
+    false_negatives_two_images_one_only_with_different_class_high_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class, `"value"`, and high IOU)
+        2. A second image with a groundtruth annotation with class `"other value"` and a prediction with higher confidence
+        then the prediction on the first image.
+
+    In this case, the AP for class `"value"` should be 0.5 since the false positive has higher confidence than the true positive.
+    AP for class `"other value"` should be 0 since there is no prediction for the `"other value"` groundtruth
+    """
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_images_one_only_with_different_class_high_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Counts]]
+    expected_metrics = [
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 1,
+                "fp": 1,
+                "fn": 0,
+            },
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+        {
+            "type": "Counts",
+            "value": {
+                "tp": 0,
+                "fp": 0,
+                "fn": 1,
+            },
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "other value",
+                },
+            },
+        },
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
diff --git a/lite/tests/detection/test_dataloader.py b/lite/tests/detection/test_dataloader.py
new file mode 100644
index 000000000..210a0e421
--- /dev/null
+++ b/lite/tests/detection/test_dataloader.py
@@ -0,0 +1,34 @@
+import json
+
+import pytest
+from valor_lite.detection import DataLoader
+
+
+def test_no_data():
+    loader = DataLoader()
+    with pytest.raises(ValueError):
+        loader.finalize()
+
+
+def test_valor_integration():
+
+    gt_json = '{"datum": {"uid": "139", "text": null, "metadata": {"license": 2, "file_name": "000000000139.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000000139.jpg", "date_captured": "2013-11-21 01:34:01", "flickr_url": "http://farm9.staticflickr.com/8035/8024364858_9c41dc1666_z.jpg", "height": 426, "width": 640}}, "annotations": [{"metadata": {}, "labels": [{"key": "supercategory", "value": "person", "score": null}, {"key": "name", "value": "person", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[158.0, 413.0], [295.0, 413.0], [295.0, 465.0], [158.0, 465.0], [158.0, 413.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "person", "score": null}, {"key": "name", "value": "person", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[172.0, 384.0], [207.0, 384.0], [207.0, 399.0], [172.0, 399.0], [172.0, 384.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "furniture", "score": null}, {"key": "name", "value": "chair", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[223.0, 413.0], [303.0, 413.0], [303.0, 442.0], [223.0, 442.0], [223.0, 413.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "furniture", "score": null}, {"key": "name", "value": "chair", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[218.0, 291.0], [315.0, 291.0], [315.0, 352.0], [218.0, 352.0], [218.0, 291.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "furniture", "score": null}, {"key": "name", "value": "chair", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[219.0, 412.0], [231.0, 412.0], [231.0, 421.0], [219.0, 421.0], [219.0, 412.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "furniture", "score": null}, {"key": "name", "value": "chair", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[219.0, 317.0], [230.0, 317.0], [230.0, 338.0], [219.0, 338.0], [219.0, 317.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "furniture", "score": null}, {"key": "name", "value": "chair", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[218.0, 359.0], [320.0, 359.0], [320.0, 414.0], [218.0, 414.0], [218.0, 359.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "furniture", "score": null}, {"key": "name", "value": "potted plant", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[149.0, 237.0], [210.0, 237.0], [210.0, 260.0], [149.0, 260.0], [149.0, 237.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "furniture", "score": null}, {"key": "name", "value": "dining table", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[231.0, 321.0], [319.0, 321.0], [319.0, 446.0], [231.0, 446.0], [231.0, 321.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "electronic", "score": null}, {"key": "name", "value": "tv", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[168.0, 7.0], [262.0, 7.0], [262.0, 155.0], [168.0, 155.0], [168.0, 7.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "electronic", "score": null}, {"key": "name", "value": "tv", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[209.0, 557.0], [287.0, 557.0], [287.0, 638.0], [209.0, 638.0], [209.0, 557.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "appliance", "score": null}, {"key": "name", "value": "microwave", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[206.0, 512.0], [221.0, 512.0], [221.0, 526.0], [206.0, 526.0], [206.0, 512.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "appliance", "score": null}, {"key": "name", "value": "refrigerator", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[174.0, 493.0], [281.0, 493.0], [281.0, 512.0], [174.0, 512.0], [174.0, 493.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "indoor", "score": null}, {"key": "name", "value": "book", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[308.0, 613.0], [353.0, 613.0], [353.0, 625.0], [308.0, 625.0], [308.0, 613.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "indoor", "score": null}, {"key": "name", "value": "book", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[306.0, 605.0], [350.0, 605.0], [350.0, 618.0], [306.0, 618.0], [306.0, 605.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "indoor", "score": null}, {"key": "name", "value": "clock", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[121.0, 448.0], [142.0, 448.0], [142.0, 461.0], [121.0, 461.0], [121.0, 448.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "indoor", "score": null}, {"key": "name", "value": "vase", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[195.0, 241.0], [212.0, 241.0], [212.0, 254.0], [195.0, 254.0], [195.0, 241.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "indoor", "score": null}, {"key": "name", "value": "vase", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[309.0, 549.0], [398.0, 549.0], [398.0, 584.0], [309.0, 584.0], [309.0, 549.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "indoor", "score": null}, {"key": "name", "value": "vase", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[209.0, 351.0], [230.0, 351.0], [230.0, 361.0], [209.0, 361.0], [209.0, 351.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "supercategory", "value": "indoor", "score": null}, {"key": "name", "value": "vase", "score": null}, {"key": "iscrowd", "value": "0", "score": null}], "bounding_box": [[[200.0, 337.0], [215.0, 337.0], [215.0, 346.0], [200.0, 346.0], [200.0, 337.0]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}]}'
+    pd_json = '{"datum": {"uid": "139", "text": null, "metadata": {"license": 2, "file_name": "000000000139.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000000139.jpg", "date_captured": "2013-11-21 01:34:01", "flickr_url": "http://farm9.staticflickr.com/8035/8024364858_9c41dc1666_z.jpg", "height": 426, "width": 640}}, "annotations": [{"metadata": {}, "labels": [{"key": "name", "value": "tv", "score": 0.9257726073265076}, {"key": "unused_class", "value": "tv", "score": 0.9257726073265076}], "bounding_box": [[[4, 166], [155, 166], [155, 263], [4, 263], [4, 166]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "name", "value": "chair", "score": 0.866135835647583}], "bounding_box": [[[293, 217], [354, 217], [354, 319], [293, 319], [293, 217]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "name", "value": "chair", "score": 0.7706670761108398}], "bounding_box": [[[361, 217], [418, 217], [418, 310], [361, 310], [361, 217]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "name", "value": "person", "score": 0.7308055758476257}], "bounding_box": [[[416, 157], [465, 157], [465, 295], [416, 295], [416, 157]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "name", "value": "chair", "score": 0.6489511728286743}], "bounding_box": [[[405, 219], [444, 219], [444, 306], [405, 306], [405, 219]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "name", "value": "clock", "score": 0.6184478998184204}], "bounding_box": [[[448, 119], [461, 119], [461, 141], [448, 141], [448, 119]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "name", "value": "refrigerator", "score": 0.6119757294654846}], "bounding_box": [[[446, 167], [513, 167], [513, 289], [446, 289], [446, 167]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "name", "value": "potted plant", "score": 0.5597260594367981}], "bounding_box": [[[226, 178], [268, 178], [268, 212], [226, 212], [226, 178]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "name", "value": "vase", "score": 0.431998074054718}], "bounding_box": [[[550, 304], [585, 304], [585, 399], [550, 399], [550, 304]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "name", "value": "potted plant", "score": 0.3539217412471771}], "bounding_box": [[[334, 175], [370, 175], [370, 221], [334, 221], [334, 175]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "name", "value": "dining table", "score": 0.27812352776527405}], "bounding_box": [[[462, 350], [639, 350], [639, 423], [462, 423], [462, 350]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}, {"metadata": {}, "labels": [{"key": "name", "value": "tv", "score": 0.25976383686065674}], "bounding_box": [[[558, 207], [639, 207], [639, 296], [558, 296], [558, 207]]], "polygon": null, "raster": null, "embedding": null, "text": null, "context_list": null, "is_instance": true, "implied_task_types": null}]}'
+
+    gt = json.loads(gt_json)
+    pd = json.loads(pd_json)
+
+    loader = DataLoader()
+    loader.add_data_from_valor_dict([(gt, pd)])
+
+    assert len(loader.pairs) == 1
+    assert loader.pairs[0].shape == (281, 7)
+
+    assert set(loader._evaluator.label_key_to_index.keys()) == {
+        "iscrowd",
+        "name",
+        "supercategory",
+        "unused_class",
+    }
+    assert len(loader._evaluator.index_to_label) == 17
+    assert loader._evaluator.n_datums == 1
diff --git a/lite/tests/detection/test_detailed_pr_curve.py b/lite/tests/detection/test_detailed_pr_curve.py
new file mode 100644
index 000000000..19e8cd73a
--- /dev/null
+++ b/lite/tests/detection/test_detailed_pr_curve.py
@@ -0,0 +1,882 @@
+import numpy as np
+from valor_lite.detection import (
+    DataLoader,
+    Detection,
+    Evaluator,
+    compute_detailed_pr_curve,
+)
+
+
+def test_detailed_pr_curve_no_data():
+    evaluator = Evaluator()
+    curves = evaluator.compute_detailed_pr_curve()
+    assert isinstance(curves, list)
+    assert len(curves) == 0
+
+
+def test_compute_detailed_pr_curve():
+    sorted_pairs = np.array(
+        [
+            # dt,  gt,  pd,  iou,  gl,  pl, score,
+            [0.0, 0.0, 1.0, 0.98, 0.0, 0.0, 0.95],
+            [1.0, 1.0, 2.0, 0.55, 1.0, 0.0, 0.95],
+            [2.0, -1.0, 3.0, 0.67, -1.0, 0.0, 0.65],
+            [3.0, 4.0, 4.0, 1.0, 0.0, 0.0, 0.1],
+            [4.0, 5.0, -1.0, 0.5, 0.0, -1.0, -1.0],
+        ]
+    )
+    label_counts = np.array([[3, 4], [1, 0]])
+    iou_thresholds = np.array([0.5])
+    score_thresholds = np.array([score / 100.0 for score in range(1, 101)])
+
+    results = compute_detailed_pr_curve(
+        data=sorted_pairs,
+        label_counts=label_counts,
+        iou_thresholds=iou_thresholds,
+        score_thresholds=score_thresholds,
+        n_samples=0,
+    )
+
+    assert len(results) == 1
+    assert results.shape == (1, 100, 2, 5)  # iou, score, label, metrics
+
+    """
+    @ iou=0.5, score<0.1
+    2x tp
+    1x fp misclassification
+    1x fp hallucination
+    0x fn misclassification
+    1x fn missing prediction
+    """
+    assert np.isclose(results[0, :10, 0, :], np.array([2, 1, 1, 0, 1])).all()
+
+    """
+    @ iou=0.5, score=0.5
+    1x tp
+    1x fp misclassification
+    1x fp hallucination
+    1x fn misclassification
+    1x fn missing prediction
+    """
+    assert np.isclose(results[0, 10:95, 0, :], np.array([1, 1, 1, 1, 1])).all()
+
+    """
+    @ iou=0.5, score>=0.95
+    0x tp
+    0x fp misclassification
+    2x fp hallucination
+    2x fn misclassification
+    1x fn missing prediction
+    """
+    assert np.isclose(results[0, 95:, 0, :], np.array([0, 0, 2, 2, 1])).all()
+
+    # compute with examples
+
+    """
+
+    output
+
+    label_idx
+    tp
+    ... examples
+    fp_misclassification
+    ... examples
+    fp_hallucination
+    ... examples
+    fn_misclassification
+    ... examples
+    fn_missing_prediction
+    ... examples
+    """
+
+    n_samples = 2
+
+    results = compute_detailed_pr_curve(
+        data=sorted_pairs,
+        label_counts=label_counts,
+        iou_thresholds=iou_thresholds,
+        score_thresholds=score_thresholds,
+        n_samples=n_samples,
+    )
+
+    assert len(results) == 1
+    assert results.shape == (1, 100, 2, 15)  # iou, score, label, metrics
+
+    tp_idx = 0
+    fp_misclf_idx = tp_idx + n_samples + 1
+    fp_halluc_idx = fp_misclf_idx + n_samples + 1
+    fn_misclf_idx = fp_halluc_idx + n_samples + 1
+    fn_misprd_idx = fn_misclf_idx + n_samples + 1
+
+    metric_indices = np.zeros((15,), dtype=bool)
+    for index in [
+        tp_idx,
+        fp_misclf_idx,
+        fp_halluc_idx,
+        fn_misclf_idx,
+        fn_misprd_idx,
+    ]:
+        metric_indices[index] = True
+
+    """
+    @ iou=0.5, score<0.1
+    2x tp
+    1x fp misclassification
+    1x fp hallucination
+    0x fn misclassification
+    1x fn missing prediction
+    """
+    assert np.isclose(
+        results[0, :10, 0, metric_indices],
+        np.array([2, 1, 1, 0, 1])[:, np.newaxis],
+    ).all()  # metrics
+    assert np.isclose(
+        results[0, :10, 0, tp_idx + 1 : fp_misclf_idx], np.array([0.0, 3.0])
+    ).all()  # tp
+    assert np.isclose(
+        results[0, :10, 0, fp_misclf_idx + 1 : fp_halluc_idx],
+        np.array([1.0, -1.0]),
+    ).all()  # fp misclf
+    assert np.isclose(
+        results[0, :10, 0, fp_halluc_idx + 1 : fn_misclf_idx],
+        np.array([2.0, -1.0]),
+    ).all()  # fp halluc
+    assert np.isclose(
+        results[0, :10, 0, fn_misclf_idx + 1 : fn_misprd_idx],
+        np.array([-1.0, -1.0]),
+    ).all()  # fn misclf
+    assert np.isclose(
+        results[0, :10, 0, fn_misprd_idx + 1 :], np.array([4.0, -1.0])
+    ).all()  # fn misprd
+
+    """
+    @ iou=0.5, score=0.5
+    1x tp
+    1x fp misclassification
+    1x fp hallucination
+    1x fn misclassification
+    1x fn missing prediction
+    """
+    assert np.isclose(
+        results[0, 10:95, 0, metric_indices],
+        np.array([1, 1, 1, 1, 1])[:, np.newaxis],
+    ).all()
+    assert np.isclose(
+        results[0, 10:95, 0, tp_idx + 1 : fp_misclf_idx], np.array([0.0, -1.0])
+    ).all()  # tp
+    assert np.isclose(
+        results[0, 10:95, 0, fp_misclf_idx + 1 : fp_halluc_idx],
+        np.array([1.0, -1.0]),
+    ).all()  # fp misclf
+    assert np.isclose(
+        results[0, 10:95, 0, fp_halluc_idx + 1 : fn_misclf_idx],
+        np.array([2.0, -1.0]),
+    ).all()  # fp halluc
+    assert np.isclose(
+        results[0, 10:95, 0, fn_misclf_idx + 1 : fn_misprd_idx],
+        np.array([3.0, -1.0]),
+    ).all()  # fn misclf
+    assert np.isclose(
+        results[0, 10:95, 0, fn_misprd_idx + 1 :], np.array([4.0, -1.0])
+    ).all()  # fn misprd
+
+    """
+    @ iou=0.5, score>=0.95
+    0x tp
+    0x fp misclassification
+    2x fp hallucination
+    2x fn misclassification
+    1x fn missing prediction
+    """
+    assert np.isclose(
+        results[0, 95:, 0, metric_indices],
+        np.array([0, 0, 2, 2, 1])[:, np.newaxis],
+    ).all()
+    assert np.isclose(
+        results[0, 95:, 0, tp_idx + 1 : fp_misclf_idx], np.array([-1.0, -1.0])
+    ).all()  # tp
+    assert np.isclose(
+        results[0, 95:, 0, fp_misclf_idx + 1 : fp_halluc_idx],
+        np.array([-1.0, -1.0]),
+    ).all()  # fp misclf
+    assert np.isclose(
+        results[0, 95:, 0, fp_halluc_idx + 1 : fn_misclf_idx],
+        np.array([1.0, 2.0]),
+    ).all()  # fp halluc
+    assert np.isclose(
+        results[0, 95:, 0, fn_misclf_idx + 1 : fn_misprd_idx],
+        np.array([0.0, 3.0]),
+    ).all()  # fn misclf
+    assert np.isclose(
+        results[0, 95:, 0, fn_misprd_idx + 1 :], np.array([4.0, -1.0])
+    ).all()  # fn misprd
+
+
+def test_detailed_pr_curve_using_torch_metrics_example(
+    torchmetrics_detections: list[Detection],
+):
+    """
+    cf with torch metrics/pycocotools results listed here:
+    https://github.com/Lightning-AI/metrics/blob/107dbfd5fb158b7ae6d76281df44bd94c836bfce/tests/unittests/detection/test_map.py#L231
+    """
+    manager = DataLoader()
+    manager.add_data(torchmetrics_detections)
+    evaluator = manager.finalize()
+
+    assert evaluator.ignored_prediction_labels == [("class", "3")]
+    assert evaluator.missing_prediction_labels == []
+    assert evaluator.n_datums == 4
+    assert evaluator.n_labels == 6
+    assert evaluator.n_groundtruths == 20
+    assert evaluator.n_predictions == 19
+
+    metrics = evaluator.compute_detailed_pr_curve(
+        iou_thresholds=[0.5, 0.75],
+        score_thresholds=[0.25, 0.75],
+        n_samples=1,
+    )
+
+    # test DetailedPrecisionRecallCurve
+    actual_metrics = [m.to_dict() for m in metrics]
+    expected_metrics = [
+        {
+            "value": [
+                {
+                    "score": 0.25,
+                    "tp": 1.0,
+                    "fp_misclassification": 0.0,
+                    "fp_hallucination": 0.0,
+                    "fn_misclassification": 1.0,
+                    "fn_missing_prediction": 0.0,
+                    "tp_examples": ["2"],
+                    "fp_misclassification_examples": [],
+                    "fp_hallucination_examples": [],
+                    "fn_misclassification_examples": ["0"],
+                    "fn_missing_prediction_examples": [],
+                },
+                {
+                    "score": 0.75,
+                    "tp": 0.0,
+                    "fp_misclassification": 0.0,
+                    "fp_hallucination": 6.0,
+                    "fn_misclassification": 2.0,
+                    "fn_missing_prediction": 4.0,
+                    "tp_examples": [],
+                    "fp_misclassification_examples": [],
+                    "fp_hallucination_examples": ["2"],
+                    "fn_misclassification_examples": ["0"],
+                    "fn_missing_prediction_examples": ["2"],
+                },
+            ],
+            "iou": 0.5,
+            "label": {"key": "class", "value": "4"},
+            "type": "DetailedPrecisionRecallCurve",
+        },
+        {
+            "value": [
+                {
+                    "score": 0.25,
+                    "tp": 1.0,
+                    "fp_misclassification": 0.0,
+                    "fp_hallucination": 0.0,
+                    "fn_misclassification": 1.0,
+                    "fn_missing_prediction": 0.0,
+                    "tp_examples": ["2"],
+                    "fp_misclassification_examples": [],
+                    "fp_hallucination_examples": [],
+                    "fn_misclassification_examples": ["0"],
+                    "fn_missing_prediction_examples": [],
+                },
+                {
+                    "score": 0.75,
+                    "tp": 0.0,
+                    "fp_misclassification": 0.0,
+                    "fp_hallucination": 6.0,
+                    "fn_misclassification": 2.0,
+                    "fn_missing_prediction": 4.0,
+                    "tp_examples": [],
+                    "fp_misclassification_examples": [],
+                    "fp_hallucination_examples": ["2"],
+                    "fn_misclassification_examples": ["0"],
+                    "fn_missing_prediction_examples": ["2"],
+                },
+            ],
+            "iou": 0.75,
+            "label": {"key": "class", "value": "4"},
+            "type": "DetailedPrecisionRecallCurve",
+        },
+        {
+            "value": [
+                {
+                    "score": 0.25,
+                    "tp": 1.0,
+                    "fp_misclassification": 0.0,
+                    "fp_hallucination": 1.0,
+                    "fn_misclassification": 0.0,
+                    "fn_missing_prediction": 1.0,
+                    "tp_examples": ["1"],
+                    "fp_misclassification_examples": [],
+                    "fp_hallucination_examples": ["1"],
+                    "fn_misclassification_examples": [],
+                    "fn_missing_prediction_examples": ["1"],
+                },
+                {
+                    "score": 0.75,
+                    "tp": 0.0,
+                    "fp_misclassification": 0.0,
+                    "fp_hallucination": 1.0,
+                    "fn_misclassification": 1.0,
+                    "fn_missing_prediction": 3.0,
+                    "tp_examples": [],
+                    "fp_misclassification_examples": [],
+                    "fp_hallucination_examples": ["1"],
+                    "fn_misclassification_examples": ["1"],
+                    "fn_missing_prediction_examples": ["1"],
+                },
+            ],
+            "iou": 0.5,
+            "label": {"key": "class", "value": "2"},
+            "type": "DetailedPrecisionRecallCurve",
+        },
+        {
+            "value": [
+                {
+                    "score": 0.25,
+                    "tp": 1.0,
+                    "fp_misclassification": 0.0,
+                    "fp_hallucination": 1.0,
+                    "fn_misclassification": 0.0,
+                    "fn_missing_prediction": 1.0,
+                    "tp_examples": ["1"],
+                    "fp_misclassification_examples": [],
+                    "fp_hallucination_examples": ["1"],
+                    "fn_misclassification_examples": [],
+                    "fn_missing_prediction_examples": ["1"],
+                },
+                {
+                    "score": 0.75,
+                    "tp": 0.0,
+                    "fp_misclassification": 0.0,
+                    "fp_hallucination": 1.0,
+                    "fn_misclassification": 1.0,
+                    "fn_missing_prediction": 3.0,
+                    "tp_examples": [],
+                    "fp_misclassification_examples": [],
+                    "fp_hallucination_examples": ["1"],
+                    "fn_misclassification_examples": ["1"],
+                    "fn_missing_prediction_examples": ["1"],
+                },
+            ],
+            "iou": 0.75,
+            "label": {"key": "class", "value": "2"},
+            "type": "DetailedPrecisionRecallCurve",
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+
+# @pytest.fixture
+# def test_detailed_precision_recall_curve(
+#     evaluate_detection_detailed_pr_curve_groundtruths: list,
+#     evaluate_detection_detailed_pr_curve_predictions: list,
+#     detailed_precision_recall_curve_outputs: tuple,
+# ):
+
+#     expected_outputs, _ = detailed_precision_recall_curve_outputs
+
+#     Dataloader = Dataloader(
+#         metrics_to_return=[enums.MetricType.DetailedDetailedPrecisionRecallCurve],
+#     )
+
+#     Dataloader.add_data(
+#         groundtruths=evaluate_detection_detailed_pr_curve_groundtruths,
+#         predictions=evaluate_detection_detailed_pr_curve_predictions,
+#     )
+
+#     # check that ious have been precomputed
+#     assert "iou_" in Dataloader.joint_df.columns
+#     assert all(
+#         [
+#             col not in ["raster", "bounding_box"]
+#             for col in Dataloader.joint_df.columns
+#         ]
+#     )
+
+#     eval_job = Dataloader.evaluate()
+#     for key, expected_value in expected_outputs.items():
+#         result = eval_job.metrics[0]["value"]
+#         for k in key:
+#             result = result[k]
+#         assert result == expected_value
+
+#     # repeat tests using a lower IOU threshold
+#     Dataloader = Dataloader(
+#         metrics_to_return=[enums.MetricType.DetailedDetailedPrecisionRecallCurve],
+#         pr_curve_iou_threshold=0.45,
+#     )
+
+#     Dataloader.add_data(
+#         groundtruths=evaluate_detection_detailed_pr_curve_groundtruths,
+#         predictions=evaluate_detection_detailed_pr_curve_predictions,
+#     )
+
+#     eval_job_low_iou_threshold = Dataloader.evaluate()
+
+#     for key, expected_value in expected_outputs.items():
+#         result = eval_job_low_iou_threshold.metrics[0]["value"]
+#         for k in key:
+#             result = result[k]
+#         assert result == expected_value
+
+
+# def test_evaluate_detection_model_with_no_predictions(
+#     evaluate_detection_groundtruths: list,
+#     evaluate_detection_model_with_no_predictions_output: list,
+# ):
+#     """
+#     Test detection evaluations when the model outputs nothing.
+
+#     gt_dets1
+#         datum 1
+#             - Label (k1, v1) with Annotation area = 1500
+#             - Label (k2, v2) with Annotation area = 57,510
+#         datum2
+#             - Label (k1, v1) with Annotation area = 1100
+#     """
+#     predictions = []
+#     for gt in evaluate_detection_groundtruths:
+#         predictions.append(
+#             schemas.Prediction(
+#                 datum=gt.datum,
+#                 annotations=[],
+#             )
+#         )
+
+#     Dataloader = Dataloader()
+
+#     # can't pass empty lists, but can pass predictions without annotations
+#     with pytest.raises(ValueError) as e:
+#         Dataloader.add_data(
+#             groundtruths=evaluate_detection_groundtruths,
+#             predictions=[],
+#         )
+#     assert (
+#         "it's neither a dataframe nor a list of Valor Prediction objects"
+#         in str(e)
+#     )
+
+#     Dataloader.add_data(
+#         groundtruths=evaluate_detection_groundtruths,
+#         predictions=predictions,
+#     )
+
+#     # check that ious have been precomputed
+#     assert "iou_" in Dataloader.joint_df.columns
+#     assert all(
+#         [
+#             col not in ["raster", "bounding_box"]
+#             for col in Dataloader.joint_df.columns
+#         ]
+#     )
+
+#     eval_job = Dataloader.evaluate()
+
+#     computed_metrics = eval_job.metrics
+
+#     assert all([metric["value"] == 0 for metric in computed_metrics])
+
+#     for m in evaluate_detection_model_with_no_predictions_output:
+#         assert m in computed_metrics
+
+#     for m in computed_metrics:
+#         assert m in evaluate_detection_model_with_no_predictions_output
+
+
+# def test_evaluate_detection_functional_test(
+#     evaluate_detection_functional_test_groundtruths: list,
+#     evaluate_detection_functional_test_predictions: list,
+#     evaluate_detection_functional_test_outputs: tuple,
+# ):
+
+#     (
+#         expected_metrics,
+#         pr_expected_answers,
+#         detailed_pr_expected_answers,
+#         higher_iou_threshold_pr_expected_answers,
+#         higher_iou_threshold_detailed_pr_expected_answers,
+#     ) = evaluate_detection_functional_test_outputs
+
+#     Dataloader = Dataloader()
+#     Dataloader.add_data(
+#         groundtruths=evaluate_detection_functional_test_groundtruths,
+#         predictions=evaluate_detection_functional_test_predictions,
+#     )
+#     Dataloader.finalize()
+
+#     ap_metrics = translate_ap_metrics(
+#         Dataloader.compute_ap(
+#             iou_thresholds=[0.5, 0.75]
+#         )
+#     )
+
+#     pr_curves = translate_pr_curves(
+#         Dataloader.compute_pr_curve(
+#             iou_thresholds=[0.5],
+#             n_samples=1,
+#         )
+#     )
+
+#         metrics_to_return=[
+#             enums.MetricType.AP,
+#             enums.MetricType.AR,
+#             enums.MetricType.mAP,
+#             enums.MetricType.APAveragedOverIOUs,
+#             enums.MetricType.mAR,
+#             enums.MetricType.mAPAveragedOverIOUs,
+#             enums.MetricType.DetailedPrecisionRecallCurve,
+#             enums.MetricType.DetailedDetailedPrecisionRecallCurve,
+#         ],
+#         pr_curve_iou_threshold=0.5,
+#         pr_curve_max_examples=1,
+#     )
+
+
+#     metrics = [
+#         m
+#         for m in eval_job.metrics
+#         if m["type"]
+#         not in ["DetailedPrecisionRecallCurve", "DetailedDetailedPrecisionRecallCurve"]
+#     ]
+
+#     # round all metrics to the third decimal place
+#     for i, m in enumerate(metrics):
+#         metrics[i]["value"] = round(m["value"], 3)
+
+#     pr_metrics = [
+#         m for m in eval_job.metrics if m["type"] == "DetailedPrecisionRecallCurve"
+#     ]
+#     detailed_pr_metrics = [
+#         m
+#         for m in eval_job.metrics
+#         if m["type"] == "DetailedDetailedPrecisionRecallCurve"
+#     ]
+
+#     for m in metrics:
+#         assert m in expected_metrics
+#     for m in metrics:
+#         assert m in eval_job.metrics
+
+#     for (
+#         _,
+#         value,
+#         threshold,
+#         metric,
+#     ), expected_value in pr_expected_answers.items():
+#         assert (
+#             pr_metrics[0]["value"][value][threshold][metric] == expected_value
+#         )
+
+#     for (
+#         value,
+#         threshold,
+#         metric,
+#     ), expected_output in detailed_pr_expected_answers.items():
+#         model_output = detailed_pr_metrics[0]["value"][value][threshold][
+#             metric
+#         ]
+#         assert isinstance(model_output, dict)
+#         assert model_output["total"] == expected_output["total"]
+#         assert all(
+#             [
+#                 model_output["observations"][key]["count"]  # type: ignore - we know this element is a dict
+#                 == expected_output[key]
+#                 for key in [
+#                     key
+#                     for key in expected_output.keys()
+#                     if key not in ["total"]
+#                 ]
+#             ]
+#         )
+
+#     # spot check number of examples
+#     assert (
+#         len(
+#             detailed_pr_metrics[0]["value"]["0"][0.95]["fn"]["observations"]["no_predictions"][  # type: ignore - we know this element is a dict
+#                 "examples"
+#             ]
+#         )
+#         == 1
+#     )
+#     assert (
+#         len(
+#             detailed_pr_metrics[0]["value"]["49"][0.05]["tp"]["observations"]["all"][  # type: ignore - we know this element is a dict
+#                 "examples"
+#             ]
+#         )
+#         == 1
+#     )
+
+#     # raise the iou threshold
+#     Dataloader = Dataloader(
+#         metrics_to_return=[
+#             enums.MetricType.DetailedPrecisionRecallCurve,
+#             enums.MetricType.DetailedDetailedPrecisionRecallCurve,
+#         ],
+#         pr_curve_iou_threshold=0.9,
+#         pr_curve_max_examples=1,
+#     )
+
+#     Dataloader.add_data(
+#         groundtruths=evaluate_detection_functional_test_groundtruths,
+#         predictions=evaluate_detection_functional_test_predictions,
+#     )
+
+#     # check that ious have been precomputed
+#     assert "iou_" in Dataloader.joint_df.columns
+#     assert all(
+#         [
+#             col not in ["raster", "bounding_box"]
+#             for col in Dataloader.joint_df.columns
+#         ]
+#     )
+
+#     eval_job_higher_threshold = Dataloader.evaluate()
+
+#     pr_metrics = [
+#         m
+#         for m in eval_job_higher_threshold.metrics
+#         if m["type"] == "DetailedPrecisionRecallCurve"
+#     ]
+#     detailed_pr_metrics = [
+#         m
+#         for m in eval_job_higher_threshold.metrics
+#         if m["type"] == "DetailedDetailedPrecisionRecallCurve"
+#     ]
+
+#     for (
+#         key,
+#         value,
+#         threshold,
+#         metric,
+#     ), expected_count in higher_iou_threshold_pr_expected_answers.items():
+#         actual_count = pr_metrics[0]["value"][value][threshold][metric]
+#         assert actual_count == expected_count
+
+#     for (
+#         value,
+#         threshold,
+#         metric,
+#     ), expected_output in (
+#         higher_iou_threshold_detailed_pr_expected_answers.items()
+#     ):
+#         model_output = detailed_pr_metrics[0]["value"][value][threshold][
+#             metric
+#         ]
+#         assert isinstance(model_output, dict)
+#         assert model_output["total"] == expected_output["total"]
+#         assert all(
+#             [
+#                 model_output["observations"][key]["count"]  # type: ignore - we know this element is a dict
+#                 == expected_output[key]
+#                 for key in [
+#                     key
+#                     for key in expected_output.keys()
+#                     if key not in ["total"]
+#                 ]
+#             ]
+#         )
+
+#     assert (
+#         len(
+#             detailed_pr_metrics[0]["value"]["0"][0.95]["fn"]["observations"]["no_predictions"][  # type: ignore - we know this element is a dict
+#                 "examples"
+#             ]
+#         )
+#         == 1
+#     )
+#     assert (
+#         len(
+#             detailed_pr_metrics[0]["value"]["49"][0.05]["tp"]["observations"]["all"][  # type: ignore - we know this element is a dict
+#                 "examples"
+#             ]
+#         )
+#         == 1
+#     )
+
+#     # repeat the above, but with a higher pr_max_curves_example
+#     Dataloader = Dataloader(
+#         metrics_to_return=[
+#             enums.MetricType.DetailedPrecisionRecallCurve,
+#             enums.MetricType.DetailedDetailedPrecisionRecallCurve,
+#         ],
+#         pr_curve_iou_threshold=0.9,
+#         pr_curve_max_examples=3,
+#     )
+
+#     Dataloader.add_data(
+#         groundtruths=evaluate_detection_functional_test_groundtruths,
+#         predictions=evaluate_detection_functional_test_predictions,
+#     )
+
+#     # check that ious have been precomputed
+#     assert "iou_" in Dataloader.joint_df.columns
+#     assert all(
+#         [
+#             col not in ["raster", "bounding_box"]
+#             for col in Dataloader.joint_df.columns
+#         ]
+#     )
+
+#     eval_job_higher_threshold = Dataloader.evaluate()
+
+#     pr_metrics = [
+#         m
+#         for m in eval_job_higher_threshold.metrics
+#         if m["type"] == "DetailedPrecisionRecallCurve"
+#     ]
+#     detailed_pr_metrics = [
+#         m
+#         for m in eval_job_higher_threshold.metrics
+#         if m["type"] == "DetailedDetailedPrecisionRecallCurve"
+#     ]
+
+#     for (
+#         key,
+#         value,
+#         threshold,
+#         metric,
+#     ), expected_count in higher_iou_threshold_pr_expected_answers.items():
+#         actual_count = pr_metrics[0]["value"][value][threshold][metric]
+#         assert actual_count == expected_count
+
+#     for (
+#         value,
+#         threshold,
+#         metric,
+#     ), expected_output in (
+#         higher_iou_threshold_detailed_pr_expected_answers.items()
+#     ):
+#         model_output = detailed_pr_metrics[0]["value"][value][threshold][
+#             metric
+#         ]
+#         assert isinstance(model_output, dict)
+#         assert model_output["total"] == expected_output["total"]
+#         assert all(
+#             [
+#                 model_output["observations"][key]["count"]  # type: ignore - we know this element is a dict
+#                 == expected_output[key]
+#                 for key in [
+#                     key
+#                     for key in expected_output.keys()
+#                     if key not in ["total"]
+#                 ]
+#             ]
+#         )
+
+#     assert (
+#         len(
+#             detailed_pr_metrics[0]["value"]["0"][0.95]["fn"]["observations"]["no_predictions"][  # type: ignore - we know this element is a dict
+#                 "examples"
+#             ]
+#         )
+#         == 3
+#     )
+#     assert (
+#         len(
+#             detailed_pr_metrics[0]["value"]["49"][0.05]["tp"]["observations"]["all"][  # type: ignore - we know this element is a dict
+#                 "examples"
+#             ]
+#         )
+#         == 2
+#     )
+
+#     # test behavior if pr_curve_max_examples == 0
+#     Dataloader = Dataloader(
+#         metrics_to_return=[
+#             enums.MetricType.DetailedPrecisionRecallCurve,
+#             enums.MetricType.DetailedDetailedPrecisionRecallCurve,
+#         ],
+#         pr_curve_iou_threshold=0.9,
+#         pr_curve_max_examples=0,
+#     )
+
+#     Dataloader.add_data(
+#         groundtruths=evaluate_detection_functional_test_groundtruths,
+#         predictions=evaluate_detection_functional_test_predictions,
+#     )
+
+#     # check that ious have been precomputed
+#     assert "iou_" in Dataloader.joint_df.columns
+#     assert all(
+#         [
+#             col not in ["raster", "bounding_box"]
+#             for col in Dataloader.joint_df.columns
+#         ]
+#     )
+
+#     eval_job_higher_threshold = Dataloader.evaluate()
+
+#     pr_metrics = [
+#         m
+#         for m in eval_job_higher_threshold.metrics
+#         if m["type"] == "DetailedPrecisionRecallCurve"
+#     ]
+#     detailed_pr_metrics = [
+#         m
+#         for m in eval_job_higher_threshold.metrics
+#         if m["type"] == "DetailedDetailedPrecisionRecallCurve"
+#     ]
+
+#     for (
+#         key,
+#         value,
+#         threshold,
+#         metric,
+#     ), expected_count in higher_iou_threshold_pr_expected_answers.items():
+#         actual_count = pr_metrics[0]["value"][value][threshold][metric]
+#         assert actual_count == expected_count
+
+#     for (
+#         value,
+#         threshold,
+#         metric,
+#     ), expected_output in (
+#         higher_iou_threshold_detailed_pr_expected_answers.items()
+#     ):
+#         model_output = detailed_pr_metrics[0]["value"][value][threshold][
+#             metric
+#         ]
+#         assert isinstance(model_output, dict)
+#         assert model_output["total"] == expected_output["total"]
+#         assert all(
+#             [
+#                 model_output["observations"][key]["count"]  # type: ignore - we know this element is a dict
+#                 == expected_output[key]
+#                 for key in [
+#                     key
+#                     for key in expected_output.keys()
+#                     if key not in ["total"]
+#                 ]
+#             ]
+#         )
+
+#     # spot check number of examples
+#     assert (
+#         len(
+#             detailed_pr_metrics[0]["value"]["0"][0.95]["fn"]["observations"]["no_predictions"][  # type: ignore - we know this element is a dict
+#                 "examples"
+#             ]
+#         )
+#         == 0
+#     )
+#     assert (
+#         len(
+#             detailed_pr_metrics[0]["value"]["49"][0.05]["tp"]["observations"]["all"][  # type: ignore - we know this element is a dict
+#                 "examples"
+#             ]
+#         )
+#         == 0
+#     )
diff --git a/lite/tests/detection/test_evaluator.py b/lite/tests/detection/test_evaluator.py
new file mode 100644
index 000000000..179e8c11e
--- /dev/null
+++ b/lite/tests/detection/test_evaluator.py
@@ -0,0 +1,31 @@
+from valor_lite.detection import DataLoader, Detection
+
+
+def test_metadata_using_torch_metrics_example(
+    torchmetrics_detections: list[Detection],
+):
+    """
+    cf with torch metrics/pycocotools results listed here:
+    https://github.com/Lightning-AI/metrics/blob/107dbfd5fb158b7ae6d76281df44bd94c836bfce/tests/unittests/detection/test_map.py#L231
+    """
+    manager = DataLoader()
+    manager.add_data(torchmetrics_detections)
+    evaluator = manager.finalize()
+
+    assert evaluator.ignored_prediction_labels == [("class", "3")]
+    assert evaluator.missing_prediction_labels == []
+    assert evaluator.n_datums == 4
+    assert evaluator.n_labels == 6
+    assert evaluator.n_groundtruths == 20
+    assert evaluator.n_predictions == 19
+
+    assert evaluator.metadata == {
+        "ignored_prediction_labels": [
+            ("class", "3"),
+        ],
+        "missing_prediction_labels": [],
+        "n_datums": 4,
+        "n_labels": 6,
+        "n_groundtruths": 20,
+        "n_predictions": 19,
+    }
diff --git a/lite/tests/detection/test_filtering.py b/lite/tests/detection/test_filtering.py
new file mode 100644
index 000000000..7420b4877
--- /dev/null
+++ b/lite/tests/detection/test_filtering.py
@@ -0,0 +1,401 @@
+from dataclasses import replace
+
+import numpy as np
+import pytest
+from valor_lite.detection import BoundingBox, DataLoader, Detection, MetricType
+
+
+@pytest.fixture
+def one_detection(basic_detections: list[Detection]) -> list[Detection]:
+    return [basic_detections[0]]
+
+
+@pytest.fixture
+def two_detections(basic_detections: list[Detection]) -> list[Detection]:
+    return basic_detections
+
+
+@pytest.fixture
+def four_detections(basic_detections: list[Detection]) -> list[Detection]:
+    det1 = basic_detections[0]
+    det2 = basic_detections[1]
+    det3 = replace(basic_detections[0])
+    det4 = replace(basic_detections[1])
+
+    det3.uid = "uid3"
+    det4.uid = "uid4"
+
+    return [det1, det2, det3, det4]
+
+
+def generate_random_detections(
+    n_detections: int, n_boxes: int, labels: str
+) -> list[Detection]:
+    from random import choice, uniform
+
+    def bbox(is_prediction):
+        xmin, ymin = uniform(0, 10), uniform(0, 10)
+        xmax, ymax = uniform(xmin, 15), uniform(ymin, 15)
+        kw = {"scores": [uniform(0, 1)]} if is_prediction else {}
+        return BoundingBox(
+            xmin,
+            xmax,
+            ymin,
+            ymax,
+            [("cl", choice(labels))],
+            **kw,
+        )
+
+    return [
+        Detection(
+            uid=f"uid{i}",
+            groundtruths=[bbox(is_prediction=False) for _ in range(n_boxes)],
+            predictions=[bbox(is_prediction=True) for _ in range(n_boxes)],
+        )
+        for i in range(n_detections)
+    ]
+
+
+def test_filtering_one_detection(one_detection: list[Detection]):
+    """
+    Basic object detection test.
+
+    groundtruths
+        datum uid1
+            box 1 - label (k1, v1) - tp
+            box 3 - label (k2, v2) - fn missing prediction
+
+    predictions
+        datum uid1
+            box 1 - label (k1, v1) - score 0.3 - tp
+    """
+
+    manager = DataLoader()
+    manager.add_data(one_detection)
+    evaluator = manager.finalize()
+
+    assert (
+        evaluator._ranked_pairs
+        == np.array(
+            [
+                [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.3],
+            ]
+        )
+    ).all()
+
+    assert (
+        evaluator._label_metadata_per_datum
+        == np.array(
+            [
+                [
+                    [1, 1],
+                ],
+                [
+                    [1, 0],
+                ],
+            ]
+        )
+    ).all()
+
+    assert (
+        evaluator._label_metadata == np.array([[1, 1, 0], [1, 0, 1]])
+    ).all()
+
+    # test datum filtering
+
+    filter_ = evaluator.create_filter(datum_uids=["uid1"])
+    assert (filter_.indices == np.array([0])).all()
+    assert (filter_.label_metadata == np.array([[1, 1, 0], [1, 0, 1]])).all()
+
+    # test label filtering
+
+    filter_ = evaluator.create_filter(labels=[("k1", "v1")])
+    assert (filter_.indices == np.array([])).all()
+
+    filter_ = evaluator.create_filter(labels=[("k2", "v2")])
+    assert (filter_.indices == np.array([])).all()
+
+    # test label key filtering
+
+    filter_ = evaluator.create_filter(label_keys=["k1"])
+    assert (filter_.indices == np.array([0])).all()
+
+    filter_ = evaluator.create_filter(label_keys=["k2"])
+    assert (filter_.indices == np.array([])).all()
+
+    # test combo
+    filter_ = evaluator.create_filter(
+        datum_uids=["uid1"],
+        label_keys=["k1"],
+    )
+    assert (filter_.indices == np.array([0])).all()
+
+    # test evaluation
+    filter_ = evaluator.create_filter(datum_uids=["uid1"])
+    metrics = evaluator.evaluate(
+        iou_thresholds=[0.5],
+        filter_=filter_,
+    )
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.AP]]
+    expected_metrics = [
+        {
+            "type": "AP",
+            "value": 1.0,
+            "parameters": {"iou": 0.5, "label": {"key": "k1", "value": "v1"}},
+        },
+        {
+            "type": "AP",
+            "value": 0.0,
+            "parameters": {"iou": 0.5, "label": {"key": "k2", "value": "v2"}},
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+
+def test_filtering_two_detections(two_detections: list[Detection]):
+    """
+    Basic object detection test.
+
+    groundtruths
+        datum uid1
+            box 1 - label (k1, v1) - tp
+            box 3 - label (k2, v2) - fn missing prediction
+        datum uid2
+            box 2 - label (k1, v1) - fn misclassification
+
+    predictions
+        datum uid1
+            box 1 - label (k1, v1) - score 0.3 - tp
+        datum uid2
+            box 2 - label (k2, v2) - score 0.98 - fp
+    """
+
+    manager = DataLoader()
+    manager.add_data(two_detections)
+    evaluator = manager.finalize()
+
+    assert (
+        evaluator._ranked_pairs
+        == np.array(
+            [
+                [1.0, -1.0, 0.0, 0.0, -1.0, 1.0, 0.98],
+                [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.3],
+            ]
+        )
+    ).all()
+
+    assert (
+        evaluator._label_metadata_per_datum
+        == np.array(
+            [
+                [
+                    [1, 1],
+                    [1, 0],
+                ],
+                [
+                    [1, 0],
+                    [0, 1],
+                ],
+            ]
+        )
+    ).all()
+
+    assert (
+        evaluator._label_metadata == np.array([[2, 1, 0], [1, 1, 1]])
+    ).all()
+
+    # test datum filtering
+
+    filter_ = evaluator.create_filter(datum_uids=["uid1"])
+    assert (filter_.indices == np.array([1])).all()
+    assert (filter_.label_metadata == np.array([[1, 1, 0], [1, 0, 1]])).all()
+
+    filter_ = evaluator.create_filter(datum_uids=["uid2"])
+    assert (filter_.indices == np.array([0])).all()
+
+    # test label filtering
+
+    filter_ = evaluator.create_filter(labels=[("k1", "v1")])
+    assert (filter_.indices == np.array([1])).all()
+
+    filter_ = evaluator.create_filter(labels=[("k2", "v2")])
+    assert (filter_.indices == np.array([])).all()
+
+    # test label key filtering
+
+    filter_ = evaluator.create_filter(label_keys=["k1"])
+    assert (filter_.indices == np.array([1])).all()
+
+    filter_ = evaluator.create_filter(label_keys=["k2"])
+    assert (filter_.indices == np.array([])).all()
+
+    # test combo
+    filter_ = evaluator.create_filter(
+        datum_uids=["uid1"],
+        label_keys=["k1"],
+    )
+    assert (filter_.indices == np.array([1])).all()
+
+    # test evaluation
+    filter_ = evaluator.create_filter(datum_uids=["uid1"])
+    metrics = evaluator.evaluate(
+        iou_thresholds=[0.5],
+        filter_=filter_,
+    )
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.AP]]
+    expected_metrics = [
+        {
+            "type": "AP",
+            "value": 1.0,
+            "parameters": {"iou": 0.5, "label": {"key": "k1", "value": "v1"}},
+        },
+        {
+            "type": "AP",
+            "value": 0.0,
+            "parameters": {"iou": 0.5, "label": {"key": "k2", "value": "v2"}},
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+
+def test_filtering_four_detections(four_detections: list[Detection]):
+    """
+    Basic object detection test.
+
+    groundtruths
+        datum uid1
+            box 1 - label (k1, v1) - tp
+            box 3 - label (k2, v2) - fn missing prediction
+        datum uid2
+            box 2 - label (k1, v1) - fn misclassification
+        datum uid3
+            box 1 - label (k1, v1) - tp
+            box 3 - label (k2, v2) - fn missing prediction
+        datum uid4
+            box 2 - label (k1, v1) - fn misclassification
+
+    predictions
+        datum uid1
+            box 1 - label (k1, v1) - score 0.3 - tp
+        datum uid2
+            box 2 - label (k2, v2) - score 0.98 - fp
+        datum uid3
+            box 1 - label (k1, v1) - score 0.3 - tp
+        datum uid4
+            box 2 - label (k2, v2) - score 0.98 - fp
+    """
+
+    manager = DataLoader()
+    manager.add_data(four_detections)
+    evaluator = manager.finalize()
+
+    assert (
+        evaluator._ranked_pairs
+        == np.array(
+            [
+                [1.0, -1.0, 0.0, 0.0, -1.0, 1.0, 0.98],
+                [3.0, -1.0, 0.0, 0.0, -1.0, 1.0, 0.98],
+                [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.3],
+                [2.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.3],
+            ]
+        )
+    ).all()
+
+    assert (
+        evaluator._label_metadata_per_datum
+        == np.array(
+            [
+                [
+                    [1, 1],
+                    [1, 0],
+                    [1, 1],
+                    [1, 0],
+                ],
+                [
+                    [1, 0],
+                    [0, 1],
+                    [1, 0],
+                    [0, 1],
+                ],
+            ],
+            dtype=np.int32,
+        )
+    ).all()
+
+    assert (
+        evaluator._label_metadata == np.array([[4, 2, 0], [2, 2, 1]])
+    ).all()
+
+    # test datum filtering
+
+    filter_ = evaluator.create_filter(datum_uids=["uid1"])
+    assert (filter_.indices == np.array([2])).all()
+    assert (filter_.label_metadata == np.array([[1, 1, 0], [1, 0, 1]])).all()
+
+    filter_ = evaluator.create_filter(datum_uids=["uid2"])
+    assert (filter_.indices == np.array([0])).all()
+
+    # test label filtering
+
+    filter_ = evaluator.create_filter(labels=[("k1", "v1")])
+    assert (filter_.indices == np.array([2, 3])).all()
+
+    filter_ = evaluator.create_filter(labels=[("k2", "v2")])
+    assert (filter_.indices == np.array([])).all()
+
+    # test label key filtering
+
+    filter_ = evaluator.create_filter(label_keys=["k1"])
+    assert (filter_.indices == np.array([2, 3])).all()
+
+    filter_ = evaluator.create_filter(label_keys=["k2"])
+    assert (filter_.indices == np.array([])).all()
+
+    # test combo
+    filter_ = evaluator.create_filter(
+        datum_uids=["uid1"],
+        label_keys=["k1"],
+    )
+    assert (filter_.indices == np.array([2])).all()
+
+    # test evaluation
+    filter_ = evaluator.create_filter(datum_uids=["uid1"])
+
+    metrics = evaluator.evaluate(
+        iou_thresholds=[0.5],
+        filter_=filter_,
+    )
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.AP]]
+    expected_metrics = [
+        {
+            "type": "AP",
+            "value": 1.0,
+            "parameters": {"iou": 0.5, "label": {"key": "k1", "value": "v1"}},
+        },
+        {
+            "type": "AP",
+            "value": 0.0,
+            "parameters": {"iou": 0.5, "label": {"key": "k2", "value": "v2"}},
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+
+def test_filtering_random_detections():
+    loader = DataLoader()
+    loader.add_data(generate_random_detections(13, 4, "abc"))
+    evaluator = loader.finalize()
+    f = evaluator.create_filter(datum_uids=["uid1"])
+    evaluator.evaluate(filter_=f)
diff --git a/lite/tests/detection/test_iou.py b/lite/tests/detection/test_iou.py
new file mode 100644
index 000000000..c929f827b
--- /dev/null
+++ b/lite/tests/detection/test_iou.py
@@ -0,0 +1,30 @@
+import numpy as np
+from valor_lite.detection import compute_iou
+
+
+def test_compute_iou():
+
+    # xmin, xmax, ymin, ymax
+    box1 = np.array([0.0, 10.0, 0.0, 10.0])
+    box2 = np.array([5.0, 10.0, 0.0, 10.0])
+    box3 = np.array([0.0, 5.0, 5.0, 10.0])
+    box4 = np.array([5.0, 15.0, 0.0, 10.0])
+    box5 = np.array([0.0, 15.0, 0.0, 10.0])
+
+    pairs = np.array(
+        [
+            np.concatenate((box1, box1)),
+            np.concatenate((box1, box2)),
+            np.concatenate((box1, box3)),
+            np.concatenate((box1, box4)),
+            np.concatenate((box1, box5)),
+        ]
+    )
+
+    ious = compute_iou(pairs)
+    assert len(ious) == 5
+    assert ious[0] == 1.0
+    assert ious[1] == 0.5
+    assert ious[2] == 0.25
+    assert round(ious[3], 5) == 0.33333
+    assert round(ious[4], 5) == 0.66667
diff --git a/lite/tests/detection/test_pr_curve.py b/lite/tests/detection/test_pr_curve.py
new file mode 100644
index 000000000..3a99e6716
--- /dev/null
+++ b/lite/tests/detection/test_pr_curve.py
@@ -0,0 +1,177 @@
+import numpy as np
+from valor_lite.detection import (
+    DataLoader,
+    Detection,
+    MetricType,
+    compute_metrics,
+)
+
+
+def test_pr_curve_simple():
+
+    sorted_pairs = np.array(
+        [
+            # dt,  gt,  pd,  iou,  gl,  pl, score,
+            [0.0, 0.0, 2.0, 0.25, 0.0, 0.0, 0.95],
+            [0.0, 0.0, 3.0, 0.33333, 0.0, 0.0, 0.9],
+            [0.0, 0.0, 4.0, 0.66667, 0.0, 0.0, 0.65],
+            [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.1],
+            [0.0, 0.0, 1.0, 0.5, 0.0, 0.0, 0.01],
+        ]
+    )
+
+    label_counts = np.array([[1, 5, 0]])
+    iou_thresholds = np.array([0.1, 0.6])
+    score_thresholds = np.array([0.0])
+
+    (_, _, _, pr_curve) = compute_metrics(
+        sorted_pairs,
+        label_counts=label_counts,
+        iou_thresholds=iou_thresholds,
+        score_thresholds=score_thresholds,
+    )
+
+    assert pr_curve.shape == (2, 1, 101)
+    assert np.isclose(pr_curve[0][0], 1.0).all()
+    assert np.isclose(pr_curve[1][0], 1 / 3).all()
+
+
+def test_pr_curve_using_torch_metrics_example(
+    torchmetrics_detections: list[Detection],
+):
+    """
+    cf with torch metrics/pycocotools results listed here:
+    https://github.com/Lightning-AI/metrics/blob/107dbfd5fb158b7ae6d76281df44bd94c836bfce/tests/unittests/detection/test_map.py#L231
+    """
+    manager = DataLoader()
+    manager.add_data(torchmetrics_detections)
+    evaluator = manager.finalize()
+
+    assert evaluator.ignored_prediction_labels == [("class", "3")]
+    assert evaluator.missing_prediction_labels == []
+    assert evaluator.n_datums == 4
+    assert evaluator.n_labels == 6
+    assert evaluator.n_groundtruths == 20
+    assert evaluator.n_predictions == 19
+
+    metrics = evaluator.evaluate(
+        iou_thresholds=[0.5, 0.75],
+    )
+
+    # AP = 1.0
+    a = [1.0 for _ in range(101)]
+
+    # AP = 0.505
+    b = [1.0 for _ in range(51)] + [0.0 for _ in range(50)]
+
+    # AP = 0.791
+    c = (
+        [1.0 for _ in range(71)]
+        + [8 / 9 for _ in range(10)]
+        + [0.0 for _ in range(20)]
+    )
+
+    # AP = 0.722
+    d = (
+        [1.0 for _ in range(41)]
+        + [0.8 for _ in range(40)]
+        + [0.0 for _ in range(20)]
+    )
+
+    # AP = 0.576
+    e = (
+        [1.0 for _ in range(41)]
+        + [0.8571428571428571 for _ in range(20)]
+        + [0.0 for _ in range(40)]
+    )
+
+    # test PrecisionRecallCurve
+    actual_metrics = [
+        m.to_dict() for m in metrics[MetricType.PrecisionRecallCurve]
+    ]
+    expected_metrics = [
+        {
+            "type": "PrecisionRecallCurve",
+            "value": a,
+            "parameters": {
+                "iou": 0.5,
+                "label": {"key": "class", "value": "0"},
+            },
+        },
+        {
+            "type": "PrecisionRecallCurve",
+            "value": d,
+            "parameters": {
+                "iou": 0.75,
+                "label": {"key": "class", "value": "0"},
+            },
+        },
+        {
+            "type": "PrecisionRecallCurve",
+            "value": a,
+            "parameters": {
+                "iou": 0.5,
+                "label": {"key": "class", "value": "1"},
+            },
+        },
+        {
+            "type": "PrecisionRecallCurve",
+            "value": a,
+            "parameters": {
+                "iou": 0.75,
+                "label": {"key": "class", "value": "1"},
+            },
+        },
+        {
+            "type": "PrecisionRecallCurve",
+            "value": b,
+            "parameters": {
+                "iou": 0.5,
+                "label": {"key": "class", "value": "2"},
+            },
+        },
+        {
+            "type": "PrecisionRecallCurve",
+            "value": b,
+            "parameters": {
+                "iou": 0.75,
+                "label": {"key": "class", "value": "2"},
+            },
+        },
+        {
+            "type": "PrecisionRecallCurve",
+            "value": a,
+            "parameters": {
+                "iou": 0.5,
+                "label": {"key": "class", "value": "4"},
+            },
+        },
+        {
+            "type": "PrecisionRecallCurve",
+            "value": a,
+            "parameters": {
+                "iou": 0.75,
+                "label": {"key": "class", "value": "4"},
+            },
+        },
+        {
+            "type": "PrecisionRecallCurve",
+            "value": c,
+            "parameters": {
+                "iou": 0.5,
+                "label": {"key": "class", "value": "49"},
+            },
+        },
+        {
+            "type": "PrecisionRecallCurve",
+            "value": e,
+            "parameters": {
+                "iou": 0.75,
+                "label": {"key": "class", "value": "49"},
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
diff --git a/lite/tests/detection/test_precision.py b/lite/tests/detection/test_precision.py
new file mode 100644
index 000000000..6982cc39a
--- /dev/null
+++ b/lite/tests/detection/test_precision.py
@@ -0,0 +1,389 @@
+from valor_lite.detection import DataLoader, Detection, MetricType
+
+
+def test_precision_metrics(basic_detections: list[Detection]):
+    """
+    Basic object detection test.
+
+    groundtruths
+        datum uid1
+            box 1 - label (k1, v1) - tp
+            box 3 - label (k2, v2) - fn missing prediction
+        datum uid2
+            box 2 - label (k1, v1) - fn misclassification
+
+    predictions
+        datum uid1
+            box 1 - label (k1, v1) - score 0.3 - tp
+        datum uid2
+            box 2 - label (k2, v2) - score 0.98 - fp
+    """
+
+    manager = DataLoader()
+    manager.add_data(basic_detections)
+    evaluator = manager.finalize()
+
+    metrics = evaluator.evaluate(
+        iou_thresholds=[0.1, 0.6],
+        score_thresholds=[0.0, 0.5],
+    )
+
+    assert evaluator.ignored_prediction_labels == []
+    assert evaluator.missing_prediction_labels == []
+    assert evaluator.n_datums == 2
+    assert evaluator.n_labels == 2
+    assert evaluator.n_groundtruths == 3
+    assert evaluator.n_predictions == 2
+
+    # test Precision
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Precision]]
+    expected_metrics = [
+        {
+            "type": "Precision",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.1,
+                "score": 0.0,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+        {
+            "type": "Precision",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.6,
+                "score": 0.0,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+        {
+            "type": "Precision",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.1,
+                "score": 0.0,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+        {
+            "type": "Precision",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.6,
+                "score": 0.0,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+        {
+            "type": "Precision",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.1,
+                "score": 0.5,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+        {
+            "type": "Precision",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.6,
+                "score": 0.5,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+        {
+            "type": "Precision",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.1,
+                "score": 0.5,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+        {
+            "type": "Precision",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.6,
+                "score": 0.5,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+
+def test_precision_false_negatives_single_datum_baseline(
+    false_negatives_single_datum_baseline_detections: list[Detection],
+):
+    """This is the baseline for the below test. In this case there are two predictions and
+    one groundtruth, but the highest confident prediction overlaps sufficiently with the groundtruth
+    so there is not a penalty for the false negative so the AP is 1
+    """
+
+    manager = DataLoader()
+    manager.add_data(false_negatives_single_datum_baseline_detections)
+    evaluator = manager.finalize()
+
+    metrics = evaluator.evaluate(
+        iou_thresholds=[0.5], score_thresholds=[0.0, 0.9]
+    )
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Precision]]
+    expected_metrics = [
+        {
+            "type": "Precision",
+            "value": 0.5,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+        {
+            "type": "Precision",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.9,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+
+def test_precision_false_negatives_single_datum(
+    false_negatives_single_datum_detections: list[Detection],
+):
+    """Tests where high confidence false negative was not being penalized. The
+    difference between this test and the above is that here the prediction with higher confidence
+    does not sufficiently overlap the groundtruth and so is penalized and we get an AP of 0.5
+    """
+
+    manager = DataLoader()
+    manager.add_data(false_negatives_single_datum_detections)
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Precision]]
+    expected_metrics = [
+        {
+            "type": "Precision",
+            "value": 0.5,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        }
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_precision_false_negatives_two_datums_one_empty_low_confidence_of_fp(
+    false_negatives_two_datums_one_empty_low_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class and high IOU)
+        2. A second image with empty groundtruth annotation but a prediction with lower confidence
+        then the prediction on the first image.
+
+    In this case, the AP should be 1.0 since the false positive has lower confidence than the true positive
+
+    """
+
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_datums_one_empty_low_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Precision]]
+    expected_metrics = [
+        {
+            "type": "Precision",
+            "value": 0.5,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        }
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_precision_false_negatives_two_datums_one_empty_high_confidence_of_fp(
+    false_negatives_two_datums_one_empty_high_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class and high IOU)
+        2. A second image with empty groundtruth annotation and a prediction with higher confidence
+        then the prediction on the first image.
+
+    In this case, the AP should be 0.5 since the false positive has higher confidence than the true positive
+    """
+
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_datums_one_empty_high_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Precision]]
+    expected_metrics = [
+        {
+            "type": "Precision",
+            "value": 0.5,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        }
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_precision_false_negatives_two_datums_one_only_with_different_class_low_confidence_of_fp(
+    false_negatives_two_datums_one_only_with_different_class_low_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class, `"value"`, and high IOU)
+        2. A second image with a groundtruth annotation with class `"other value"` and a prediction with lower confidence
+        then the prediction on the first image.
+
+    In this case, the AP for class `"value"` should be 1 since the false positive has lower confidence than the true positive.
+    AP for class `"other value"` should be 0 since there is no prediction for the `"other value"` groundtruth
+    """
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_datums_one_only_with_different_class_low_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Precision]]
+    expected_metrics = [
+        {
+            "type": "Precision",
+            "value": 0.5,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+        {
+            "type": "Precision",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "other value",
+                },
+            },
+        },
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_precision_false_negatives_two_datums_one_only_with_different_class_high_confidence_of_fp(
+    false_negatives_two_images_one_only_with_different_class_high_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class, `"value"`, and high IOU)
+        2. A second image with a groundtruth annotation with class `"other value"` and a prediction with higher confidence
+        then the prediction on the first image.
+
+    In this case, the AP for class `"value"` should be 0.5 since the false positive has higher confidence than the true positive.
+    AP for class `"other value"` should be 0 since there is no prediction for the `"other value"` groundtruth
+    """
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_images_one_only_with_different_class_high_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Precision]]
+    expected_metrics = [
+        {
+            "type": "Precision",
+            "value": 0.5,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+        {
+            "type": "Precision",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "other value",
+                },
+            },
+        },
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
diff --git a/lite/tests/detection/test_recall.py b/lite/tests/detection/test_recall.py
new file mode 100644
index 000000000..659ac95e0
--- /dev/null
+++ b/lite/tests/detection/test_recall.py
@@ -0,0 +1,389 @@
+from valor_lite.detection import DataLoader, Detection, MetricType
+
+
+def test_recall_metrics(basic_detections: list[Detection]):
+    """
+    Basic object detection test.
+
+    groundtruths
+        datum uid1
+            box 1 - label (k1, v1) - tp
+            box 3 - label (k2, v2) - fn missing prediction
+        datum uid2
+            box 2 - label (k1, v1) - fn misclassification
+
+    predictions
+        datum uid1
+            box 1 - label (k1, v1) - score 0.3 - tp
+        datum uid2
+            box 2 - label (k2, v2) - score 0.98 - fp
+    """
+
+    manager = DataLoader()
+    manager.add_data(basic_detections)
+    evaluator = manager.finalize()
+
+    metrics = evaluator.evaluate(
+        iou_thresholds=[0.1, 0.6],
+        score_thresholds=[0.0, 0.5],
+    )
+
+    assert evaluator.ignored_prediction_labels == []
+    assert evaluator.missing_prediction_labels == []
+    assert evaluator.n_datums == 2
+    assert evaluator.n_labels == 2
+    assert evaluator.n_groundtruths == 3
+    assert evaluator.n_predictions == 2
+
+    # test Recall
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Recall]]
+    expected_metrics = [
+        {
+            "type": "Recall",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.1,
+                "score": 0.0,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+        {
+            "type": "Recall",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.6,
+                "score": 0.0,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+        {
+            "type": "Recall",
+            "value": 0.5,
+            "parameters": {
+                "iou": 0.1,
+                "score": 0.0,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+        {
+            "type": "Recall",
+            "value": 0.5,
+            "parameters": {
+                "iou": 0.6,
+                "score": 0.0,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+        {
+            "type": "Recall",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.1,
+                "score": 0.5,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+        {
+            "type": "Recall",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.6,
+                "score": 0.5,
+                "label": {"key": "k2", "value": "v2"},
+            },
+        },
+        {
+            "type": "Recall",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.1,
+                "score": 0.5,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+        {
+            "type": "Recall",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.6,
+                "score": 0.5,
+                "label": {"key": "k1", "value": "v1"},
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+
+def test_recall_false_negatives_single_datum_baseline(
+    false_negatives_single_datum_baseline_detections: list[Detection],
+):
+    """This is the baseline for the below test. In this case there are two predictions and
+    one groundtruth, but the highest confident prediction overlaps sufficiently with the groundtruth
+    so there is not a penalty for the false negative so the AP is 1
+    """
+
+    manager = DataLoader()
+    manager.add_data(false_negatives_single_datum_baseline_detections)
+    evaluator = manager.finalize()
+
+    metrics = evaluator.evaluate(
+        iou_thresholds=[0.5], score_thresholds=[0.0, 0.9]
+    )
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Recall]]
+    expected_metrics = [
+        {
+            "type": "Recall",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+        {
+            "type": "Recall",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.9,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+    ]
+    for m in actual_metrics:
+        assert m in expected_metrics
+    for m in expected_metrics:
+        assert m in actual_metrics
+
+
+def test_recall_false_negatives_single_datum(
+    false_negatives_single_datum_detections: list[Detection],
+):
+    """Tests where high confidence false negative was not being penalized. The
+    difference between this test and the above is that here the prediction with higher confidence
+    does not sufficiently overlap the groundtruth and so is penalized and we get an AP of 0.5
+    """
+
+    manager = DataLoader()
+    manager.add_data(false_negatives_single_datum_detections)
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Recall]]
+    expected_metrics = [
+        {
+            "type": "Recall",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        }
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_recall_false_negatives_two_datums_one_empty_low_confidence_of_fp(
+    false_negatives_two_datums_one_empty_low_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class and high IOU)
+        2. A second image with empty groundtruth annotation but a prediction with lower confidence
+        then the prediction on the first image.
+
+    In this case, the AP should be 1.0 since the false positive has lower confidence than the true positive
+
+    """
+
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_datums_one_empty_low_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Recall]]
+    expected_metrics = [
+        {
+            "type": "Recall",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        }
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_recall_false_negatives_two_datums_one_empty_high_confidence_of_fp(
+    false_negatives_two_datums_one_empty_high_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class and high IOU)
+        2. A second image with empty groundtruth annotation and a prediction with higher confidence
+        then the prediction on the first image.
+
+    In this case, the AP should be 0.5 since the false positive has higher confidence than the true positive
+    """
+
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_datums_one_empty_high_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Recall]]
+    expected_metrics = [
+        {
+            "type": "Recall",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        }
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_recall_false_negatives_two_datums_one_only_with_different_class_low_confidence_of_fp(
+    false_negatives_two_datums_one_only_with_different_class_low_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class, `"value"`, and high IOU)
+        2. A second image with a groundtruth annotation with class `"other value"` and a prediction with lower confidence
+        then the prediction on the first image.
+
+    In this case, the AP for class `"value"` should be 1 since the false positive has lower confidence than the true positive.
+    AP for class `"other value"` should be 0 since there is no prediction for the `"other value"` groundtruth
+    """
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_datums_one_only_with_different_class_low_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Recall]]
+    expected_metrics = [
+        {
+            "type": "Recall",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+        {
+            "type": "Recall",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "other value",
+                },
+            },
+        },
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
+
+
+def test_recall_false_negatives_two_datums_one_only_with_different_class_high_confidence_of_fp(
+    false_negatives_two_images_one_only_with_different_class_high_confidence_of_fp_detections: list[
+        Detection
+    ],
+):
+    """In this test we have
+        1. An image with a matching groundtruth and prediction (same class, `"value"`, and high IOU)
+        2. A second image with a groundtruth annotation with class `"other value"` and a prediction with higher confidence
+        then the prediction on the first image.
+
+    In this case, the AP for class `"value"` should be 0.5 since the false positive has higher confidence than the true positive.
+    AP for class `"other value"` should be 0 since there is no prediction for the `"other value"` groundtruth
+    """
+    manager = DataLoader()
+    manager.add_data(
+        false_negatives_two_images_one_only_with_different_class_high_confidence_of_fp_detections
+    )
+    evaluator = manager.finalize()
+    metrics = evaluator.evaluate(iou_thresholds=[0.5], score_thresholds=[0.0])
+
+    actual_metrics = [m.to_dict() for m in metrics[MetricType.Recall]]
+    expected_metrics = [
+        {
+            "type": "Recall",
+            "value": 1.0,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "value",
+                },
+            },
+        },
+        {
+            "type": "Recall",
+            "value": 0.0,
+            "parameters": {
+                "iou": 0.5,
+                "score": 0.0,
+                "label": {
+                    "key": "key",
+                    "value": "other value",
+                },
+            },
+        },
+    ]
+    for m in expected_metrics:
+        assert m in actual_metrics
+    for m in actual_metrics:
+        assert m in expected_metrics
diff --git a/lite/tests/detection/test_schemas.py b/lite/tests/detection/test_schemas.py
new file mode 100644
index 000000000..8345fed36
--- /dev/null
+++ b/lite/tests/detection/test_schemas.py
@@ -0,0 +1,105 @@
+import numpy as np
+import pytest
+from valor_lite.detection import Bitmask, BoundingBox, Detection
+
+
+def test_BoundingBox():
+    # groundtruth
+    gt = BoundingBox(xmin=0, xmax=1, ymin=0, ymax=1, labels=[("k", "v")])
+
+    # prediction
+    pd = BoundingBox(
+        xmin=-1,
+        xmax=11,
+        ymin=0,
+        ymax=1,
+        labels=[("k", "v")],
+        scores=[0.7],
+    )
+
+    with pytest.raises(ValueError):
+        BoundingBox(
+            xmin=0,
+            xmax=1,
+            ymin=0,
+            ymax=1,
+            labels=[("k", "v")],
+            scores=[0.7, 0.1],
+        )
+    with pytest.raises(ValueError):
+        BoundingBox(
+            xmin=0,
+            xmax=1,
+            ymin=0,
+            ymax=1,
+            labels=[("k", "v1"), ("k", "v2")],
+            scores=[0.7],
+        )
+
+    # test `extrema` property
+    assert gt.extrema == (0, 1, 0, 1)
+    assert pd.extrema == (-1, 11, 0, 1)
+
+
+def test_Bitmask():
+
+    mask = mask = np.zeros((10, 10), dtype=np.bool_)
+    mask[:5, :5] = True
+
+    # groundtruth
+    gt = Bitmask(mask=mask, labels=[("k", "v")])
+
+    # prediction
+    Bitmask(
+        mask=mask,
+        labels=[("k", "v")],
+        scores=[0.7],
+    )
+
+    # test score-label matching
+    with pytest.raises(ValueError):
+        Bitmask(
+            mask=np.zeros((10, 10), dtype=np.bool_),
+            labels=[("k", "v")],
+            scores=[0.7, 0.1],
+        )
+    with pytest.raises(ValueError):
+        Bitmask(
+            mask=np.zeros((10, 10), dtype=np.bool_),
+            labels=[("k", "v1"), ("k", "v2")],
+            scores=[0.7],
+        )
+
+    # test `to_box` function
+    with pytest.raises(NotImplementedError):
+        gt.to_box()
+
+
+def test_Detection():
+
+    # groundtruth
+    gt = BoundingBox(xmin=0, xmax=1, ymin=0, ymax=1, labels=[("k", "v")])
+
+    # prediction
+    pd = BoundingBox(
+        xmin=-1,
+        xmax=11,
+        ymin=0,
+        ymax=1,
+        labels=[("k", "v")],
+        scores=[0.7],
+    )
+
+    Detection(
+        uid="uid",
+        groundtruths=[gt],
+        predictions=[pd],
+    )
+
+    # test that predictions must contain scores
+    with pytest.raises(ValueError):
+        Detection(
+            uid="uid",
+            groundtruths=[gt],
+            predictions=[gt],
+        )
diff --git a/lite/tests/detection/test_stability.py b/lite/tests/detection/test_stability.py
new file mode 100644
index 000000000..db239a194
--- /dev/null
+++ b/lite/tests/detection/test_stability.py
@@ -0,0 +1,87 @@
+from random import choice, uniform
+
+from valor_lite.detection import BoundingBox, DataLoader, Detection
+
+
+def generate_random_detections(
+    n_detections: int, n_boxes: int, labels: str
+) -> list[Detection]:
+    def bbox(is_prediction):
+        xmin, ymin = uniform(0, 10), uniform(0, 10)
+        xmax, ymax = uniform(xmin, 15), uniform(ymin, 15)
+        kw = (
+            {"scores": [uniform(0, 1), uniform(0, 1)]} if is_prediction else {}
+        )
+        return BoundingBox(
+            xmin,
+            xmax,
+            ymin,
+            ymax,
+            [("class", choice(labels)), ("category", choice(labels))],
+            **kw,
+        )
+
+    return [
+        Detection(
+            uid=f"uid{i}",
+            groundtruths=[bbox(is_prediction=False) for _ in range(n_boxes)],
+            predictions=[bbox(is_prediction=True) for _ in range(n_boxes)],
+        )
+        for i in range(n_detections)
+    ]
+
+
+def test_fuzz_detections():
+
+    few_labels = "abc"
+    many_labels = "abcdefghijklmnopqrstuvwxyz123456789"
+    quantities = [1, 5, 10]
+
+    for _ in range(100):
+
+        labels = choice([few_labels, many_labels])
+        n_detections = choice(quantities)
+        n_boxes = choice(quantities)
+
+        detections = generate_random_detections(n_detections, n_boxes, labels)
+
+        loader = DataLoader()
+        loader.add_data(detections)
+        evaluator = loader.finalize()
+        evaluator.evaluate(
+            iou_thresholds=[0.25, 0.75],
+            score_thresholds=[0.25, 0.75],
+        )
+
+
+def test_fuzz_detections_with_filtering():
+
+    few_labels = "abcd"
+    many_labels = "abcdefghijklmnopqrstuvwxyz123456789"
+    quantities = [4, 10]
+
+    for _ in range(100):
+
+        labels = choice([few_labels, many_labels])
+        n_detections = choice(quantities)
+        n_boxes = choice(quantities)
+
+        detections = generate_random_detections(n_detections, n_boxes, labels)
+
+        loader = DataLoader()
+        loader.add_data(detections)
+        evaluator = loader.finalize()
+
+        label_key = "class"
+        datum_subset = [f"uid{i}" for i in range(len(detections) // 2)]
+
+        filter_ = evaluator.create_filter(
+            datum_uids=datum_subset,
+            label_keys=[label_key],
+        )
+
+        evaluator.evaluate(
+            iou_thresholds=[0.25, 0.75],
+            score_thresholds=[0.25, 0.75],
+            filter_=filter_,
+        )
diff --git a/lite/valor_lite/__init__.py b/lite/valor_lite/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/lite/valor_lite/detection/__init__.py b/lite/valor_lite/detection/__init__.py
new file mode 100644
index 000000000..38c61ba99
--- /dev/null
+++ b/lite/valor_lite/detection/__init__.py
@@ -0,0 +1,56 @@
+from .annotation import Bitmask, BoundingBox, Detection
+from .computation import (
+    compute_detailed_pr_curve,
+    compute_iou,
+    compute_metrics,
+    compute_ranked_pairs,
+)
+from .manager import DataLoader, Evaluator
+from .metric import (
+    AP,
+    AR,
+    F1,
+    Accuracy,
+    APAveragedOverIOUs,
+    ARAveragedOverScores,
+    Counts,
+    DetailedPrecisionRecallCurve,
+    DetailedPrecisionRecallPoint,
+    MetricType,
+    Precision,
+    PrecisionRecallCurve,
+    Recall,
+    mAP,
+    mAPAveragedOverIOUs,
+    mAR,
+    mARAveragedOverScores,
+)
+
+__all__ = [
+    "Bitmask",
+    "BoundingBox",
+    "Detection",
+    "MetricType",
+    "Counts",
+    "Precision",
+    "Recall",
+    "Accuracy",
+    "F1",
+    "AP",
+    "mAP",
+    "AR",
+    "mAR",
+    "APAveragedOverIOUs",
+    "mAPAveragedOverIOUs",
+    "ARAveragedOverScores",
+    "mARAveragedOverScores",
+    "PrecisionRecallCurve",
+    "DetailedPrecisionRecallPoint",
+    "DetailedPrecisionRecallCurve",
+    "compute_iou",
+    "compute_ranked_pairs",
+    "compute_metrics",
+    "compute_detailed_pr_curve",
+    "DataLoader",
+    "Evaluator",
+]
diff --git a/lite/valor_lite/detection/annotation.py b/lite/valor_lite/detection/annotation.py
new file mode 100644
index 000000000..ca6132438
--- /dev/null
+++ b/lite/valor_lite/detection/annotation.py
@@ -0,0 +1,54 @@
+from dataclasses import dataclass, field
+
+import numpy as np
+from numpy.typing import NDArray
+
+
+@dataclass
+class BoundingBox:
+    xmin: float
+    xmax: float
+    ymin: float
+    ymax: float
+    labels: list[tuple[str, str]]
+    scores: list[float] = field(default_factory=list)
+
+    def __post_init__(self):
+        if len(self.scores) > 0 and len(self.labels) != len(self.scores):
+            raise ValueError(
+                "If scores are defined, there must be a 1:1 pairing with labels."
+            )
+
+    @property
+    def extrema(self) -> tuple[float, float, float, float]:
+        return (self.xmin, self.xmax, self.ymin, self.ymax)
+
+
+@dataclass
+class Bitmask:
+    mask: NDArray[np.bool_]
+    labels: list[tuple[str, str]]
+    scores: list[float] = field(default_factory=list)
+
+    def __post_init__(self):
+        if len(self.scores) > 0 and len(self.labels) != len(self.scores):
+            raise ValueError(
+                "If scores are defined, there must be a 1:1 pairing with labels."
+            )
+
+    def to_box(self) -> BoundingBox:
+        raise NotImplementedError
+
+
+@dataclass
+class Detection:
+    uid: str
+    groundtruths: list[BoundingBox]
+    predictions: list[BoundingBox]
+
+    def __post_init__(self):
+        for prediction in self.predictions:
+            if len(prediction.scores) != len(prediction.labels):
+                raise ValueError(
+                    "Predictions must provide a score for every label."
+                )
diff --git a/lite/valor_lite/detection/computation.py b/lite/valor_lite/detection/computation.py
new file mode 100644
index 000000000..e41dcf256
--- /dev/null
+++ b/lite/valor_lite/detection/computation.py
@@ -0,0 +1,506 @@
+import numpy as np
+from numpy.typing import NDArray
+
+# datum id  0
+# gt        1
+# pd        2
+# iou       3
+# gt label  4
+# pd label  5
+# score     6
+
+
+def compute_iou(data: NDArray[np.floating]) -> NDArray[np.floating]:
+
+    xmin1, xmax1, ymin1, ymax1 = (
+        data[:, 0],
+        data[:, 1],
+        data[:, 2],
+        data[:, 3],
+    )
+    xmin2, xmax2, ymin2, ymax2 = (
+        data[:, 4],
+        data[:, 5],
+        data[:, 6],
+        data[:, 7],
+    )
+
+    xmin = np.maximum(xmin1, xmin2)
+    ymin = np.maximum(ymin1, ymin2)
+    xmax = np.minimum(xmax1, xmax2)
+    ymax = np.minimum(ymax1, ymax2)
+
+    intersection_width = np.maximum(0, xmax - xmin)
+    intersection_height = np.maximum(0, ymax - ymin)
+    intersection_area = intersection_width * intersection_height
+
+    area1 = (xmax1 - xmin1) * (ymax1 - ymin1)
+    area2 = (xmax2 - xmin2) * (ymax2 - ymin2)
+
+    union_area = area1 + area2 - intersection_area
+
+    iou = np.zeros(data.shape[0])
+    valid_union_mask = union_area >= 1e-9
+    iou[valid_union_mask] = (
+        intersection_area[valid_union_mask] / union_area[valid_union_mask]
+    )
+    return iou
+
+
+def _compute_ranked_pairs_for_datum(
+    data: np.ndarray,
+    label_counts: np.ndarray,
+) -> np.ndarray:
+    """
+    Computes ranked pairs for a datum.
+    """
+
+    # remove null predictions
+    data = data[data[:, 2] >= 0.0]
+
+    # sort by gt_id, iou, score
+    indices = np.lexsort(
+        (
+            data[:, 1],
+            -data[:, 3],
+            -data[:, 6],
+        )
+    )
+    data = data[indices]
+
+    # remove ignored predictions
+    for label_idx, count in enumerate(label_counts[:, 0]):
+        if count > 0:
+            continue
+        data = data[data[:, 5] != label_idx]
+
+    # only keep the highest ranked pair
+    _, indices = np.unique(data[:, [0, 2, 5]], axis=0, return_index=True)
+
+    # np.unique orders its results by value, we need to sort the indices to maintain the results of the lexsort
+    data = data[indices, :]
+
+    return data
+
+
+def compute_ranked_pairs(
+    data: list[NDArray[np.floating]],
+    label_counts: NDArray[np.integer],
+) -> NDArray[np.floating]:
+    pairs = np.concatenate(
+        [
+            _compute_ranked_pairs_for_datum(
+                datum,
+                label_counts=label_counts,
+            )
+            for datum in data
+        ],
+        axis=0,
+    )
+    indices = np.lexsort(
+        (
+            -pairs[:, 3],  # iou
+            -pairs[:, 6],  # score
+        )
+    )
+    return pairs[indices]
+
+
+def compute_metrics(
+    data: np.ndarray,
+    label_counts: np.ndarray,
+    iou_thresholds: np.ndarray,
+    score_thresholds: np.ndarray,
+) -> tuple[
+    tuple[
+        NDArray[np.floating],
+        NDArray[np.floating],
+        NDArray[np.floating],
+        NDArray[np.floating],
+    ],
+    tuple[
+        NDArray[np.floating],
+        NDArray[np.floating],
+        NDArray[np.floating],
+        NDArray[np.floating],
+    ],
+    NDArray[np.floating],
+    NDArray[np.floating],
+]:
+    """
+    Computes Object Detection metrics.
+
+    Returns
+    -------
+    tuple[NDArray, NDArray, NDArray NDArray]
+        Average Precision results.
+    tuple[NDArray, NDArray, NDArray NDArray]
+        Average Recall results.
+    np.ndarray
+        Precision, Recall, TP, FP, FN, F1 Score, Accuracy.
+    np.ndarray
+        Interpolated Precision-Recall Curves.
+    """
+
+    n_rows = data.shape[0]
+    n_labels = label_counts.shape[0]
+    n_ious = iou_thresholds.shape[0]
+    n_scores = score_thresholds.shape[0]
+
+    average_precision = np.zeros((n_ious, n_labels))
+    average_recall = np.zeros((n_scores, n_labels))
+    precision_recall = np.zeros((n_ious, n_scores, n_labels, 7))
+
+    pd_labels = data[:, 5].astype(int)
+    unique_pd_labels = np.unique(pd_labels)
+    gt_count = label_counts[:, 0]
+    running_total_count = np.zeros(
+        (n_ious, n_rows),
+        dtype=np.float64,
+    )
+    running_tp_count = np.zeros_like(running_total_count)
+    running_gt_count = np.zeros_like(running_total_count)
+    pr_curve = np.zeros((n_ious, n_labels, 101))
+
+    mask_score_nonzero = data[:, 6] > 1e-9
+    mask_gt_exists = data[:, 1] >= 0.0
+    mask_labels_match = np.isclose(data[:, 4], data[:, 5])
+
+    mask_gt_exists_labels_match = mask_gt_exists & mask_labels_match
+
+    mask_tp = mask_score_nonzero & mask_gt_exists_labels_match
+    mask_fp = mask_score_nonzero
+    mask_fn = mask_gt_exists_labels_match
+
+    for iou_idx in range(n_ious):
+        mask_iou = data[:, 3] >= iou_thresholds[iou_idx]
+
+        mask_tp_outer = mask_tp & mask_iou
+        mask_fp_outer = mask_fp & (
+            (~mask_gt_exists_labels_match & mask_iou) | ~mask_iou
+        )
+        mask_fn_outer = mask_fn & mask_iou
+
+        for score_idx in range(n_scores):
+            mask_score_thresh = data[:, 6] >= score_thresholds[score_idx]
+
+            mask_tp_inner = mask_tp_outer & mask_score_thresh
+            mask_fp_inner = mask_fp_outer & mask_score_thresh
+            mask_fn_inner = mask_fn_outer & ~mask_score_thresh
+
+            # create true-positive mask score threshold
+            tp_candidates = data[mask_tp_inner]
+            _, indices_gt_unique = np.unique(
+                tp_candidates[:, [0, 1, 4]], axis=0, return_index=True
+            )
+            mask_gt_unique = np.zeros(tp_candidates.shape[0], dtype=bool)
+            mask_gt_unique[indices_gt_unique] = True
+            true_positives_mask = np.zeros(n_rows, dtype=bool)
+            true_positives_mask[mask_tp_inner] = mask_gt_unique
+
+            # calculate intermediates
+            pd_count = np.bincount(pd_labels, minlength=n_labels).astype(float)
+            tp_count = np.bincount(
+                pd_labels,
+                weights=true_positives_mask,
+                minlength=n_labels,
+            ).astype(float)
+
+            fp_count = np.bincount(
+                pd_labels[mask_fp_inner],
+                minlength=n_labels,
+            ).astype(float)
+
+            fn_count = np.bincount(
+                pd_labels[mask_fn_inner],
+                minlength=n_labels,
+            )
+
+            # calculate component metrics
+            recall = np.zeros_like(tp_count)
+            precision = np.zeros_like(tp_count)
+            np.divide(tp_count, gt_count, where=gt_count > 1e-9, out=recall)
+            np.divide(tp_count, pd_count, where=pd_count > 1e-9, out=precision)
+            fn_count = gt_count - tp_count
+
+            f1_score = np.zeros_like(precision)
+            np.divide(
+                np.multiply(precision, recall),
+                (precision + recall),
+                where=(precision + recall) > 1e-9,
+                out=f1_score,
+            )
+
+            accuracy = np.zeros_like(tp_count)
+            np.divide(
+                tp_count,
+                (gt_count + pd_count),
+                where=(gt_count + pd_count) > 1e-9,
+                out=accuracy,
+            )
+
+            precision_recall[iou_idx][score_idx] = np.concatenate(
+                (
+                    tp_count[:, np.newaxis],
+                    fp_count[:, np.newaxis],
+                    fn_count[:, np.newaxis],
+                    precision[:, np.newaxis],
+                    recall[:, np.newaxis],
+                    f1_score[:, np.newaxis],
+                    accuracy[:, np.newaxis],
+                ),
+                axis=1,
+            )
+
+            # calculate recall for AR
+            average_recall[score_idx] += recall
+
+        # create true-positive mask score threshold
+        tp_candidates = data[mask_tp_outer]
+        _, indices_gt_unique = np.unique(
+            tp_candidates[:, [0, 1, 4]], axis=0, return_index=True
+        )
+        mask_gt_unique = np.zeros(tp_candidates.shape[0], dtype=bool)
+        mask_gt_unique[indices_gt_unique] = True
+        true_positives_mask = np.zeros(n_rows, dtype=bool)
+        true_positives_mask[mask_tp_outer] = mask_gt_unique
+
+        # count running tp and total for AP
+        for pd_label in unique_pd_labels:
+            mask_pd_label = pd_labels == pd_label
+            running_gt_count[iou_idx][mask_pd_label] = gt_count[pd_label]
+            running_total_count[iou_idx][mask_pd_label] = np.arange(
+                1, mask_pd_label.sum() + 1
+            )
+            mask_tp_for_counting = mask_pd_label & true_positives_mask
+            running_tp_count[iou_idx][mask_tp_for_counting] = np.arange(
+                1, mask_tp_for_counting.sum() + 1
+            )
+
+    # calculate running precision-recall points for AP
+    precision = np.zeros_like(running_total_count)
+    np.divide(
+        running_tp_count,
+        running_total_count,
+        where=running_total_count > 1e-9,
+        out=precision,
+    )
+    recall = np.zeros_like(running_total_count)
+    np.divide(
+        running_tp_count,
+        running_gt_count,
+        where=running_gt_count > 1e-9,
+        out=recall,
+    )
+    recall_index = np.floor(recall * 100.0).astype(int)
+    for iou_idx in range(n_ious):
+        p = precision[iou_idx]
+        r = recall_index[iou_idx]
+        pr_curve[iou_idx, pd_labels, r] = np.maximum(
+            pr_curve[iou_idx, pd_labels, r], p
+        )
+
+    # calculate average precision
+    running_max = np.zeros((n_ious, n_labels))
+    for recall in range(100, -1, -1):
+        precision = pr_curve[:, :, recall]
+        running_max = np.maximum(precision, running_max)
+        average_precision += running_max
+        pr_curve[:, :, recall] = running_max
+    average_precision = average_precision / 101.0
+
+    # calculate average recall
+    average_recall /= n_ious
+
+    # calculate mAP and mAR
+    label_key_mapping = label_counts[unique_pd_labels, 2]
+    label_keys = np.unique(label_counts[:, 2])
+    mAP = np.ones((n_ious, label_keys.shape[0])) * -1.0
+    mAR = np.ones((n_scores, label_keys.shape[0])) * -1.0
+    for key in np.unique(label_key_mapping):
+        labels = unique_pd_labels[label_key_mapping == key]
+        key_idx = int(key)
+        mAP[:, key_idx] = average_precision[:, labels].mean(axis=1)
+        mAR[:, key_idx] = average_recall[:, labels].mean(axis=1)
+
+    # calculate AP and mAP averaged over iou thresholds
+    APAveragedOverIoUs = average_precision.mean(axis=0)
+    mAPAveragedOverIoUs = mAP.mean(axis=0)
+
+    # calculate AR and mAR averaged over score thresholds
+    ARAveragedOverIoUs = average_recall.mean(axis=0)
+    mARAveragedOverIoUs = mAR.mean(axis=0)
+
+    ap_results = (
+        average_precision,
+        mAP,
+        APAveragedOverIoUs,
+        mAPAveragedOverIoUs,
+    )
+    ar_results = (
+        average_recall,
+        mAR,
+        ARAveragedOverIoUs,
+        mARAveragedOverIoUs,
+    )
+
+    return (
+        ap_results,
+        ar_results,
+        precision_recall,
+        pr_curve,
+    )
+
+
+def compute_detailed_pr_curve(
+    data: np.ndarray,
+    label_counts: np.ndarray,
+    iou_thresholds: np.ndarray,
+    score_thresholds: np.ndarray,
+    n_samples: int,
+) -> np.ndarray:
+
+    """
+    0  label
+    1  tp
+    ...
+    2  fp - 1
+    3  fp - 2
+    4  fn - misclassification
+    5  fn - hallucination
+    """
+
+    n_labels = label_counts.shape[0]
+    n_ious = iou_thresholds.shape[0]
+    n_scores = score_thresholds.shape[0]
+    n_metrics = 5 * (n_samples + 1)
+
+    tp_idx = 0
+    fp_misclf_idx = tp_idx + n_samples + 1
+    fp_halluc_idx = fp_misclf_idx + n_samples + 1
+    fn_misclf_idx = fp_halluc_idx + n_samples + 1
+    fn_misprd_idx = fn_misclf_idx + n_samples + 1
+
+    detailed_pr_curve = np.ones((n_ious, n_scores, n_labels, n_metrics)) * -1.0
+
+    mask_gt_exists = data[:, 1] > -0.5
+    mask_pd_exists = data[:, 2] > -0.5
+    mask_label_match = np.isclose(data[:, 4], data[:, 5])
+
+    mask_gt_pd_exists = mask_gt_exists & mask_pd_exists
+    mask_gt_pd_match = mask_gt_pd_exists & mask_label_match
+    mask_gt_pd_mismatch = mask_gt_pd_exists & ~mask_label_match
+
+    for iou_idx in range(n_ious):
+        mask_iou = data[:, 3] >= iou_thresholds[iou_idx]
+        mask_gt_pd_match_iou = mask_gt_pd_match & mask_iou
+        mask_gt_pd_mismatch_iou = mask_gt_pd_mismatch & mask_iou
+        for score_idx in range(n_scores):
+            mask_score = data[:, 6] >= score_thresholds[score_idx]
+            mask_tp = mask_gt_pd_match_iou & mask_score
+            mask_fp_misclf = mask_gt_pd_mismatch_iou & mask_score
+            mask_fn_misclf = mask_gt_pd_match_iou & ~mask_score
+            mask_halluc_missing = ~(
+                mask_gt_pd_match_iou | (mask_gt_pd_mismatch & mask_score)
+            )
+            mask_fp_halluc = mask_halluc_missing & mask_pd_exists
+            mask_fn_misprd = mask_halluc_missing & mask_gt_exists
+
+            tp_slice = data[mask_tp]
+            fp_misclf_slice = data[mask_fp_misclf]
+            fp_halluc_slice = data[mask_fp_halluc]
+            fn_misclf_slice = data[mask_fn_misclf]
+            fn_misprd_slice = data[mask_fn_misprd]
+
+            tp_count = np.bincount(
+                tp_slice[:, 5].astype(int), minlength=n_labels
+            )
+            fp_misclf_count = np.bincount(
+                fp_misclf_slice[:, 5].astype(int), minlength=n_labels
+            )
+            fp_halluc_count = np.bincount(
+                fp_halluc_slice[:, 5].astype(int), minlength=n_labels
+            )
+            fn_misclf_count = np.bincount(
+                fn_misclf_slice[:, 4].astype(int), minlength=n_labels
+            )
+            fn_misprd_count = np.bincount(
+                fn_misprd_slice[:, 4].astype(int), minlength=n_labels
+            )
+
+            detailed_pr_curve[iou_idx, score_idx, :, tp_idx] = tp_count
+            detailed_pr_curve[
+                iou_idx, score_idx, :, fp_misclf_idx
+            ] = fp_misclf_count
+            detailed_pr_curve[
+                iou_idx, score_idx, :, fp_halluc_idx
+            ] = fp_halluc_count
+            detailed_pr_curve[
+                iou_idx, score_idx, :, fn_misclf_idx
+            ] = fn_misclf_count
+            detailed_pr_curve[
+                iou_idx, score_idx, :, fn_misprd_idx
+            ] = fn_misprd_count
+
+            if n_samples > 0:
+                for label_idx in range(n_labels):
+                    tp_examples = tp_slice[
+                        tp_slice[:, 5].astype(int) == label_idx
+                    ][:n_samples, 0]
+                    fp_misclf_examples = fp_misclf_slice[
+                        fp_misclf_slice[:, 5].astype(int) == label_idx
+                    ][:n_samples, 0]
+                    fp_halluc_examples = fp_halluc_slice[
+                        fp_halluc_slice[:, 5].astype(int) == label_idx
+                    ][:n_samples, 0]
+                    fn_misclf_examples = fn_misclf_slice[
+                        fn_misclf_slice[:, 4].astype(int) == label_idx
+                    ][:n_samples, 0]
+                    fn_misprd_examples = fn_misprd_slice[
+                        fn_misprd_slice[:, 4].astype(int) == label_idx
+                    ][:n_samples, 0]
+
+                    detailed_pr_curve[
+                        iou_idx,
+                        score_idx,
+                        label_idx,
+                        tp_idx + 1 : tp_idx + 1 + tp_examples.shape[0],
+                    ] = tp_examples
+                    detailed_pr_curve[
+                        iou_idx,
+                        score_idx,
+                        label_idx,
+                        fp_misclf_idx
+                        + 1 : fp_misclf_idx
+                        + 1
+                        + fp_misclf_examples.shape[0],
+                    ] = fp_misclf_examples
+                    detailed_pr_curve[
+                        iou_idx,
+                        score_idx,
+                        label_idx,
+                        fp_halluc_idx
+                        + 1 : fp_halluc_idx
+                        + 1
+                        + fp_halluc_examples.shape[0],
+                    ] = fp_halluc_examples
+                    detailed_pr_curve[
+                        iou_idx,
+                        score_idx,
+                        label_idx,
+                        fn_misclf_idx
+                        + 1 : fn_misclf_idx
+                        + 1
+                        + fn_misclf_examples.shape[0],
+                    ] = fn_misclf_examples
+                    detailed_pr_curve[
+                        iou_idx,
+                        score_idx,
+                        label_idx,
+                        fn_misprd_idx
+                        + 1 : fn_misprd_idx
+                        + 1
+                        + fn_misprd_examples.shape[0],
+                    ] = fn_misprd_examples
+
+    return detailed_pr_curve
diff --git a/lite/valor_lite/detection/manager.py b/lite/valor_lite/detection/manager.py
new file mode 100644
index 000000000..c05c89d26
--- /dev/null
+++ b/lite/valor_lite/detection/manager.py
@@ -0,0 +1,845 @@
+from collections import defaultdict
+from dataclasses import dataclass
+
+import numpy as np
+from numpy.typing import NDArray
+from tqdm import tqdm
+from valor_lite.detection.annotation import Detection
+from valor_lite.detection.computation import (
+    compute_detailed_pr_curve,
+    compute_iou,
+    compute_metrics,
+    compute_ranked_pairs,
+)
+from valor_lite.detection.metric import (
+    AP,
+    AR,
+    F1,
+    Accuracy,
+    APAveragedOverIOUs,
+    ARAveragedOverScores,
+    Counts,
+    DetailedPrecisionRecallCurve,
+    DetailedPrecisionRecallPoint,
+    MetricType,
+    Precision,
+    PrecisionRecallCurve,
+    Recall,
+    mAP,
+    mAPAveragedOverIOUs,
+    mAR,
+    mARAveragedOverScores,
+)
+
+"""
+Usage
+-----
+
+manager = DataLoader()
+manager.add_data(
+    groundtruths=groundtruths,
+    predictions=predictions,
+)
+evaluator = manager.finalize()
+
+metrics = evaluator.evaluate(iou_thresholds=[0.5])
+
+ap_metrics = metrics[MetricType.AP]
+ar_metrics = metrics[MetricType.AR]
+
+filter_mask = evaluator.create_filter(datum_uids=["uid1", "uid2"])
+filtered_metrics = evaluator.evaluate(iou_thresholds=[0.5], filter_mask=filter_mask)
+"""
+
+
+@dataclass
+class Filter:
+    indices: NDArray[np.int32]
+    label_metadata: NDArray[np.int32]
+
+
+class Evaluator:
+    def __init__(self):
+
+        # metadata
+        self.n_datums = 0
+        self.n_groundtruths = 0
+        self.n_predictions = 0
+        self.n_labels = 0
+
+        # datum reference
+        self.uid_to_index: dict[str, int] = dict()
+        self.index_to_uid: dict[int, str] = dict()
+
+        # label reference
+        self.label_to_index: dict[tuple[str, str], int] = dict()
+        self.index_to_label: dict[int, tuple[str, str]] = dict()
+
+        # label key reference
+        self.index_to_label_key: dict[int, str] = dict()
+        self.label_key_to_index: dict[str, int] = dict()
+        self.label_index_to_label_key_index: dict[int, int] = dict()
+
+        # computation caches
+        self._detailed_pairs = np.array([])
+        self._ranked_pairs = np.array([])
+        self._label_metadata = np.array([])
+        self._label_metadata_per_datum = np.array([])
+
+    @property
+    def ignored_prediction_labels(self) -> list[tuple[str, str]]:
+        glabels = set(np.where(self._label_metadata[:, 0] > 0)[0])
+        plabels = set(np.where(self._label_metadata[:, 1] > 0)[0])
+        return [
+            self.index_to_label[label_id] for label_id in (plabels - glabels)
+        ]
+
+    @property
+    def missing_prediction_labels(self) -> list[tuple[str, str]]:
+        glabels = set(np.where(self._label_metadata[:, 0] > 0)[0])
+        plabels = set(np.where(self._label_metadata[:, 1] > 0)[0])
+        return [
+            self.index_to_label[label_id] for label_id in (glabels - plabels)
+        ]
+
+    @property
+    def metadata(self) -> dict:
+        return {
+            "n_datums": self.n_datums,
+            "n_groundtruths": self.n_groundtruths,
+            "n_predictions": self.n_predictions,
+            "n_labels": self.n_labels,
+            "ignored_prediction_labels": self.ignored_prediction_labels,
+            "missing_prediction_labels": self.missing_prediction_labels,
+        }
+
+    def create_filter(
+        self,
+        datum_uids: list[str] | NDArray[np.int32] | None = None,
+        labels: list[tuple[str, str]] | NDArray[np.int32] | None = None,
+        label_keys: list[str] | NDArray[np.int32] | None = None,
+    ) -> Filter:
+        """
+        Creates a boolean mask that can be passed to an evaluation.
+
+        Parameters
+        ----------
+        datum_uids : list[str] | NDArray[np.int32], optional
+            An optional list of string uids or a numpy array of uid indices.
+        labels : list[tuple[str, str]] | NDArray[np.int32], optional
+            An optional list of labels or a numpy array of label indices.
+        label_keys : list[str] | NDArray[np.int32], optional
+            An optional list of label keys or a numpy array of label key indices.
+
+        Returns
+        -------
+        Filter
+            A filter object that can be passed to the `evaluate` method.
+        """
+        n_rows = self._ranked_pairs.shape[0]
+
+        n_datums = self._label_metadata_per_datum.shape[1]
+        n_labels = self._label_metadata_per_datum.shape[2]
+
+        mask_pairs = np.ones((n_rows, 1), dtype=np.bool_)
+        mask_datums = np.ones(n_datums, dtype=np.bool_)
+        mask_labels = np.ones(n_labels, dtype=np.bool_)
+
+        if datum_uids is not None:
+            if isinstance(datum_uids, list):
+                datum_uids = np.array(
+                    [self.uid_to_index[uid] for uid in datum_uids],
+                    dtype=np.int32,
+                )
+            mask = np.zeros_like(mask_pairs, dtype=np.bool_)
+            mask[
+                np.isin(self._ranked_pairs[:, 0].astype(int), datum_uids)
+            ] = True
+            mask_pairs &= mask
+
+            mask = np.zeros_like(mask_datums, dtype=np.bool_)
+            mask[datum_uids] = True
+            mask_datums &= mask
+
+        if labels is not None:
+            if isinstance(labels, list):
+                labels = np.array(
+                    [self.label_to_index[label] for label in labels]
+                )
+            mask = np.zeros_like(mask_pairs, dtype=np.bool_)
+            mask[np.isin(self._ranked_pairs[:, 4].astype(int), labels)] = True
+            mask_pairs &= mask
+
+            mask = np.zeros_like(mask_labels, dtype=np.bool_)
+            mask[labels] = True
+            mask_labels &= mask
+
+        if label_keys is not None:
+            if isinstance(label_keys, list):
+                label_keys = np.array(
+                    [self.label_key_to_index[key] for key in label_keys]
+                )
+            label_indices = np.where(
+                np.isclose(self._label_metadata[:, 2], label_keys)
+            )[0]
+            mask = np.zeros_like(mask_pairs, dtype=np.bool_)
+            mask[
+                np.isin(self._ranked_pairs[:, 4].astype(int), label_indices)
+            ] = True
+            mask_pairs &= mask
+
+            mask = np.zeros_like(mask_labels, dtype=np.bool_)
+            mask[label_indices] = True
+            mask_labels &= mask
+
+        mask = mask_datums[:, np.newaxis] & mask_labels[np.newaxis, :]
+        label_metadata_per_datum = self._label_metadata_per_datum.copy()
+        label_metadata_per_datum[:, ~mask] = 0
+
+        label_metadata = np.zeros_like(self._label_metadata, dtype=np.int32)
+        label_metadata[:, :2] = np.transpose(
+            np.sum(
+                label_metadata_per_datum,
+                axis=1,
+            )
+        )
+        label_metadata[:, 2] = self._label_metadata[:, 2]
+
+        return Filter(
+            indices=np.where(mask_pairs)[0],
+            label_metadata=label_metadata,
+            # uids=datum_uids,
+            # labels=labels,
+            # label_keys=label_keys,
+        )
+
+    def evaluate(
+        self,
+        iou_thresholds: list[float] = [0.5, 0.75, 0.9],
+        score_thresholds: list[float] = [0.5],
+        filter_: Filter | None = None,
+    ) -> dict[MetricType, list]:
+        """
+        Runs evaluation over cached data.
+
+        Parameters
+        ----------
+        iou_thresholds : list[float]
+            A list of iou thresholds to compute over.
+        score_thresholds : list[float]
+            A list of score thresholds to compute over.
+        filter_mask : NDArray[bool], optional
+            A boolean mask that filters the cached data.
+        """
+
+        data = self._ranked_pairs
+        label_metadata = self._label_metadata
+        if filter_ is not None:
+            data = data[filter_.indices]
+            label_metadata = filter_.label_metadata
+
+        (
+            (
+                average_precision,
+                mean_average_precision,
+                average_precision_average_over_ious,
+                mean_average_precision_average_over_ious,
+            ),
+            (
+                average_recall,
+                mean_average_recall,
+                average_recall_averaged_over_scores,
+                mean_average_recall_averaged_over_scores,
+            ),
+            precision_recall,
+            pr_curves,
+        ) = compute_metrics(
+            data=data,
+            label_counts=label_metadata,
+            iou_thresholds=np.array(iou_thresholds),
+            score_thresholds=np.array(score_thresholds),
+        )
+
+        metrics = defaultdict(list)
+
+        metrics[MetricType.AP] = [
+            AP(
+                value=average_precision[iou_idx][label_idx],
+                iou=iou_thresholds[iou_idx],
+                label=self.index_to_label[label_idx],
+            )
+            for iou_idx in range(average_precision.shape[0])
+            for label_idx in range(average_precision.shape[1])
+            if int(label_metadata[label_idx][0]) > 0
+        ]
+
+        metrics[MetricType.mAP] = [
+            mAP(
+                value=mean_average_precision[iou_idx][label_key_idx],
+                iou=iou_thresholds[iou_idx],
+                label_key=self.index_to_label_key[label_key_idx],
+            )
+            for iou_idx in range(mean_average_precision.shape[0])
+            for label_key_idx in range(mean_average_precision.shape[1])
+        ]
+
+        metrics[MetricType.APAveragedOverIOUs] = [
+            APAveragedOverIOUs(
+                value=average_precision_average_over_ious[label_idx],
+                ious=iou_thresholds,
+                label=self.index_to_label[label_idx],
+            )
+            for label_idx in range(self.n_labels)
+            if int(label_metadata[label_idx][0]) > 0
+        ]
+
+        metrics[MetricType.mAPAveragedOverIOUs] = [
+            mAPAveragedOverIOUs(
+                value=mean_average_precision_average_over_ious[label_key_idx],
+                ious=iou_thresholds,
+                label_key=self.index_to_label_key[label_key_idx],
+            )
+            for label_key_idx in range(
+                mean_average_precision_average_over_ious.shape[0]
+            )
+        ]
+
+        metrics[MetricType.AR] = [
+            AR(
+                value=average_recall[score_idx][label_idx],
+                ious=iou_thresholds,
+                score=score_thresholds[score_idx],
+                label=self.index_to_label[label_idx],
+            )
+            for score_idx in range(average_recall.shape[0])
+            for label_idx in range(average_recall.shape[1])
+            if int(label_metadata[label_idx][0]) > 0
+        ]
+
+        metrics[MetricType.mAR] = [
+            mAR(
+                value=mean_average_recall[score_idx][label_key_idx],
+                ious=iou_thresholds,
+                score=score_thresholds[score_idx],
+                label_key=self.index_to_label_key[label_key_idx],
+            )
+            for score_idx in range(mean_average_recall.shape[0])
+            for label_key_idx in range(mean_average_recall.shape[1])
+        ]
+
+        metrics[MetricType.ARAveragedOverScores] = [
+            ARAveragedOverScores(
+                value=average_recall_averaged_over_scores[label_idx],
+                scores=score_thresholds,
+                ious=iou_thresholds,
+                label=self.index_to_label[label_idx],
+            )
+            for label_idx in range(self.n_labels)
+            if int(label_metadata[label_idx][0]) > 0
+        ]
+
+        metrics[MetricType.mARAveragedOverScores] = [
+            mARAveragedOverScores(
+                value=mean_average_recall_averaged_over_scores[label_key_idx],
+                scores=score_thresholds,
+                ious=iou_thresholds,
+                label_key=self.index_to_label_key[label_key_idx],
+            )
+            for label_key_idx in range(
+                mean_average_recall_averaged_over_scores.shape[0]
+            )
+        ]
+
+        metrics[MetricType.PrecisionRecallCurve] = [
+            PrecisionRecallCurve(
+                precision=list(pr_curves[iou_idx][label_idx]),
+                iou=iou_threshold,
+                label=label,
+            )
+            for iou_idx, iou_threshold in enumerate(iou_thresholds)
+            for label_idx, label in self.index_to_label.items()
+            if int(label_metadata[label_idx][0]) > 0
+        ]
+
+        for iou_idx, iou_threshold in enumerate(iou_thresholds):
+            for score_idx, score_threshold in enumerate(score_thresholds):
+                for label_idx, label in self.index_to_label.items():
+                    row = precision_recall[iou_idx][score_idx][label_idx]
+                    kwargs = {
+                        "label": label,
+                        "iou": iou_threshold,
+                        "score": score_threshold,
+                    }
+                    metrics[MetricType.Counts].append(
+                        Counts(
+                            tp=int(row[0]),
+                            fp=int(row[1]),
+                            fn=int(row[2]),
+                            **kwargs,
+                        )
+                    )
+                    metrics[MetricType.Precision].append(
+                        Precision(
+                            value=row[3],
+                            **kwargs,
+                        )
+                    )
+                    metrics[MetricType.Recall].append(
+                        Recall(
+                            value=row[4],
+                            **kwargs,
+                        )
+                    )
+                    metrics[MetricType.F1].append(
+                        F1(
+                            value=row[5],
+                            **kwargs,
+                        )
+                    )
+                    metrics[MetricType.Accuracy].append(
+                        Accuracy(
+                            value=row[6],
+                            **kwargs,
+                        )
+                    )
+
+        return metrics
+
+    def compute_detailed_pr_curve(
+        self,
+        iou_thresholds: list[float] = [0.5],
+        score_thresholds: list[float] = [
+            score / 10.0 for score in range(1, 11)
+        ],
+        n_samples: int = 0,
+    ) -> list[DetailedPrecisionRecallCurve]:
+
+        if self._detailed_pairs.size == 0:
+            return list()
+
+        metrics = compute_detailed_pr_curve(
+            self._detailed_pairs,
+            label_counts=self._label_metadata,
+            iou_thresholds=np.array(iou_thresholds),
+            score_thresholds=np.array(score_thresholds),
+            n_samples=n_samples,
+        )
+
+        tp_idx = 0
+        fp_misclf_idx = tp_idx + n_samples + 1
+        fp_halluc_idx = fp_misclf_idx + n_samples + 1
+        fn_misclf_idx = fp_halluc_idx + n_samples + 1
+        fn_misprd_idx = fn_misclf_idx + n_samples + 1
+
+        results = list()
+        for label_idx in range(len(metrics)):
+            n_ious, n_scores, _, _ = metrics.shape
+            for iou_idx in range(n_ious):
+                curve = DetailedPrecisionRecallCurve(
+                    iou=iou_thresholds[iou_idx],
+                    value=list(),
+                    label=self.index_to_label[label_idx],
+                )
+                for score_idx in range(n_scores):
+                    curve.value.append(
+                        DetailedPrecisionRecallPoint(
+                            score=score_thresholds[score_idx],
+                            tp=metrics[iou_idx][score_idx][label_idx][tp_idx],
+                            tp_examples=[
+                                self.index_to_uid[int(datum_idx)]
+                                for datum_idx in metrics[iou_idx][score_idx][
+                                    label_idx
+                                ][tp_idx + 1 : fp_misclf_idx]
+                                if int(datum_idx) >= 0
+                            ],
+                            fp_misclassification=metrics[iou_idx][score_idx][
+                                label_idx
+                            ][fp_misclf_idx],
+                            fp_misclassification_examples=[
+                                self.index_to_uid[int(datum_idx)]
+                                for datum_idx in metrics[iou_idx][score_idx][
+                                    label_idx
+                                ][fp_misclf_idx + 1 : fp_halluc_idx]
+                                if int(datum_idx) >= 0
+                            ],
+                            fp_hallucination=metrics[iou_idx][score_idx][
+                                label_idx
+                            ][fp_halluc_idx],
+                            fp_hallucination_examples=[
+                                self.index_to_uid[int(datum_idx)]
+                                for datum_idx in metrics[iou_idx][score_idx][
+                                    label_idx
+                                ][fp_halluc_idx + 1 : fn_misclf_idx]
+                                if int(datum_idx) >= 0
+                            ],
+                            fn_misclassification=metrics[iou_idx][score_idx][
+                                label_idx
+                            ][fn_misclf_idx],
+                            fn_misclassification_examples=[
+                                self.index_to_uid[int(datum_idx)]
+                                for datum_idx in metrics[iou_idx][score_idx][
+                                    label_idx
+                                ][fn_misclf_idx + 1 : fn_misprd_idx]
+                                if int(datum_idx) >= 0
+                            ],
+                            fn_missing_prediction=metrics[iou_idx][score_idx][
+                                label_idx
+                            ][fn_misprd_idx],
+                            fn_missing_prediction_examples=[
+                                self.index_to_uid[int(datum_idx)]
+                                for datum_idx in metrics[iou_idx][score_idx][
+                                    label_idx
+                                ][fn_misprd_idx + 1 :]
+                                if int(datum_idx) >= 0
+                            ],
+                        )
+                    )
+                results.append(curve)
+        return results
+
+
+class DataLoader:
+    def __init__(self):
+        self._evaluator = Evaluator()
+        self.pairs = list()
+        self.groundtruth_count = defaultdict(lambda: defaultdict(int))
+        self.prediction_count = defaultdict(lambda: defaultdict(int))
+
+    def _add_datum(self, uid: str) -> int:
+        if uid not in self._evaluator.uid_to_index:
+            index = len(self._evaluator.uid_to_index)
+            self._evaluator.uid_to_index[uid] = index
+            self._evaluator.index_to_uid[index] = uid
+        return self._evaluator.uid_to_index[uid]
+
+    def _add_label(self, label: tuple[str, str]) -> tuple[int, int]:
+        label_id = len(self._evaluator.index_to_label)
+        label_key_id = len(self._evaluator.index_to_label_key)
+        if label not in self._evaluator.label_to_index:
+            self._evaluator.label_to_index[label] = label_id
+            self._evaluator.index_to_label[label_id] = label
+
+            # update label key index
+            if label[0] not in self._evaluator.label_key_to_index:
+                self._evaluator.label_key_to_index[label[0]] = label_key_id
+                self._evaluator.index_to_label_key[label_key_id] = label[0]
+                label_key_id += 1
+
+            self._evaluator.label_index_to_label_key_index[
+                label_id
+            ] = self._evaluator.label_key_to_index[label[0]]
+            label_id += 1
+
+        return (
+            self._evaluator.label_to_index[label],
+            self._evaluator.label_key_to_index[label[0]],
+        )
+
+    def add_data(
+        self,
+        detections: list[Detection],
+        show_progress: bool = False,
+    ):
+        disable_tqdm = not show_progress
+        for detection in tqdm(detections, disable=disable_tqdm):
+
+            # update metadata
+            self._evaluator.n_datums += 1
+            self._evaluator.n_groundtruths += len(detection.groundtruths)
+            self._evaluator.n_predictions += len(detection.predictions)
+
+            # update datum uid index
+            uid_index = self._add_datum(uid=detection.uid)
+
+            # cache labels and annotations
+            keyed_groundtruths = defaultdict(list)
+            keyed_predictions = defaultdict(list)
+            for gidx, gann in enumerate(detection.groundtruths):
+                for glabel in gann.labels:
+                    label_idx, label_key_idx = self._add_label(glabel)
+                    self.groundtruth_count[label_idx][uid_index] += 1
+                    keyed_groundtruths[label_key_idx].append(
+                        (
+                            gidx,
+                            label_idx,
+                            gann.extrema,
+                        )
+                    )
+            for pidx, pann in enumerate(detection.predictions):
+                for plabel, pscore in zip(pann.labels, pann.scores):
+                    label_idx, label_key_idx = self._add_label(plabel)
+                    self.prediction_count[label_idx][uid_index] += 1
+                    keyed_predictions[label_key_idx].append(
+                        (
+                            pidx,
+                            label_idx,
+                            pscore,
+                            pann.extrema,
+                        )
+                    )
+
+            gt_keys = set(keyed_groundtruths.keys())
+            pd_keys = set(keyed_predictions.keys())
+            joint_keys = gt_keys.intersection(pd_keys)
+            gt_unique_keys = gt_keys - pd_keys
+            pd_unique_keys = pd_keys - gt_keys
+
+            pairs = list()
+            for key in joint_keys:
+                boxes = np.array(
+                    [
+                        np.array([*gextrema, *pextrema])
+                        for _, _, _, pextrema in keyed_predictions[key]
+                        for _, _, gextrema in keyed_groundtruths[key]
+                    ]
+                )
+                ious = compute_iou(boxes)
+                pairs.extend(
+                    [
+                        np.array(
+                            [
+                                float(uid_index),
+                                float(gidx),
+                                float(pidx),
+                                ious[
+                                    pidx * len(keyed_groundtruths[key]) + gidx
+                                ],
+                                float(glabel),
+                                float(plabel),
+                                float(score),
+                            ]
+                        )
+                        for pidx, plabel, score, _ in keyed_predictions[key]
+                        for gidx, glabel, _ in keyed_groundtruths[key]
+                    ]
+                )
+            for key in gt_unique_keys:
+                pairs.extend(
+                    [
+                        np.array(
+                            [
+                                float(uid_index),
+                                float(gidx),
+                                -1.0,
+                                0.0,
+                                float(glabel),
+                                -1.0,
+                                -1.0,
+                            ]
+                        )
+                        for gidx, glabel, _ in keyed_groundtruths[key]
+                    ]
+                )
+            for key in pd_unique_keys:
+                pairs.extend(
+                    [
+                        np.array(
+                            [
+                                float(uid_index),
+                                -1.0,
+                                float(pidx),
+                                0.0,
+                                -1.0,
+                                float(plabel),
+                                float(score),
+                            ]
+                        )
+                        for pidx, plabel, score, _ in keyed_predictions[key]
+                    ]
+                )
+
+            self.pairs.append(np.array(pairs))
+
+    def add_data_from_valor_dict(
+        self,
+        detections: list[tuple[dict, dict]],
+        show_progress: bool = False,
+    ):
+        def _get_bbox_extrema(
+            data: list[list[list[float]]],
+        ) -> tuple[float, float, float, float]:
+            x = [point[0] for shape in data for point in shape]
+            y = [point[1] for shape in data for point in shape]
+            return (min(x), max(x), min(y), max(y))
+
+        disable_tqdm = not show_progress
+        for groundtruth, prediction in tqdm(detections, disable=disable_tqdm):
+
+            # update metadata
+            self._evaluator.n_datums += 1
+            self._evaluator.n_groundtruths += len(groundtruth["annotations"])
+            self._evaluator.n_predictions += len(prediction["annotations"])
+
+            # update datum uid index
+            uid_index = self._add_datum(uid=groundtruth["datum"]["uid"])
+
+            # cache labels and annotations
+            keyed_groundtruths = defaultdict(list)
+            keyed_predictions = defaultdict(list)
+            for gidx, gann in enumerate(groundtruth["annotations"]):
+                for valor_label in gann["labels"]:
+                    glabel = (valor_label["key"], valor_label["value"])
+                    label_idx, label_key_idx = self._add_label(glabel)
+                    self.groundtruth_count[label_idx][uid_index] += 1
+                    keyed_groundtruths[label_key_idx].append(
+                        (
+                            gidx,
+                            label_idx,
+                            _get_bbox_extrema(gann["bounding_box"]),
+                        )
+                    )
+            for pidx, pann in enumerate(prediction["annotations"]):
+                for valor_label in pann["labels"]:
+                    plabel = (valor_label["key"], valor_label["value"])
+                    pscore = valor_label["score"]
+                    label_idx, label_key_idx = self._add_label(plabel)
+                    self.prediction_count[label_idx][uid_index] += 1
+                    keyed_predictions[label_key_idx].append(
+                        (
+                            pidx,
+                            label_idx,
+                            pscore,
+                            _get_bbox_extrema(pann["bounding_box"]),
+                        )
+                    )
+
+            gt_keys = set(keyed_groundtruths.keys())
+            pd_keys = set(keyed_predictions.keys())
+            joint_keys = gt_keys.intersection(pd_keys)
+            gt_unique_keys = gt_keys - pd_keys
+            pd_unique_keys = pd_keys - gt_keys
+
+            pairs = list()
+            for key in joint_keys:
+                boxes = np.array(
+                    [
+                        np.array([*gextrema, *pextrema])
+                        for _, _, _, pextrema in keyed_predictions[key]
+                        for _, _, gextrema in keyed_groundtruths[key]
+                    ]
+                )
+                ious = compute_iou(boxes)
+                pairs.extend(
+                    [
+                        np.array(
+                            [
+                                float(uid_index),
+                                float(gidx),
+                                float(pidx),
+                                ious[
+                                    pidx * len(keyed_groundtruths[key]) + gidx
+                                ],
+                                float(glabel),
+                                float(plabel),
+                                float(score),
+                            ]
+                        )
+                        for pidx, plabel, score, _ in keyed_predictions[key]
+                        for gidx, glabel, _ in keyed_groundtruths[key]
+                    ]
+                )
+            for key in gt_unique_keys:
+                pairs.extend(
+                    [
+                        np.array(
+                            [
+                                float(uid_index),
+                                float(gidx),
+                                -1.0,
+                                0.0,
+                                float(glabel),
+                                -1.0,
+                                -1.0,
+                            ]
+                        )
+                        for gidx, glabel, _ in keyed_groundtruths[key]
+                    ]
+                )
+            for key in pd_unique_keys:
+                pairs.extend(
+                    [
+                        np.array(
+                            [
+                                float(uid_index),
+                                -1.0,
+                                float(pidx),
+                                0.0,
+                                -1.0,
+                                float(plabel),
+                                float(score),
+                            ]
+                        )
+                        for pidx, plabel, score, _ in keyed_predictions[key]
+                    ]
+                )
+
+            self.pairs.append(np.array(pairs))
+
+    def finalize(self) -> Evaluator:
+
+        self.pairs = [pair for pair in self.pairs if pair.size > 0]
+        if len(self.pairs) == 0:
+            raise ValueError("No data available to create evaluator.")
+
+        n_datums = self._evaluator.n_datums
+        n_labels = len(self._evaluator.index_to_label)
+
+        self._evaluator.n_labels = n_labels
+
+        self._evaluator._label_metadata_per_datum = np.zeros(
+            (2, n_datums, n_labels), dtype=np.int32
+        )
+        for datum_idx in range(n_datums):
+            for label_idx in range(n_labels):
+                gt_count = (
+                    self.groundtruth_count[label_idx].get(datum_idx, 0)
+                    if label_idx in self.groundtruth_count
+                    else 0
+                )
+                pd_count = (
+                    self.prediction_count[label_idx].get(datum_idx, 0)
+                    if label_idx in self.prediction_count
+                    else 0
+                )
+                self._evaluator._label_metadata_per_datum[
+                    :, datum_idx, label_idx
+                ] = np.array([gt_count, pd_count])
+
+        self._evaluator._label_metadata = np.array(
+            [
+                [
+                    float(
+                        np.sum(
+                            self._evaluator._label_metadata_per_datum[
+                                0, :, label_idx
+                            ]
+                        )
+                    ),
+                    float(
+                        np.sum(
+                            self._evaluator._label_metadata_per_datum[
+                                1, :, label_idx
+                            ]
+                        )
+                    ),
+                    float(
+                        self._evaluator.label_index_to_label_key_index[
+                            label_idx
+                        ]
+                    ),
+                ]
+                for label_idx in range(n_labels)
+            ]
+        )
+
+        self._evaluator._detailed_pairs = np.concatenate(
+            self.pairs,
+            axis=0,
+        )
+
+        self._evaluator._ranked_pairs = compute_ranked_pairs(
+            self.pairs,
+            label_counts=self._evaluator._label_metadata,
+        )
+
+        return self._evaluator
diff --git a/lite/valor_lite/detection/metric.py b/lite/valor_lite/detection/metric.py
new file mode 100644
index 000000000..90c2baf81
--- /dev/null
+++ b/lite/valor_lite/detection/metric.py
@@ -0,0 +1,357 @@
+from dataclasses import dataclass
+from enum import Enum
+
+from valor_lite.schemas import Metric
+
+
+class MetricType(str, Enum):
+    Counts = "Counts"
+    Accuracy = "Accuracy"
+    Precision = "Precision"
+    Recall = "Recall"
+    F1 = "F1"
+    AP = "AP"
+    AR = "AR"
+    mAP = "mAP"
+    mAR = "mAR"
+    APAveragedOverIOUs = "APAveragedOverIOUs"
+    mAPAveragedOverIOUs = "mAPAveragedOverIOUs"
+    ARAveragedOverScores = "ARAveragedOverScores"
+    mARAveragedOverScores = "mARAveragedOverScores"
+    PrecisionRecallCurve = "PrecisionRecallCurve"
+    DetailedPrecisionRecallCurve = "DetailedPrecisionRecallCurve"
+
+
+@dataclass
+class Counts:
+    tp: int
+    fp: int
+    fn: int
+    label: tuple[str, str]
+    iou: float
+    score: float
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value={
+                "tp": self.tp,
+                "fp": self.fp,
+                "fn": self.fn,
+            },
+            parameters={
+                "iou": self.iou,
+                "score": self.score,
+                "label": {
+                    "key": self.label[0],
+                    "value": self.label[1],
+                },
+            },
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()
+
+
+@dataclass
+class ClassMetric:
+    value: float
+    label: tuple[str, str]
+    iou: float
+    score: float
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value=self.value,
+            parameters={
+                "iou": self.iou,
+                "score": self.score,
+                "label": {
+                    "key": self.label[0],
+                    "value": self.label[1],
+                },
+            },
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()
+
+
+class Precision(ClassMetric):
+    pass
+
+
+class Recall(ClassMetric):
+    pass
+
+
+class Accuracy(ClassMetric):
+    pass
+
+
+class F1(ClassMetric):
+    pass
+
+
+@dataclass
+class AP:
+    value: float
+    iou: float
+    label: tuple[str, str]
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value=self.value,
+            parameters={
+                "iou": self.iou,
+                "label": {
+                    "key": self.label[0],
+                    "value": self.label[1],
+                },
+            },
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()
+
+
+@dataclass
+class mAP:
+    value: float
+    iou: float
+    label_key: str
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value=self.value,
+            parameters={
+                "iou": self.iou,
+                "label_key": self.label_key,
+            },
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()
+
+
+@dataclass
+class APAveragedOverIOUs:
+    value: float
+    ious: list[float]
+    label: tuple[str, str]
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value=self.value,
+            parameters={
+                "ious": self.ious,
+                "label": {
+                    "key": self.label[0],
+                    "value": self.label[1],
+                },
+            },
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()
+
+
+@dataclass
+class mAPAveragedOverIOUs:
+    value: float
+    ious: list[float]
+    label_key: str
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value=self.value,
+            parameters={
+                "ious": self.ious,
+                "label_key": self.label_key,
+            },
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()
+
+
+@dataclass
+class AR:
+    value: float
+    score: float
+    ious: list[float]
+    label: tuple[str, str]
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value=self.value,
+            parameters={
+                "score": self.score,
+                "ious": self.ious,
+                "label": {
+                    "key": self.label[0],
+                    "value": self.label[1],
+                },
+            },
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()
+
+
+@dataclass
+class mAR:
+    value: float
+    score: float
+    ious: list[float]
+    label_key: str
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value=self.value,
+            parameters={
+                "score": self.score,
+                "ious": self.ious,
+                "label_key": self.label_key,
+            },
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()
+
+
+@dataclass
+class ARAveragedOverScores:
+    value: float
+    scores: list[float]
+    ious: list[float]
+    label: tuple[str, str]
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value=self.value,
+            parameters={
+                "scores": self.scores,
+                "ious": self.ious,
+                "label": {
+                    "key": self.label[0],
+                    "value": self.label[1],
+                },
+            },
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()
+
+
+@dataclass
+class mARAveragedOverScores:
+    value: float
+    scores: list[float]
+    ious: list[float]
+    label_key: str
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value=self.value,
+            parameters={
+                "scores": self.scores,
+                "ious": self.ious,
+                "label_key": self.label_key,
+            },
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()
+
+
+@dataclass
+class PrecisionRecallCurve:
+    """
+    Interpolated over recalls 0.0, 0.01, ..., 1.0.
+    """
+
+    precision: list[float]
+    iou: float
+    label: tuple[str, str]
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value=self.precision,
+            parameters={
+                "iou": self.iou,
+                "label": {"key": self.label[0], "value": self.label[1]},
+            },
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()
+
+
+@dataclass
+class DetailedPrecisionRecallPoint:
+    score: float
+    tp: int
+    fp_misclassification: int
+    fp_hallucination: int
+    fn_misclassification: int
+    fn_missing_prediction: int
+    tp_examples: list[str]
+    fp_misclassification_examples: list[str]
+    fp_hallucination_examples: list[str]
+    fn_misclassification_examples: list[str]
+    fn_missing_prediction_examples: list[str]
+
+    def to_dict(self) -> dict:
+        return {
+            "score": self.score,
+            "tp": self.tp,
+            "fp_misclassification": self.fp_misclassification,
+            "fp_hallucination": self.fp_hallucination,
+            "fn_misclassification": self.fn_misclassification,
+            "fn_missing_prediction": self.fn_missing_prediction,
+            "tp_examples": self.tp_examples,
+            "fp_misclassification_examples": self.fp_misclassification_examples,
+            "fp_hallucination_examples": self.fp_hallucination_examples,
+            "fn_misclassification_examples": self.fn_misclassification_examples,
+            "fn_missing_prediction_examples": self.fn_missing_prediction_examples,
+        }
+
+
+@dataclass
+class DetailedPrecisionRecallCurve:
+    iou: float
+    value: list[DetailedPrecisionRecallPoint]
+    label: tuple[str, str]
+
+    def to_dict(self) -> dict:
+        return {
+            "value": [pt.to_dict() for pt in self.value],
+            "iou": self.iou,
+            "label": {
+                "key": self.label[0],
+                "value": self.label[1],
+            },
+            "type": "DetailedPrecisionRecallCurve",
+        }
diff --git a/lite/valor_lite/schemas.py b/lite/valor_lite/schemas.py
new file mode 100644
index 000000000..2279f464f
--- /dev/null
+++ b/lite/valor_lite/schemas.py
@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Metric:
+    type: str
+    value: float | dict | list
+    parameters: dict
+
+    def to_dict(self) -> dict:
+        return {
+            "type": self.type,
+            "value": self.value,
+            "parameters": self.parameters,
+        }