Skip to content
Snippets Groups Projects
Commit f3b8fef6 authored by André Anjos's avatar André Anjos :speech_balloon:
Browse files

[tests] Implement tests for some remix datasets

parent 02f6b38a
No related branches found
No related tags found
1 merge request!6Making use of LightningDataModule and simplification of data loading
Expand all Hide whitespace changes
Inline Side-by-side
tests/test_mc_ch.py deleted 100644 → 0
+ 0
− 505
View file @ 02f6b38a
# SPDX-FileCopyrightText: Copyright © 2023 Idiap Research Institute <contact@idiap.ch>
#
# SPDX-License-Identifier: GPL-3.0-or-later
"""Tests for the aggregated Montgomery-Shenzhen dataset."""
import pytest
@pytest.mark.skip(reason="Test need to be updated")
def test_dataset_consistency():
from ptbench.data.montgomery import default as mc
from ptbench.data.montgomery import fold_0 as mc_f0
from ptbench.data.montgomery import fold_1 as mc_f1
from ptbench.data.montgomery import fold_2 as mc_f2
from ptbench.data.montgomery import fold_3 as mc_f3
from ptbench.data.montgomery import fold_4 as mc_f4
from ptbench.data.montgomery import fold_5 as mc_f5
from ptbench.data.montgomery import fold_6 as mc_f6
from ptbench.data.montgomery import fold_7 as mc_f7
from ptbench.data.montgomery import fold_8 as mc_f8
from ptbench.data.montgomery import fold_9 as mc_f9
from ptbench.data.montgomery_shenzhen import default as mc_ch
from ptbench.data.montgomery_shenzhen import fold_0 as mc_ch_f0
from ptbench.data.montgomery_shenzhen import fold_1 as mc_ch_f1
from ptbench.data.montgomery_shenzhen import fold_2 as mc_ch_f2
from ptbench.data.montgomery_shenzhen import fold_3 as mc_ch_f3
from ptbench.data.montgomery_shenzhen import fold_4 as mc_ch_f4
from ptbench.data.montgomery_shenzhen import fold_5 as mc_ch_f5
from ptbench.data.montgomery_shenzhen import fold_6 as mc_ch_f6
from ptbench.data.montgomery_shenzhen import fold_7 as mc_ch_f7
from ptbench.data.montgomery_shenzhen import fold_8 as mc_ch_f8
from ptbench.data.montgomery_shenzhen import fold_9 as mc_ch_f9
from ptbench.data.shenzhen import default as ch
from ptbench.data.shenzhen import fold_0 as ch_f0
from ptbench.data.shenzhen import fold_1 as ch_f1
from ptbench.data.shenzhen import fold_2 as ch_f2
from ptbench.data.shenzhen import fold_3 as ch_f3
from ptbench.data.shenzhen import fold_4 as ch_f4
from ptbench.data.shenzhen import fold_5 as ch_f5
from ptbench.data.shenzhen import fold_6 as ch_f6
from ptbench.data.shenzhen import fold_7 as ch_f7
from ptbench.data.shenzhen import fold_8 as ch_f8
from ptbench.data.shenzhen import fold_9 as ch_f9
# Default protocol
mc_ch_dataset = mc_ch.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc.dataset
ch_dataset = ch.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f0 protocol
mc_ch_dataset = mc_ch_f0.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f0.dataset
ch_dataset = ch_f0.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f1 protocol
mc_ch_dataset = mc_ch_f1.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f1.dataset
ch_dataset = ch_f1.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f2 protocol
mc_ch_dataset = mc_ch_f2.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f2.dataset
ch_dataset = ch_f2.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f3 protocol
mc_ch_dataset = mc_ch_f3.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f3.dataset
ch_dataset = ch_f3.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f4 protocol
mc_ch_dataset = mc_ch_f4.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f4.dataset
ch_dataset = ch_f4.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f5 protocol
mc_ch_dataset = mc_ch_f5.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f5.dataset
ch_dataset = ch_f5.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f6 protocol
mc_ch_dataset = mc_ch_f6.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f6.dataset
ch_dataset = ch_f6.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f7 protocol
mc_ch_dataset = mc_ch_f7.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f7.dataset
ch_dataset = ch_f7.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f8 protocol
mc_ch_dataset = mc_ch_f8.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f8.dataset
ch_dataset = ch_f8.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f9 protocol
mc_ch_dataset = mc_ch_f9.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f9.dataset
ch_dataset = ch_f9.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f0 protocol RGB
mc_ch_dataset = mc_ch_f0_rgb.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f0_rgb.dataset
ch_dataset = ch_f0_rgb.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f1 protocol RGB
mc_ch_dataset = mc_ch_f1_rgb.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f1_rgb.dataset
ch_dataset = ch_f1_rgb.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f2 protocol RGB
mc_ch_dataset = mc_ch_f2_rgb.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f2_rgb.dataset
ch_dataset = ch_f2_rgb.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f3 protocol RGB
mc_ch_dataset = mc_ch_f3_rgb.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f3_rgb.dataset
ch_dataset = ch_f3_rgb.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f4 protocol RGB
mc_ch_dataset = mc_ch_f4_rgb.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f4_rgb.dataset
ch_dataset = ch_f4_rgb.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f5 protocol RGB
mc_ch_dataset = mc_ch_f5_rgb.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f5_rgb.dataset
ch_dataset = ch_f5_rgb.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f6 protocol RGB
mc_ch_dataset = mc_ch_f6_rgb.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f6_rgb.dataset
ch_dataset = ch_f6_rgb.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f7 protocol RGB
mc_ch_dataset = mc_ch_f7_rgb.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f7_rgb.dataset
ch_dataset = ch_f7_rgb.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f8 protocol RGB
mc_ch_dataset = mc_ch_f8_rgb.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f8_rgb.dataset
ch_dataset = ch_f8_rgb.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
# f9 protocol RGB
mc_ch_dataset = mc_ch_f9_rgb.dataset
assert isinstance(mc_ch_dataset, dict)
mc_dataset = mc_f9_rgb.dataset
ch_dataset = ch_f9_rgb.dataset
assert "train" in mc_ch_dataset
assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
)
assert "validation" in mc_ch_dataset
assert len(mc_ch_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"])
assert "test" in mc_ch_dataset
assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
)
tests/test_mc_ch_in.py deleted 100644 → 0
+ 0
− 535
View file @ 02f6b38a
# SPDX-FileCopyrightText: Copyright © 2023 Idiap Research Institute <contact@idiap.ch>
#
# SPDX-License-Identifier: GPL-3.0-or-later
"""Tests for the aggregated Montgomery-Shenzhen-Indian dataset."""
import pytest
@pytest.mark.skip(reason="Test need to be updated")
def test_dataset_consistency():
from ptbench.data.indian import default as indian
from ptbench.data.indian import fold_0 as indian_f0
from ptbench.data.indian import fold_1 as indian_f1
from ptbench.data.indian import fold_2 as indian_f2
from ptbench.data.indian import fold_3 as indian_f3
from ptbench.data.indian import fold_4 as indian_f4
from ptbench.data.indian import fold_5 as indian_f5
from ptbench.data.indian import fold_6 as indian_f6
from ptbench.data.indian import fold_7 as indian_f7
from ptbench.data.indian import fold_8 as indian_f8
from ptbench.data.indian import fold_9 as indian_f9
from ptbench.data.montgomery import default as mc
from ptbench.data.montgomery import fold_0 as mc_f0
from ptbench.data.montgomery import fold_1 as mc_f1
from ptbench.data.montgomery import fold_2 as mc_f2
from ptbench.data.montgomery import fold_3 as mc_f3
from ptbench.data.montgomery import fold_4 as mc_f4
from ptbench.data.montgomery import fold_5 as mc_f5
from ptbench.data.montgomery import fold_6 as mc_f6
from ptbench.data.montgomery import fold_7 as mc_f7
from ptbench.data.montgomery import fold_8 as mc_f8
from ptbench.data.montgomery import fold_9 as mc_f9
from ptbench.data.montgomery_shenzhen_indian import default as mc_ch_in
from ptbench.data.montgomery_shenzhen_indian import fold_0 as mc_ch_in_f0
from ptbench.data.montgomery_shenzhen_indian import fold_1 as mc_ch_in_f1
from ptbench.data.montgomery_shenzhen_indian import fold_2 as mc_ch_in_f2
from ptbench.data.montgomery_shenzhen_indian import fold_3 as mc_ch_in_f3
from ptbench.data.montgomery_shenzhen_indian import fold_4 as mc_ch_in_f4
from ptbench.data.montgomery_shenzhen_indian import fold_5 as mc_ch_in_f5
from ptbench.data.montgomery_shenzhen_indian import fold_6 as mc_ch_in_f6
from ptbench.data.montgomery_shenzhen_indian import fold_7 as mc_ch_in_f7
from ptbench.data.montgomery_shenzhen_indian import fold_8 as mc_ch_in_f8
from ptbench.data.montgomery_shenzhen_indian import fold_9 as mc_ch_in_f9
from ptbench.data.shenzhen import default as ch
from ptbench.data.shenzhen import fold_0 as ch_f0
from ptbench.data.shenzhen import fold_1 as ch_f1
from ptbench.data.shenzhen import fold_2 as ch_f2
from ptbench.data.shenzhen import fold_3 as ch_f3
from ptbench.data.shenzhen import fold_4 as ch_f4
from ptbench.data.shenzhen import fold_5 as ch_f5
from ptbench.data.shenzhen import fold_6 as ch_f6
from ptbench.data.shenzhen import fold_7 as ch_f7
from ptbench.data.shenzhen import fold_8 as ch_f8
from ptbench.data.shenzhen import fold_9 as ch_f9
# Default protocol
mc_ch_in_dataset = mc_ch_in.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc.dataset
ch_dataset = ch.dataset
in_dataset = indian.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 0
mc_ch_in_dataset = mc_ch_in_f0.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f0.dataset
ch_dataset = ch_f0.dataset
in_dataset = indian_f0.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 1
mc_ch_in_dataset = mc_ch_in_f1.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f1.dataset
ch_dataset = ch_f1.dataset
in_dataset = indian_f1.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 2
mc_ch_in_dataset = mc_ch_in_f2.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f2.dataset
ch_dataset = ch_f2.dataset
in_dataset = indian_f2.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 3
mc_ch_in_dataset = mc_ch_in_f3.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f3.dataset
ch_dataset = ch_f3.dataset
in_dataset = indian_f3.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 4
mc_ch_in_dataset = mc_ch_in_f4.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f4.dataset
ch_dataset = ch_f4.dataset
in_dataset = indian_f4.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 5
mc_ch_in_dataset = mc_ch_in_f5.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f5.dataset
ch_dataset = ch_f5.dataset
in_dataset = indian_f5.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 6
mc_ch_in_dataset = mc_ch_in_f6.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f6.dataset
ch_dataset = ch_f6.dataset
in_dataset = indian_f6.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 7
mc_ch_in_dataset = mc_ch_in_f7.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f7.dataset
ch_dataset = ch_f7.dataset
in_dataset = indian_f7.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 8
mc_ch_in_dataset = mc_ch_in_f8.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f8.dataset
ch_dataset = ch_f8.dataset
in_dataset = indian_f8.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 9
mc_ch_in_dataset = mc_ch_in_f9.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f9.dataset
ch_dataset = ch_f9.dataset
in_dataset = indian_f9.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 0, RGB
mc_ch_in_dataset = mc_ch_in_f0_rgb.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f0_rgb.dataset
ch_dataset = ch_f0_rgb.dataset
in_dataset = indian_f0_rgb.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 1, RGB
mc_ch_in_dataset = mc_ch_in_f1_rgb.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f1_rgb.dataset
ch_dataset = ch_f1_rgb.dataset
in_dataset = indian_f1_rgb.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 2, RGB
mc_ch_in_dataset = mc_ch_in_f2_rgb.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f2_rgb.dataset
ch_dataset = ch_f2_rgb.dataset
in_dataset = indian_f2_rgb.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 3, RGB
mc_ch_in_dataset = mc_ch_in_f3_rgb.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f3_rgb.dataset
ch_dataset = ch_f3_rgb.dataset
in_dataset = indian_f3_rgb.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 4, RGB
mc_ch_in_dataset = mc_ch_in_f4_rgb.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f4_rgb.dataset
ch_dataset = ch_f4_rgb.dataset
in_dataset = indian_f4_rgb.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 5, RGB
mc_ch_in_dataset = mc_ch_in_f5_rgb.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f5_rgb.dataset
ch_dataset = ch_f5_rgb.dataset
in_dataset = indian_f5_rgb.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 6, RGB
mc_ch_in_dataset = mc_ch_in_f6_rgb.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f6_rgb.dataset
ch_dataset = ch_f6_rgb.dataset
in_dataset = indian_f6_rgb.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 7, RGB
mc_ch_in_dataset = mc_ch_in_f7_rgb.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f7_rgb.dataset
ch_dataset = ch_f7_rgb.dataset
in_dataset = indian_f7_rgb.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 8, RGB
mc_ch_in_dataset = mc_ch_in_f8_rgb.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f8_rgb.dataset
ch_dataset = ch_f8_rgb.dataset
in_dataset = indian_f8_rgb.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
# Fold 9, RGB
mc_ch_in_dataset = mc_ch_in_f9_rgb.dataset
assert isinstance(mc_ch_in_dataset, dict)
mc_dataset = mc_f9_rgb.dataset
ch_dataset = ch_f9_rgb.dataset
in_dataset = indian_f9_rgb.dataset
assert "train" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["train"]) == len(mc_dataset["train"]) + len(
ch_dataset["train"]
) + len(in_dataset["train"])
assert "validation" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["validation"]) == len(
mc_dataset["validation"]
) + len(ch_dataset["validation"]) + len(in_dataset["validation"])
assert "test" in mc_ch_in_dataset
assert len(mc_ch_in_dataset["test"]) == len(mc_dataset["test"]) + len(
ch_dataset["test"]
) + len(in_dataset["test"])
tests/test_mc_ch_in_11k.py deleted 100644 → 0
+ 0
− 630
View file @ 02f6b38a
This diff is collapsed.
tests/test_mc_ch_in_11kv2.py deleted 100644 → 0
+ 0
− 613
View file @ 02f6b38a
This diff is collapsed.
tests/test_montgomery_shenzhen.py 0 → 100644
+ 55
− 0
View file @ f3b8fef6
# SPDX-FileCopyrightText: Copyright © 2023 Idiap Research Institute <contact@idiap.ch>
#
# SPDX-License-Identifier: GPL-3.0-or-later
"""Tests for the aggregated Montgomery-Shenzhen dataset."""
import importlib
import pytest
@pytest.mark.parametrize(
"name",
[
"default",
"fold_0",
"fold_1",
"fold_2",
"fold_3",
"fold_4",
"fold_5",
"fold_6",
"fold_7",
"fold_8",
"fold_9",
],
)
def test_split_consistency(name: str):
montgomery = importlib.import_module(
f".{name}", "ptbench.data.montgomery"
).datamodule
shenzhen = importlib.import_module(
f".{name}", "ptbench.data.shenzhen"
).datamodule
combined = importlib.import_module(
f".{name}", "ptbench.data.montgomery_shenzhen"
).datamodule
MontgomeryLoader = importlib.import_module(
".datamodule", "ptbench.data.montgomery"
).RawDataLoader
ShenzhenLoader = importlib.import_module(
".datamodule", "ptbench.data.shenzhen"
).RawDataLoader
for split in ("train", "validation", "test"):
assert montgomery.splits[split][0][0] == combined.splits[split][0][0]
assert isinstance(montgomery.splits[split][0][1], MontgomeryLoader)
assert isinstance(combined.splits[split][0][1], MontgomeryLoader)
assert shenzhen.splits[split][0][0] == combined.splits[split][1][0]
assert isinstance(shenzhen.splits[split][0][1], ShenzhenLoader)
assert isinstance(combined.splits[split][1][1], ShenzhenLoader)
tests/test_montgomery_shenzhen_indian.py 0 → 100644
+ 67
− 0
View file @ f3b8fef6
# SPDX-FileCopyrightText: Copyright © 2023 Idiap Research Institute <contact@idiap.ch>
#
# SPDX-License-Identifier: GPL-3.0-or-later
"""Tests for the aggregated Montgomery-Shenzhen-Indian dataset."""
import importlib
import pytest
@pytest.mark.parametrize(
"name",
[
"default",
"fold_0",
"fold_1",
"fold_2",
"fold_3",
"fold_4",
"fold_5",
"fold_6",
"fold_7",
"fold_8",
"fold_9",
],
)
def test_split_consistency(name: str):
montgomery = importlib.import_module(
f".{name}", "ptbench.data.montgomery"
).datamodule
shenzhen = importlib.import_module(
f".{name}", "ptbench.data.shenzhen"
).datamodule
indian = importlib.import_module(
f".{name}", "ptbench.data.indian"
).datamodule
combined = importlib.import_module(
f".{name}", "ptbench.data.montgomery_shenzhen_indian"
).datamodule
MontgomeryLoader = importlib.import_module(
".datamodule", "ptbench.data.montgomery"
).RawDataLoader
ShenzhenLoader = importlib.import_module(
".datamodule", "ptbench.data.shenzhen"
).RawDataLoader
IndianLoader = importlib.import_module(
".datamodule", "ptbench.data.indian"
).RawDataLoader
for split in ("train", "validation", "test"):
assert montgomery.splits[split][0][0] == combined.splits[split][0][0]
assert isinstance(montgomery.splits[split][0][1], MontgomeryLoader)
assert isinstance(combined.splits[split][0][1], MontgomeryLoader)
assert shenzhen.splits[split][0][0] == combined.splits[split][1][0]
assert isinstance(shenzhen.splits[split][0][1], ShenzhenLoader)
assert isinstance(combined.splits[split][1][1], ShenzhenLoader)
assert indian.splits[split][0][0] == combined.splits[split][2][0]
assert isinstance(indian.splits[split][0][1], IndianLoader)
assert isinstance(combined.splits[split][2][1], IndianLoader)
tests/test_montgomery_shenzhen_indian_tbx11k.py 0 → 100644
+ 90
− 0
View file @ f3b8fef6
# SPDX-FileCopyrightText: Copyright © 2023 Idiap Research Institute <contact@idiap.ch>
#
# SPDX-License-Identifier: GPL-3.0-or-later
"""Tests for the aggregated Montgomery-Shenzhen-Indian-TBX11k dataset."""
import importlib
import pytest
@pytest.mark.parametrize(
"name,tbx11k_name",
[
("default", "v1_healthy_vs_atb"),
("fold_0", "v1_fold_0"),
("fold_1", "v1_fold_1"),
("fold_2", "v1_fold_2"),
("fold_3", "v1_fold_3"),
("fold_4", "v1_fold_4"),
("fold_5", "v1_fold_5"),
("fold_6", "v1_fold_6"),
("fold_7", "v1_fold_7"),
("fold_8", "v1_fold_8"),
("fold_9", "v1_fold_9"),
("default", "v2_others_vs_atb"),
("fold_0", "v2_fold_0"),
("fold_1", "v2_fold_1"),
("fold_2", "v2_fold_2"),
("fold_3", "v2_fold_3"),
("fold_4", "v2_fold_4"),
("fold_5", "v2_fold_5"),
("fold_6", "v2_fold_6"),
("fold_7", "v2_fold_7"),
("fold_8", "v2_fold_8"),
("fold_9", "v2_fold_9"),
],
)
def test_split_consistency(name: str, tbx11k_name: str):
montgomery = importlib.import_module(
f".{name}", "ptbench.data.montgomery"
).datamodule
shenzhen = importlib.import_module(
f".{name}", "ptbench.data.shenzhen"
).datamodule
indian = importlib.import_module(
f".{name}", "ptbench.data.indian"
).datamodule
tbx11k = importlib.import_module(
f".{tbx11k_name}", "ptbench.data.tbx11k"
).datamodule
combined = importlib.import_module(
f".{tbx11k_name}", "ptbench.data.montgomery_shenzhen_indian_tbx11k"
).datamodule
MontgomeryLoader = importlib.import_module(
".datamodule", "ptbench.data.montgomery"
).RawDataLoader
ShenzhenLoader = importlib.import_module(
".datamodule", "ptbench.data.shenzhen"
).RawDataLoader
IndianLoader = importlib.import_module(
".datamodule", "ptbench.data.indian"
).RawDataLoader
TBX11kLoader = importlib.import_module(
".datamodule", "ptbench.data.tbx11k"
).RawDataLoader
for split in ("train", "validation", "test"):
assert montgomery.splits[split][0][0] == combined.splits[split][0][0]
assert isinstance(montgomery.splits[split][0][1], MontgomeryLoader)
assert isinstance(combined.splits[split][0][1], MontgomeryLoader)
assert shenzhen.splits[split][0][0] == combined.splits[split][1][0]
assert isinstance(shenzhen.splits[split][0][1], ShenzhenLoader)
assert isinstance(combined.splits[split][1][1], ShenzhenLoader)
assert indian.splits[split][0][0] == combined.splits[split][2][0]
assert isinstance(indian.splits[split][0][1], IndianLoader)
assert isinstance(combined.splits[split][2][1], IndianLoader)
assert tbx11k.splits[split][0][0] == combined.splits[split][3][0]
assert isinstance(tbx11k.splits[split][0][1], TBX11kLoader)
assert isinstance(combined.splits[split][3][1], TBX11kLoader)
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment