wip: hierarchical prediction

README.md

@@ -9,5 +9,3 @@ app_file: app.py
 pinned: false
 license: mit
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,3 +1,5 @@
+import os
+
 import gradio as gr
 import torch
 import torch.nn.functional as F
@@ -6,9 +8,13 @@ from torchvision import transforms
 
 from templates import openai_imagenet_template
 
+hf_token = os.getenv("HF_TOKEN")
+hf_writer = gr.HuggingFaceDatasetSaver(hf_token, "bioclip-demo")
+
 model_str = "hf-hub:imageomics/bioclip"
 tokenizer_str = "ViT-B-16"
 
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 
 preprocess_img = transforms.Compose(
     [
@@ -26,7 +32,7 @@ def get_txt_features(classnames, templates):
     all_features = []
     for classname in classnames:
         txts = [template(classname) for template in templates]
-        txts = tokenizer(txts)
+        txts = tokenizer(txts).to(device)
         txt_features = model.encode_text(txts)
         txt_features = F.normalize(txt_features, dim=-1).mean(dim=0)
         txt_features /= txt_features.norm()
@@ -36,22 +42,43 @@ def get_txt_features(classnames, templates):
 
 
 @torch.no_grad()
-def predict(img, cls_str: str) -> dict[str, float]:
-    classes = [cls.strip() for cls in cls_str.split("\n") if cls.strip()]
+def predict(img, classes: list[str]) -> dict[str, float]:
+    classes = [cls.strip() for cls in classes if cls.strip()]
     txt_features = get_txt_features(classes, openai_imagenet_template)
 
-    img = preprocess_img(img)
-
+    img = preprocess_img(img).to(device)
     img_features = model.encode_image(img.unsqueeze(0))
     img_features = F.normalize(img_features, dim=-1)
+
     logits = (model.logit_scale.exp() * img_features @ txt_features).squeeze()
-    probs = F.softmax(logits, dim=0).tolist()
+    probs = F.softmax(logits, dim=0).to("cpu").tolist()
     return {cls: prob for cls, prob in zip(classes, probs)}
 
 
+def hierarchical_predict(img) -> list[str]:
+    """
+    Predicts from the top of the tree of life down to the species.
+    """
+    img = preprocess_img(img).to(device)
+    img_features = model.encode_image(img.unsqueeze(0))
+    img_features = F.normalize(img_features, dim=-1)
+
+    breakpoint()
+
+
+def run(img, cls_str: str) -> dict[str, float]:
+    breakpoint()
+    if cls_str:
+        classes = [cls.strip() for cls in cls_str.split("\n") if cls.strip()]
+        return predict(img, classes)
+    else:
+        return hierarchical_predict(img)
+
+
 if __name__ == "__main__":
     print("Starting.")
     model = create_model(model_str, output_dict=True, require_pretrained=True)
+    model = model.to(device)
     print("Created model.")
 
     model = torch.compile(model)
@@ -60,14 +87,21 @@ if __name__ == "__main__":
     tokenizer = get_tokenizer(tokenizer_str)
 
     demo = gr.Interface(
-        fn=predict,
+        fn=run,
         inputs=[
             gr.Image(shape=(224, 224)),
             gr.Textbox(
-                placeholder="dog\ncat\n...", lines=3, label="Classes", show_label=True
+                placeholder="dog\ncat\n...",
+                lines=3,
+                label="Classes",
+                show_label=True,
+                info="If empty, will predict from the entire tree of life.",
             ),
         ],
         outputs=gr.Label(num_top_classes=20, label="Predictions", show_label=True),
+        allow_flagging="manual",
+        flagging_options=["Incorrect", "Other"],
+        flagging_callback=hf_writer,
     )
 
     demo.launch()

embed_texts.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+#SBATCH --nodes=1
+#SBATCH --account=PAS2136
+#SBATCH --gpus-per-node=1
+#SBATCH --ntasks-per-node=10
+#SBATCH --job-name=embed-treeoflife
+#SBATCH --time=12:00:00
+#SBATCH --partition=gpu
+
+python make_txt_embedding.py \
+    --catalog-path /fs/ess/PAS2136/open_clip/data/evobio10m-v3.3/predicted-statistics.csv \
+    --out-path text_emb.bin

lib.py

@@ -0,0 +1,122 @@
+import json
+import itertools
+
+
+class TaxonomicNode:
+    __slots__ = ("name", "index", "root", "_children")
+
+    def __init__(self, name, index, root):
+        self.name = name
+        self.index = index
+        self.root = root
+        self._children = {}
+
+    def add(self, name):
+        added = 0
+        if not name:
+            return added
+
+        first, rest = name[0], name[1:]
+        if first not in self._children:
+            self._children[first] = TaxonomicNode(first, self.root.size, self.root)
+            self.root.size += 1
+
+        self._children[first].add(rest)
+
+    def children(self, name):
+        if not name:
+            return set((child.name, child.index) for child in self._children.values())
+
+        first, rest = name[0], name[1:]
+        if first not in self._children:
+            return set()
+
+        return self._children[first].children(rest)
+
+    def __iter__(self):
+        yield self.name, self.index
+
+        for child in self._children.values():
+            for name, index in child:
+                yield f"{self.name} {name}", index
+
+    @classmethod
+    def from_dict(cls, dct, root):
+        node = cls(dct["name"], dct["index"], root)
+        node._children = {child["name"]: cls.from_dict(child, root) for child in dct["children"]}
+        return node
+
+
+
+class TaxonomicTree:
+    """
+    Efficient structure for finding taxonomic names and their descendants.
+    Also returns an integer index i for each possible name.
+    """
+
+    def __init__(self):
+        self.kingdoms = {}
+        self.size = 0
+
+    def add(self, name: list[str]):
+        if not name:
+            return
+
+        first, rest = name[0], name[1:]
+        if first not in self.kingdoms:
+            self.kingdoms[first] = TaxonomicNode(first, self.size, self)
+            self.size += 1
+
+        self.kingdoms[first].add(rest)
+
+    def children(self, name=None):
+        if not name:
+            return set(
+                (kingdom.name, kingdom.index) for kingdom in self.kingdoms.values()
+            )
+
+        first, rest = name[0], name[1:]
+        if first not in self.kingdoms:
+            return set()
+
+        return self.kingdoms[first].children(rest)
+
+    def __iter__(self):
+        for kingdom in self.kingdoms.values():
+            yield from kingdom
+
+    @classmethod
+    def from_dict(cls, dct):
+        tree = cls()
+        tree.kingdoms = {
+            kingdom["name"]: TaxonomicNode.from_dict(kingdom, tree) for kingdom in dct["kingdoms"]
+        }
+        tree.size = dct["size"]
+        return tree
+
+
+class TaxonomicJsonEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, TaxonomicNode):
+            return {
+                "name": obj.name,
+                "index": obj.index,
+                "children": list(obj._children.values()),
+            }
+        elif isinstance(obj, TaxonomicTree):
+            return {
+                "kingdoms": list(obj.kingdoms.values()),
+                "size": obj.size,
+            }
+        else:
+            super().default(self, obj)
+
+
+
+def batched(iterable, n):
+    # batched('ABCDEFG', 3) --> ABC DEF G
+    if n < 1:
+        raise ValueError('n must be at least one')
+    it = iter(iterable)
+    while batch := tuple(itertools.islice(it, n)):
+        yield zip(*batch)

make_txt_embedding.py

@@ -0,0 +1,89 @@
+"""
+Makes the entire set of text emebeddings for all possible names in the tree of life. 
+Uses the catalog.csv file from TreeOfLife-10M.
+"""
+import argparse
+import csv
+import json
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from open_clip import create_model, get_tokenizer
+from tqdm import tqdm
+
+import lib
+from templates import openai_imagenet_template
+
+model_str = "hf-hub:imageomics/bioclip"
+tokenizer_str = "ViT-B-16"
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+
+@torch.no_grad()
+def write_txt_features(name_lookup):
+    all_features = np.memmap(
+        args.out_path, dtype=np.float32, mode="w+", shape=(512, name_lookup.size)
+    )
+
+    batch_size = args.batch_size // len(openai_imagenet_template)
+    for names, indices in tqdm(lib.batched(name_lookup, batch_size)):
+        txts = [template(name) for name in names for template in openai_imagenet_template]
+        txts = tokenizer(txts).to(device)
+        txt_features = model.encode_text(txts)
+        txt_features = torch.reshape(txt_features, (batch_size, len(openai_imagenet_template), 512))
+        txt_features = F.normalize(txt_features, dim=2).mean(dim=1)
+        txt_features /= txt_features.norm(dim=1, keepdim=True)
+        all_features[:, indices] = txt_features.cpu().numpy().T
+
+    all_features.flush()
+
+
+def get_name_lookup(catalog_path):
+    lookup = lib.TaxonomicTree()
+
+    with open(catalog_path) as fd:
+        reader = csv.DictReader(fd)
+        for row in tqdm(reader):
+            name = [
+                row["kingdom"],
+                row["phylum"],
+                row["class"],
+                row["order"],
+                row["family"],
+                row["genus"],
+                row["species"],
+            ]
+            if any(not value for value in name):
+                name = name[: name.index("")]
+            lookup.add(name)
+
+    return lookup
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--catalog-path",
+        help="Path to the catalog.csv file from TreeOfLife-10M.",
+        required=True,
+    )
+    parser.add_argument("--out-path", help="Path to the output file.", required=True)
+    parser.add_argument("--name-cache-path", help="Path to the name cache file.", default=".name_lookup_cache.json")
+    parser.add_argument("--batch-size", help="Batch size.", default=2 ** 15, type=int)
+    args = parser.parse_args()
+
+    name_lookup = get_name_lookup(args.catalog_path)
+    with open(args.name_cache_path, "w") as fd:
+        json.dump(name_lookup, fd, cls=lib.TaxonomicJsonEncoder)
+
+    print("Starting.")
+    model = create_model(model_str, output_dict=True, require_pretrained=True)
+    model = model.to(device)
+    print("Created model.")
+
+    model = torch.compile(model)
+    print("Compiled model.")
+
+    tokenizer = get_tokenizer(tokenizer_str)
+    write_txt_features(name_lookup)

templates.py

@@ -1,83 +1,82 @@
 openai_imagenet_template = [
-    lambda c: f'a bad photo of a {c}.',
-    lambda c: f'a photo of many {c}.',
-    lambda c: f'a sculpture of a {c}.',
-    lambda c: f'a photo of the hard to see {c}.',
-    lambda c: f'a low resolution photo of the {c}.',
-    lambda c: f'a rendering of a {c}.',
-    lambda c: f'graffiti of a {c}.',
-    lambda c: f'a bad photo of the {c}.',
-    lambda c: f'a cropped photo of the {c}.',
-    lambda c: f'a tattoo of a {c}.',
-    lambda c: f'the embroidered {c}.',
-    lambda c: f'a photo of a hard to see {c}.',
-    lambda c: f'a bright photo of a {c}.',
-    lambda c: f'a photo of a clean {c}.',
-    lambda c: f'a photo of a dirty {c}.',
-    lambda c: f'a dark photo of the {c}.',
-    lambda c: f'a drawing of a {c}.',
-    lambda c: f'a photo of my {c}.',
-    lambda c: f'the plastic {c}.',
-    lambda c: f'a photo of the cool {c}.',
-    lambda c: f'a close-up photo of a {c}.',
-    lambda c: f'a black and white photo of the {c}.',
-    lambda c: f'a painting of the {c}.',
-    lambda c: f'a painting of a {c}.',
-    lambda c: f'a pixelated photo of the {c}.',
-    lambda c: f'a sculpture of the {c}.',
-    lambda c: f'a bright photo of the {c}.',
-    lambda c: f'a cropped photo of a {c}.',
-    lambda c: f'a plastic {c}.',
-    lambda c: f'a photo of the dirty {c}.',
-    lambda c: f'a jpeg corrupted photo of a {c}.',
-    lambda c: f'a blurry photo of the {c}.',
-    lambda c: f'a photo of the {c}.',
-    lambda c: f'a good photo of the {c}.',
-    lambda c: f'a rendering of the {c}.',
-    lambda c: f'a {c} in a video game.',
-    lambda c: f'a photo of one {c}.',
-    lambda c: f'a doodle of a {c}.',
-    lambda c: f'a close-up photo of the {c}.',
-    lambda c: f'a photo of a {c}.',
-    lambda c: f'the origami {c}.',
-    lambda c: f'the {c} in a video game.',
-    lambda c: f'a sketch of a {c}.',
-    lambda c: f'a doodle of the {c}.',
-    lambda c: f'a origami {c}.',
-    lambda c: f'a low resolution photo of a {c}.',
-    lambda c: f'the toy {c}.',
-    lambda c: f'a rendition of the {c}.',
-    lambda c: f'a photo of the clean {c}.',
-    lambda c: f'a photo of a large {c}.',
-    lambda c: f'a rendition of a {c}.',
-    lambda c: f'a photo of a nice {c}.',
-    lambda c: f'a photo of a weird {c}.',
-    lambda c: f'a blurry photo of a {c}.',
-    lambda c: f'a cartoon {c}.',
-    lambda c: f'art of a {c}.',
-    lambda c: f'a sketch of the {c}.',
-    lambda c: f'a embroidered {c}.',
-    lambda c: f'a pixelated photo of a {c}.',
-    lambda c: f'itap of the {c}.',
-    lambda c: f'a jpeg corrupted photo of the {c}.',
-    lambda c: f'a good photo of a {c}.',
-    lambda c: f'a plushie {c}.',
-    lambda c: f'a photo of the nice {c}.',
-    lambda c: f'a photo of the small {c}.',
-    lambda c: f'a photo of the weird {c}.',
-    lambda c: f'the cartoon {c}.',
-    lambda c: f'art of the {c}.',
-    lambda c: f'a drawing of the {c}.',
-    lambda c: f'a photo of the large {c}.',
-    lambda c: f'a black and white photo of a {c}.',
-    lambda c: f'the plushie {c}.',
-    lambda c: f'a dark photo of a {c}.',
-    lambda c: f'itap of a {c}.',
-    lambda c: f'graffiti of the {c}.',
-    lambda c: f'a toy {c}.',
-    lambda c: f'itap of my {c}.',
-    lambda c: f'a photo of a cool {c}.',
-    lambda c: f'a photo of a small {c}.',
-    lambda c: f'a tattoo of the {c}.',
+    lambda c: f"a bad photo of a {c}.",
+    lambda c: f"a photo of many {c}.",
+    lambda c: f"a sculpture of a {c}.",
+    lambda c: f"a photo of the hard to see {c}.",
+    lambda c: f"a low resolution photo of the {c}.",
+    lambda c: f"a rendering of a {c}.",
+    lambda c: f"graffiti of a {c}.",
+    lambda c: f"a bad photo of the {c}.",
+    lambda c: f"a cropped photo of the {c}.",
+    lambda c: f"a tattoo of a {c}.",
+    lambda c: f"the embroidered {c}.",
+    lambda c: f"a photo of a hard to see {c}.",
+    lambda c: f"a bright photo of a {c}.",
+    lambda c: f"a photo of a clean {c}.",
+    lambda c: f"a photo of a dirty {c}.",
+    lambda c: f"a dark photo of the {c}.",
+    lambda c: f"a drawing of a {c}.",
+    lambda c: f"a photo of my {c}.",
+    lambda c: f"the plastic {c}.",
+    lambda c: f"a photo of the cool {c}.",
+    lambda c: f"a close-up photo of a {c}.",
+    lambda c: f"a black and white photo of the {c}.",
+    lambda c: f"a painting of the {c}.",
+    lambda c: f"a painting of a {c}.",
+    lambda c: f"a pixelated photo of the {c}.",
+    lambda c: f"a sculpture of the {c}.",
+    lambda c: f"a bright photo of the {c}.",
+    lambda c: f"a cropped photo of a {c}.",
+    lambda c: f"a plastic {c}.",
+    lambda c: f"a photo of the dirty {c}.",
+    lambda c: f"a jpeg corrupted photo of a {c}.",
+    lambda c: f"a blurry photo of the {c}.",
+    lambda c: f"a photo of the {c}.",
+    lambda c: f"a good photo of the {c}.",
+    lambda c: f"a rendering of the {c}.",
+    lambda c: f"a {c} in a video game.",
+    lambda c: f"a photo of one {c}.",
+    lambda c: f"a doodle of a {c}.",
+    lambda c: f"a close-up photo of the {c}.",
+    lambda c: f"a photo of a {c}.",
+    lambda c: f"the origami {c}.",
+    lambda c: f"the {c} in a video game.",
+    lambda c: f"a sketch of a {c}.",
+    lambda c: f"a doodle of the {c}.",
+    lambda c: f"a origami {c}.",
+    lambda c: f"a low resolution photo of a {c}.",
+    lambda c: f"the toy {c}.",
+    lambda c: f"a rendition of the {c}.",
+    lambda c: f"a photo of the clean {c}.",
+    lambda c: f"a photo of a large {c}.",
+    lambda c: f"a rendition of a {c}.",
+    lambda c: f"a photo of a nice {c}.",
+    lambda c: f"a photo of a weird {c}.",
+    lambda c: f"a blurry photo of a {c}.",
+    lambda c: f"a cartoon {c}.",
+    lambda c: f"art of a {c}.",
+    lambda c: f"a sketch of the {c}.",
+    lambda c: f"a embroidered {c}.",
+    lambda c: f"a pixelated photo of a {c}.",
+    lambda c: f"itap of the {c}.",
+    lambda c: f"a jpeg corrupted photo of the {c}.",
+    lambda c: f"a good photo of a {c}.",
+    lambda c: f"a plushie {c}.",
+    lambda c: f"a photo of the nice {c}.",
+    lambda c: f"a photo of the small {c}.",
+    lambda c: f"a photo of the weird {c}.",
+    lambda c: f"the cartoon {c}.",
+    lambda c: f"art of the {c}.",
+    lambda c: f"a drawing of the {c}.",
+    lambda c: f"a photo of the large {c}.",
+    lambda c: f"a black and white photo of a {c}.",
+    lambda c: f"the plushie {c}.",
+    lambda c: f"a dark photo of a {c}.",
+    lambda c: f"itap of a {c}.",
+    lambda c: f"graffiti of the {c}.",
+    lambda c: f"a toy {c}.",
+    lambda c: f"itap of my {c}.",
+    lambda c: f"a photo of a cool {c}.",
+    lambda c: f"a photo of a small {c}.",
+    lambda c: f"a tattoo of the {c}.",
 ]
-

test_lib.py

@@ -0,0 +1,424 @@
+import lib
+
+
+def test_taxonomiclookup_empty():
+    lookup = lib.TaxonomicTree()
+    assert lookup.size == 0
+
+
+def test_taxonomiclookup_kingdom_size():
+    lookup = lib.TaxonomicTree()
+
+    lookup.add(("Animalia",))
+
+    assert lookup.size == 1
+
+
+def test_taxonomiclookup_genus_size():
+    lookup = lib.TaxonomicTree()
+
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Accipitriformes",
+            "Accipitridae",
+            "Halieaeetus",
+        )
+    )
+
+    assert lookup.size == 6
+
+
+def test_taxonomictree_kingdom_children():
+    lookup = lib.TaxonomicTree()
+
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Accipitriformes",
+            "Accipitridae",
+            "Halieaeetus",
+        )
+    )
+
+    expected = set([("Animalia", 0)])
+    actual = lookup.children()
+    assert actual == expected
+
+
+def test_taxonomiclookup_children_of_animal_only_birds():
+    lookup = lib.TaxonomicTree()
+
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Accipitriformes",
+            "Accipitridae",
+            "Halieaeetus",
+            "leucocephalus",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Strigiformes",
+            "Strigidae",
+            "Ninox",
+            "scutulata",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Strigiformes",
+            "Strigidae",
+            "Ninox",
+            "plesseni",
+        )
+    )
+
+    actual = lookup.children(("Animalia",))
+    expected = set([("Chordata", 1)])
+    assert actual == expected
+
+
+def test_taxonomiclookup_children_of_animal():
+    lookup = lib.TaxonomicTree()
+
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Accipitriformes",
+            "Accipitridae",
+            "Halieaeetus",
+            "leucocephalus",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Strigiformes",
+            "Strigidae",
+            "Ninox",
+            "scutulata",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Strigiformes",
+            "Strigidae",
+            "Ninox",
+            "plesseni",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Mammalia",
+            "Primates",
+            "Hominidae",
+            "Gorilla",
+            "gorilla",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Arthropoda",
+            "Insecta",
+            "Hymenoptera",
+            "Apidae",
+            "Bombus",
+            "balteatus",
+        )
+    )
+
+    actual = lookup.children(("Animalia",))
+    expected = set([("Chordata", 1), ("Arthropoda", 17)])
+    assert actual == expected
+
+
+def test_taxonomiclookup_children_of_chordata():
+    lookup = lib.TaxonomicTree()
+
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Accipitriformes",
+            "Accipitridae",
+            "Halieaeetus",
+            "leucocephalus",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Strigiformes",
+            "Strigidae",
+            "Ninox",
+            "scutulata",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Strigiformes",
+            "Strigidae",
+            "Ninox",
+            "plesseni",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Mammalia",
+            "Primates",
+            "Hominidae",
+            "Gorilla",
+            "gorilla",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Arthropoda",
+            "Insecta",
+            "Hymenoptera",
+            "Apidae",
+            "Bombus",
+            "balteatus",
+        )
+    )
+
+    actual = lookup.children(("Animalia", "Chordata"))
+    expected = set([("Aves", 2), ("Mammalia", 12)])
+    assert actual == expected
+
+
+def test_taxonomiclookup_children_of_strigiformes():
+    lookup = lib.TaxonomicTree()
+
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Accipitriformes",
+            "Accipitridae",
+            "Halieaeetus",
+            "leucocephalus",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Strigiformes",
+            "Strigidae",
+            "Ninox",
+            "scutulata",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Strigiformes",
+            "Strigidae",
+            "Ninox",
+            "plesseni",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Mammalia",
+            "Primates",
+            "Hominidae",
+            "Gorilla",
+            "gorilla",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Arthropoda",
+            "Insecta",
+            "Hymenoptera",
+            "Apidae",
+            "Bombus",
+            "balteatus",
+        )
+    )
+
+    actual = lookup.children(("Animalia", "Chordata", "Aves", "Strigiformes"))
+    expected = set([("Strigidae", 8)])
+    assert actual == expected
+
+
+def test_taxonomiclookup_children_of_ninox():
+    lookup = lib.TaxonomicTree()
+
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Accipitriformes",
+            "Accipitridae",
+            "Halieaeetus",
+            "leucocephalus",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Strigiformes",
+            "Strigidae",
+            "Ninox",
+            "scutulata",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Strigiformes",
+            "Strigidae",
+            "Ninox",
+            "plesseni",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Mammalia",
+            "Primates",
+            "Hominidae",
+            "Gorilla",
+            "gorilla",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Arthropoda",
+            "Insecta",
+            "Hymenoptera",
+            "Apidae",
+            "Bombus",
+            "balteatus",
+        )
+    )
+
+    actual = lookup.children(
+        ("Animalia", "Chordata", "Aves", "Strigiformes", "Strigidae", "Ninox")
+    )
+    expected = set([("scutulata", 10), ("plesseni", 11)])
+    assert actual == expected
+
+
+def test_taxonomiclookup_children_of_gorilla():
+    lookup = lib.TaxonomicTree()
+
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Accipitriformes",
+            "Accipitridae",
+            "Halieaeetus",
+            "leucocephalus",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Strigiformes",
+            "Strigidae",
+            "Ninox",
+            "scutulata",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Aves",
+            "Strigiformes",
+            "Strigidae",
+            "Ninox",
+            "plesseni",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Chordata",
+            "Mammalia",
+            "Primates",
+            "Hominidae",
+            "Gorilla",
+            "gorilla",
+        )
+    )
+    lookup.add(
+        (
+            "Animalia",
+            "Arthropoda",
+            "Insecta",
+            "Hymenoptera",
+            "Apidae",
+            "Bombus",
+            "balteatus",
+        )
+    )
+
+    actual = lookup.children(
+        (
+            "Animalia",
+            "Chordata",
+            "Mammalia",
+            "Primates",
+            "Hominidae",
+            "Gorilla",
+            "gorilla",
+        )
+    )
+    expected = set()
+    assert actual == expected