diff --git a/milk10k_effb2_metadata/.cache/huggingface/.gitignore b/milk10k_effb2_metadata/.cache/huggingface/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..f59ec20aabf5842d237244ece8c81ab184faeac1 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/.gitignore @@ -0,0 +1 @@ +* \ No newline at end of file diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/.gitattributes.lock b/milk10k_effb2_metadata/.cache/huggingface/download/.gitattributes.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/.gitattributes.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/.gitattributes.metadata new file mode 100644 index 0000000000000000000000000000000000000000..7033754ee6c5725e950b47c19f1cba833697d02a --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/.gitattributes.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +bed0738c7eeb449bca98b5d2f33c89a1ee56349a +1781597425.7859669 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/datasets.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/datasets.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/datasets.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/datasets.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..fed8d858ef0acbe6ac868623ab3561e0cad9ec49 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/datasets.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +745bbba7691dd8a1caf1f1450fe9cd267979fb72 +1781597425.9924324 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/MILK10K_EFFB2_METADATA_CLI.md.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/MILK10K_EFFB2_METADATA_CLI.md.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/MILK10K_EFFB2_METADATA_CLI.md.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/MILK10K_EFFB2_METADATA_CLI.md.metadata new file mode 100644 index 0000000000000000000000000000000000000000..6f3dca24ac8ec92d4fff4ade3b77bec6bb93fdde --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/MILK10K_EFFB2_METADATA_CLI.md.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +9c467a783f5db02fc2938b239aafbb79ec441940 +1781597425.6549404 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__init__.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__init__.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__init__.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__init__.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..bafb2da803134628805feee651d336c1e39cda41 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__init__.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +4b177b7643716beb9197ff1a6f13ddc082bcf679 +1781597425.585372 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/__init__.cpython-310.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/__init__.cpython-310.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/__init__.cpython-310.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/__init__.cpython-310.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..b12f8225ef66466dc69d923d6b38176d3ac2c657 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/__init__.cpython-310.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +0896243fe721016e63775ed3d25d17e47ecb9d29 +1781597425.813415 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/__init__.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/__init__.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/__init__.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/__init__.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..a2032f8dabbd467deb13d1f82a383e011ec3a566 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/__init__.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +08bf4b46a5615b9ea4d9a1fafc10abaf6fbcdf77 +1781597426.1462557 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/checkpoints.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/checkpoints.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/checkpoints.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/checkpoints.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..fd2f5b0980604a25b8d61cbaafa4b432973b210c --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/checkpoints.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +e48728b832ad1f61f864094af5ae7197e1beded2 +1781597425.511972 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/cli.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/cli.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/cli.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/cli.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..4a6960ace9ed73df197b7bb6a5ec9d94b82532ff --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/cli.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +152dc30657add84c181fa4f9c068d86349fba1a6 +1781597426.539304 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/data.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/data.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/data.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/data.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..c332fea527a0fa55c60a96979d635fe9b3eac4d8 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/data.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +34f4712b6ab226459b0dc4bce8824d994070021a +1781597426.559293 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/engine.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/engine.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/engine.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/engine.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..a78c3e99aba4a9bb2505badc66e36d2b0759064b --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/engine.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +94d085df27494f40c7b4cfbc6a4d426985cfcba9 +1781597426.480496 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/inference.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/inference.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/inference.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/inference.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..2e941b15cb139f3e751bc2b7502537abeed295fa --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/inference.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +70b1a231d6c0bcffa94631deb7b8cbb85d9bf224 +1781597426.6514366 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/losses.cpython-310.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/losses.cpython-310.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/losses.cpython-310.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/losses.cpython-310.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..f03741eb5bea9d2ed26b57d02528a8d39e1bd1d2 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/losses.cpython-310.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +dc43b0d3f3a6c7e77371155a67a730881f96634c +1781597426.7428267 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/losses.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/losses.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/losses.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/losses.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..d248c556b5696a004a9988a27b779c8b5a92740b --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/losses.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +e67f1957628509f5390aa9041e8f4b14ca19e6ed +1781597426.6966894 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/metrics.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/metrics.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/metrics.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/metrics.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..d2d433128f78809d4a232a3bf1931743159b68de --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/metrics.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +57e036ee2530157cec8597a2194d0f699e2d98d5 +1781597427.0974405 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/model_setup.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/model_setup.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/model_setup.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/model_setup.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..3188802dc29a288258abb0fd68eadebbd0f04c86 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/model_setup.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +5a90a95188fd6ccadf70579cd1ad768f675f5258 +1781597427.0447693 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/models.cpython-310.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/models.cpython-310.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/models.cpython-310.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/models.cpython-310.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..71dbc4d11a84939dcaeb09bd0b54d62e3848ccd6 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/models.cpython-310.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +d38b14cad04e5a63a1fd0ac34908ce69f8bcd187 +1781597427.375944 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/models.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/models.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/models.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/models.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..032525359d04a4076ae23a22baae4a606f7c71f5 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/models.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +85b1b6b5686a45d2a47d5df2e20b712b10aeaa55 +1781597427.6779335 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/runner.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/runner.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/runner.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/runner.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..5cbc2c6254aaf11050c37e0f3dc84449da95fee9 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/runner.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +9efb15b1ccf8afef6145cc53221067fe920b75b4 +1781597427.760574 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/train_milk10k_effb2_dual_metadata.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/train_milk10k_effb2_dual_metadata.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/train_milk10k_effb2_dual_metadata.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/train_milk10k_effb2_dual_metadata.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..6ee55454d42ffb1bd8ed869ff5f38d3f83321c1d --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/train_milk10k_effb2_dual_metadata.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +9a7cb0f115b95ac83a1bda2d29654b6b44b80f8c +1781597427.551546 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/training.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/training.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/training.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/training.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..9ead562ad394ad874ba67904210c962e25d4ecca --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/training.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +4f979947db3b11e272935ae1768a693b54a56630 +1781597427.717837 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/training_utils.cpython-314.pyc.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/training_utils.cpython-314.pyc.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/training_utils.cpython-314.pyc.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/training_utils.cpython-314.pyc.metadata new file mode 100644 index 0000000000000000000000000000000000000000..796048e26352f84bb9dba515e2906b10aaf1723a --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/__pycache__/training_utils.cpython-314.pyc.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +9b6237f6b9bedbe8465352e8617f62719de01c27 +1781597427.864535 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/checkpoints.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/checkpoints.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/checkpoints.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/checkpoints.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..622c2cb5ea449d95cf717f32304eb40671c8a7b8 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/checkpoints.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +ca041bd29958b95380013b4c1ab77a377241a5b6 +1781597428.0874379 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/cli.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/cli.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/cli.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/cli.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..68db81904e22bf0b59639c71ed3883cb233cbe7f --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/cli.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +f2afe680f9be4c32d0b764cec33e954b9405c36a +1781597428.2136478 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/data.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/data.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/data.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/data.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..de0ee26848dafb57a03975360cb3f4a0345f04a5 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/data.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +18280e8278d5c3309d25807787869b5399200cfa +1781597428.513635 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/engine.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/engine.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/engine.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/engine.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..004f2e95e746598dc5dd1d6b30331d3430ef6432 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/engine.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +a99ff221829611a452ec800c5ffec8ef45a46721 +1781597428.426173 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/inference.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/inference.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/inference.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/inference.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..7aa2e2d18b01c47df5c5bb164cf699205e885380 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/inference.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +5161a1a84c4904356be64f2d8a41b4d450a05860 +1781597428.82443 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/losses.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/losses.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/losses.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/losses.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..0759ba98d23a02c711e7ce78102fce434f943971 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/losses.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +8b6d627c534d71d99d855b29c65bc294b87c6303 +1781597428.79422 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/metrics.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/metrics.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/metrics.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/metrics.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..77d5839c442968d4733cf7ed8d073b214e5d6935 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/metrics.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +e9c3f3d079aa08915f21fa758bf05891d861c1bd +1781597428.8403232 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/model_setup.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/model_setup.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/model_setup.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/model_setup.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..437b1e6628aed55c9c307c13ddc31cb26663c5f6 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/model_setup.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +adaed11bb482bc9312d8a9d2b5bcd555936bea9e +1781597428.9916527 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/models.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/models.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/models.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/models.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..89bc5028723bf9b599b0c9ab2c89748ffdefc582 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/models.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +f6d126347f16f6904eae70a9055005db53a23c81 +1781597428.9753091 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/runner.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/runner.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/runner.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/runner.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..0de9277c59f50d0f121e4d47dcb260ec0f819948 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/runner.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +4b39d6e160bc3dab5624ef6da0e572de33b72980 +1781597429.1600146 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/train_milk10k_effb2_dual_metadata.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/train_milk10k_effb2_dual_metadata.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/train_milk10k_effb2_dual_metadata.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/train_milk10k_effb2_dual_metadata.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..9d548aa2379b264bff6f549e38fccae80aa05559 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/train_milk10k_effb2_dual_metadata.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +da1072ea523e7c2a806284dfafacbb6dba6a1293 +1781597429.3428674 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/training.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/training.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/training.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/training.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..59101ea48a845883cd9193fcd65fcd44b129e4d7 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/training.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +72e7f7b777bddfa3c6e4ed06cf40cf230d8696ee +1781597429.706166 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/training_utils.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/training_utils.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/training_utils.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/training_utils.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..3f5e64125d8b43ac02ace9653023aa217c636cb1 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/milk10k_effb2_metadata/training_utils.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +96df26e95c0a775a4d5d85ced5c23db69a0e3687 +1781597429.9209738 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/predict_milk10k_effb2_dual_metadata.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/predict_milk10k_effb2_dual_metadata.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/predict_milk10k_effb2_dual_metadata.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/predict_milk10k_effb2_dual_metadata.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..d77985bdf9e9ff265aebc1a6710ff304dfb081b7 --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/predict_milk10k_effb2_dual_metadata.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +15f35146cc23e29e3348f85ea82d19bcfbc4f1f0 +1781597430.34601 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/train_milk10k_effb2_dual_metadata.py.lock b/milk10k_effb2_metadata/.cache/huggingface/download/train_milk10k_effb2_dual_metadata.py.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/milk10k_effb2_metadata/.cache/huggingface/download/train_milk10k_effb2_dual_metadata.py.metadata b/milk10k_effb2_metadata/.cache/huggingface/download/train_milk10k_effb2_dual_metadata.py.metadata new file mode 100644 index 0000000000000000000000000000000000000000..21c33b4116ab09dc5610d8b01b8b3acda50db6cd --- /dev/null +++ b/milk10k_effb2_metadata/.cache/huggingface/download/train_milk10k_effb2_dual_metadata.py.metadata @@ -0,0 +1,3 @@ +c48b211a983203f99f058ce6a5ae649db2561a43 +da1072ea523e7c2a806284dfafacbb6dba6a1293 +1781597429.9241464 diff --git a/milk10k_effb2_metadata/.gitattributes b/milk10k_effb2_metadata/.gitattributes new file mode 100644 index 0000000000000000000000000000000000000000..bed0738c7eeb449bca98b5d2f33c89a1ee56349a --- /dev/null +++ b/milk10k_effb2_metadata/.gitattributes @@ -0,0 +1,60 @@ +*.7z filter=lfs diff=lfs merge=lfs -text +*.arrow filter=lfs diff=lfs merge=lfs -text +*.avro filter=lfs diff=lfs merge=lfs -text +*.bin filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.ckpt filter=lfs diff=lfs merge=lfs -text +*.ftz filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.h5 filter=lfs diff=lfs merge=lfs -text +*.joblib filter=lfs diff=lfs merge=lfs -text +*.lfs.* filter=lfs diff=lfs merge=lfs -text +*.lz4 filter=lfs diff=lfs merge=lfs -text +*.mds filter=lfs diff=lfs merge=lfs -text +*.mlmodel filter=lfs diff=lfs merge=lfs -text +*.model filter=lfs diff=lfs merge=lfs -text +*.msgpack filter=lfs diff=lfs merge=lfs -text +*.npy filter=lfs diff=lfs merge=lfs -text +*.npz filter=lfs diff=lfs merge=lfs -text +*.onnx filter=lfs diff=lfs merge=lfs -text +*.ot filter=lfs diff=lfs merge=lfs -text +*.parquet filter=lfs diff=lfs merge=lfs -text +*.pb filter=lfs diff=lfs merge=lfs -text +*.pickle filter=lfs diff=lfs merge=lfs -text +*.pkl filter=lfs diff=lfs merge=lfs -text +*.pt filter=lfs diff=lfs merge=lfs -text +*.pth filter=lfs diff=lfs merge=lfs -text +*.rar filter=lfs diff=lfs merge=lfs -text +*.safetensors filter=lfs diff=lfs merge=lfs -text +saved_model/**/* filter=lfs diff=lfs merge=lfs -text +*.tar.* filter=lfs diff=lfs merge=lfs -text +*.tar filter=lfs diff=lfs merge=lfs -text +*.tflite filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.wasm filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text +*tfevents* filter=lfs diff=lfs merge=lfs -text +# Audio files - uncompressed +*.pcm filter=lfs diff=lfs merge=lfs -text +*.sam filter=lfs diff=lfs merge=lfs -text +*.raw filter=lfs diff=lfs merge=lfs -text +# Audio files - compressed +*.aac filter=lfs diff=lfs merge=lfs -text +*.flac filter=lfs diff=lfs merge=lfs -text +*.mp3 filter=lfs diff=lfs merge=lfs -text +*.ogg filter=lfs diff=lfs merge=lfs -text +*.wav filter=lfs diff=lfs merge=lfs -text +# Image files - uncompressed +*.bmp filter=lfs diff=lfs merge=lfs -text +*.gif filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.tiff filter=lfs diff=lfs merge=lfs -text +# Image files - compressed +*.jpg filter=lfs diff=lfs merge=lfs -text +*.jpeg filter=lfs diff=lfs merge=lfs -text +*.webp filter=lfs diff=lfs merge=lfs -text +# Video files - compressed +*.mp4 filter=lfs diff=lfs merge=lfs -text +*.webm filter=lfs diff=lfs merge=lfs -text diff --git a/milk10k_effb2_metadata/__pycache__/datasets.cpython-314.pyc b/milk10k_effb2_metadata/__pycache__/datasets.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af1626140821300808b58ce972715723c2a60ee5 Binary files /dev/null and b/milk10k_effb2_metadata/__pycache__/datasets.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/__pycache__/predict_milk10k_effb2_dual_metadata.cpython-314.pyc b/milk10k_effb2_metadata/__pycache__/predict_milk10k_effb2_dual_metadata.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f701b787b1d57cb6267f2f694e12d07ca677223c Binary files /dev/null and b/milk10k_effb2_metadata/__pycache__/predict_milk10k_effb2_dual_metadata.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/__pycache__/train_milk10k_effb2_dual_metadata.cpython-314.pyc b/milk10k_effb2_metadata/__pycache__/train_milk10k_effb2_dual_metadata.cpython-314.pyc index 9a7cb0f115b95ac83a1bda2d29654b6b44b80f8c..efcf05096adb4bc4336a1ab06ba147107fac35d8 100644 Binary files a/milk10k_effb2_metadata/__pycache__/train_milk10k_effb2_dual_metadata.cpython-314.pyc and b/milk10k_effb2_metadata/__pycache__/train_milk10k_effb2_dual_metadata.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/datasets.py b/milk10k_effb2_metadata/datasets.py new file mode 100644 index 0000000000000000000000000000000000000000..745bbba7691dd8a1caf1f1450fe9cd267979fb72 --- /dev/null +++ b/milk10k_effb2_metadata/datasets.py @@ -0,0 +1,187 @@ +#!/usr/bin/env python3 +""" +MILK10k dataset utilities shared by training scripts. + +Keep dataframe construction and torch Dataset classes here; training scripts +should build transforms/loaders and own model/training logic. +""" + +from __future__ import annotations + +import os +import random +from pathlib import Path + +import numpy as np +import pandas as pd +import torch +from PIL import Image, ImageFile +from sklearn.model_selection import train_test_split +from torch.utils.data import Dataset + +ImageFile.LOAD_TRUNCATED_IMAGES = True + +REQUIRED_DATA_FILES = ( + "MILK10k_Training_GroundTruth.csv", + "MILK10k_Training_Metadata.csv", + "MILK10k_Training_Input", +) + +LABEL_COLUMNS = [ + "AKIEC", + "BCC", + "BEN_OTH", + "BKL", + "DF", + "INF", + "MAL_OTH", + "MEL", + "NV", + "SCCKA", + "VASC", +] + + +class Milk10kDataset(Dataset): + def __init__(self, df: pd.DataFrame, label_to_idx: dict[str, int], transform=None) -> None: + self.paths = df["path"].tolist() + self.labels = [label_to_idx[label] for label in df["label"].tolist()] + self.transform = transform + + def __len__(self) -> int: + return len(self.paths) + + def __getitem__(self, idx: int) -> tuple[torch.Tensor, int]: + with Image.open(self.paths[idx]) as img: + img = img.convert("RGB") + if self.transform is not None: + img = self.transform(img) + return img, self.labels[idx] + + +class PairedMilk10kDataset(Dataset): + def __init__(self, df: pd.DataFrame, label_to_idx: dict[str, int], transform=None) -> None: + self.clinical_paths = df["clinical_path"].tolist() + self.dermoscopic_paths = df["dermoscopic_path"].tolist() + self.labels = [label_to_idx[label] for label in df["label"].tolist()] + self.transform = transform + + def __len__(self) -> int: + return len(self.labels) + + def _load_image(self, path: str) -> torch.Tensor: + with Image.open(path) as img: + img = img.convert("RGB") + if self.transform is not None: + img = self.transform(img) + return img + + def __getitem__(self, idx: int) -> tuple[torch.Tensor, int]: + clinical = self._load_image(self.clinical_paths[idx]) + dermoscopic = self._load_image(self.dermoscopic_paths[idx]) + return torch.stack([clinical, dermoscopic], dim=0), self.labels[idx] + + +def set_seed(seed: int) -> None: + os.environ["PYTHONHASHSEED"] = str(seed) + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.benchmark = True + + +def normalize_image_type(image_type: str) -> str: + if image_type == "clinical: close-up": + return "clinical_close_up" + return image_type.replace(" ", "_").replace(":", "").replace("-", "_") + + +def has_milk10k_files(path: Path) -> bool: + return all((path / name).exists() for name in REQUIRED_DATA_FILES) + + +def resolve_data_dir(data_dir: Path | None) -> Path: + if data_dir is not None: + data_dir = data_dir.expanduser().resolve() + if not has_milk10k_files(data_dir): + expected = ", ".join(REQUIRED_DATA_FILES) + raise FileNotFoundError(f"--data-dir={data_dir} does not contain required MILK10k files: {expected}") + return data_dir + + candidates = [Path.cwd()] + kaggle_input = Path("/kaggle/input") + if kaggle_input.exists(): + candidates.extend(path.parent for path in kaggle_input.rglob("MILK10k_Training_GroundTruth.csv")) + + seen = set() + for candidate in candidates: + candidate = candidate.resolve() + if candidate in seen: + continue + seen.add(candidate) + if has_milk10k_files(candidate): + return candidate + + expected = ", ".join(REQUIRED_DATA_FILES) + raise FileNotFoundError( + f"Could not auto-detect MILK10k data dir. Pass --data-dir PATH containing: {expected}" + ) + + +def load_dataframe(data_dir: Path, image_type: str) -> pd.DataFrame: + input_dir = data_dir / "MILK10k_Training_Input" + gt = pd.read_csv(data_dir / "MILK10k_Training_GroundTruth.csv") + meta = pd.read_csv(data_dir / "MILK10k_Training_Metadata.csv") + + gt["label"] = gt[LABEL_COLUMNS].idxmax(axis=1) + df = meta.merge(gt[["lesion_id", "label"]], on="lesion_id", how="inner") + df["image_type_norm"] = df["image_type"].map(normalize_image_type) + + if image_type != "all": + df = df[df["image_type_norm"] == image_type].copy() + + df["path"] = df.apply(lambda r: input_dir / r["lesion_id"] / f"{r['isic_id']}.jpg", axis=1) + df = df[df["path"].map(lambda p: p.exists())].copy() + df["path"] = df["path"].map(str) + + if df.empty: + raise ValueError(f"No images found for image_type={image_type!r} under {input_dir}") + return df[["path", "label", "lesion_id", "isic_id", "image_type_norm"]] + + +def to_paired_lesion_dataframe(df: pd.DataFrame) -> pd.DataFrame: + clinical = ( + df[df["image_type_norm"] == "clinical_close_up"][["lesion_id", "path"]] + .rename(columns={"path": "clinical_path"}) + .drop_duplicates("lesion_id") + ) + dermoscopic = ( + df[df["image_type_norm"] == "dermoscopic"][["lesion_id", "path"]] + .rename(columns={"path": "dermoscopic_path"}) + .drop_duplicates("lesion_id") + ) + labels = df[["lesion_id", "label"]].drop_duplicates("lesion_id") + paired = labels.merge(clinical, on="lesion_id", how="inner").merge(dermoscopic, on="lesion_id", how="inner") + if paired.empty: + raise ValueError("No paired clinical/dermoscopic lesions found.") + return paired[["lesion_id", "label", "clinical_path", "dermoscopic_path"]] + + +def lesion_level_train_val_split( + df: pd.DataFrame, + val_size: float, + seed: int, +) -> tuple[pd.DataFrame, pd.DataFrame]: + lesion_df = df[["lesion_id", "label"]].drop_duplicates("lesion_id") + + train_lesions, val_lesions = train_test_split( + lesion_df, + test_size=val_size, + stratify=lesion_df["label"], + random_state=seed, + ) + + train_df = df[df["lesion_id"].isin(train_lesions["lesion_id"])].copy() + val_df = df[df["lesion_id"].isin(val_lesions["lesion_id"])].copy() + return train_df, val_df diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/MILK10K_EFFB2_METADATA_CLI.md b/milk10k_effb2_metadata/milk10k_effb2_metadata/MILK10K_EFFB2_METADATA_CLI.md new file mode 100644 index 0000000000000000000000000000000000000000..6ec8b106d6242b45f0feea9db0c872ececcd53af --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/MILK10K_EFFB2_METADATA_CLI.md @@ -0,0 +1,400 @@ +# MILK10k EffB2 Metadata CLI Commands + +Entrypoint: + +```bash +python train_milk10k_effb2_dual_metadata.py +``` + +Base checkpoints: + +```bash +--clinical-checkpoint best_effnetb2_ufes_clinical.pth \ +--dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt +``` + +## Code Map + +Training code is split by responsibility: + +```text +training.py Thin entry facade: normalize args, load dataframe, choose single run vs k-fold. +runner.py Full split runner: split CSVs, loaders, loss, train phases, final metrics/files. +engine.py Epoch/phase loop: run_epoch, train_phase, save best checkpoint. +model_setup.py Backend detection, model construction, resume checkpoint, optimizer param groups. +training_utils.py JSON-safe serialization, run_config.json, kfold_summary.csv/json. +``` + +Common places to edit: + +```text +Add/adjust training flow runner.py +Change epoch behavior engine.py +Change model/optimizer setup model_setup.py +Change output summaries training_utils.py +Change top-level CLI run training.py +``` + +## 1. Check CLI + +```bash +python train_milk10k_effb2_dual_metadata.py --help +``` + +## 2. Baseline + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --output-dir milk10k_effb2_baseline +``` + +## Metadata Fusion Options + +Keep the baseline concat fusion: + +```bash +--metadata-fusion concat +``` + +Use metadata as channel gates while still concatenating metadata into the classifier: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --metadata-fusion gated_concat \ + --output-dir milk10k_effb2_gated_concat +``` + +Use metadata only for channel gating, without direct metadata concat: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --metadata-fusion gated_only \ + --output-dir milk10k_effb2_gated_only +``` + +## Image Fusion Options + +Keep the current final representation concat: + +```bash +--image-fusion concat +``` + +Try the global feature fusion ideas from `archs_to_try.md`: + +```bash +--image-fusion cross_attention +--image-fusion co_attention +--image-fusion low_rank_bilinear +--image-fusion adaptive_gate +--image-fusion moe +--image-fusion shared_private +``` + +`compact_bilinear` remains accepted as a backward-compatible alias for the low-rank projected product fusion. + +Recommended first F1-focused run: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --image-fusion cross_attention \ + --loss ce_f1 \ + --f1-weight 0.5 \ + --f1-ignore-classes MAL_OTH \ + --output-dir milk10k_effb2_cross_attention_ce_f1_no_mal_oth +``` + +Swap `cross_attention` for `low_rank_bilinear`, `adaptive_gate`, or `moe` for the next ablations. + +Metadata fusion can be combined with every image fusion mode: + +```bash +--metadata-fusion concat +--metadata-fusion gated_concat +--metadata-fusion gated_only +``` + +Normal online image transforms keep the original metadata vector. If you materialize offline transform augmentations, duplicate the original row metadata unchanged. Do not invent metadata for generated synthetic lesions in this trainer; use real-row metadata or disable metadata for synthetic-only experiments. + +## 3. Class Weight Only + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --class-weight \ + --output-dir milk10k_effb2_class_weight +``` + +## 4. Weighted Sampler + +Start with mild sampling: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --weighted-sampler \ + --sampler-power 0.5 \ + --output-dir milk10k_effb2_sampler_p05 +``` + +Stronger sampling: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --weighted-sampler \ + --sampler-power 1.0 \ + --output-dir milk10k_effb2_sampler_p10 +``` + +## 5. Focal Loss + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --loss focal \ + --focal-gamma 2.0 \ + --output-dir milk10k_effb2_focal +``` + +Focal plus mild sampler: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --loss focal \ + --focal-gamma 2.0 \ + --weighted-sampler \ + --sampler-power 0.5 \ + --output-dir milk10k_effb2_focal_sampler_p05 +``` + +## 5b. F1-Priority Loss + +Optimize CE plus a differentiable soft macro-F1 auxiliary term: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --loss ce_f1 \ + --f1-weight 0.5 \ + --f1-ignore-classes MAL_OTH \ + --output-dir milk10k_effb2_ce_f1_no_mal_oth +``` + +Downweight a class instead of fully ignoring it: + +```bash +--f1-class-weight MAL_OTH=0.1 +``` + +## 6. LDAM + DRW Loss + +Recommended first run: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --loss ldam \ + --weighted-sampler \ + --sampler-power 0.5 \ + --output-dir milk10k_effb2_ldam_sampler_p05 +``` + +Without sampler: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --loss ldam \ + --output-dir milk10k_effb2_ldam +``` + +More conservative LDAM margin with delayed DRW: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --loss ldam \ + --ldam-max-margin 0.3 \ + --ldam-drw-start-epoch 8 \ + --weighted-sampler \ + --sampler-power 0.5 \ + --output-dir milk10k_effb2_ldam_conservative +``` + +Note: do not add `--class-weight` with `--loss ldam`; LDAM+DRW already uses effective-number alpha. + +## 7. K-Fold + +5-fold with recommended long-tail setup: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --loss ldam \ + --weighted-sampler \ + --sampler-power 0.5 \ + --k-folds 5 \ + --output-dir milk10k_effb2_ldam_kfold5 +``` + +Outputs: + +```text +milk10k_effb2_ldam_kfold5/ + fold_00/ + fold_01/ + fold_02/ + fold_03/ + fold_04/ + kfold_summary.csv + kfold_summary.json +``` + +## 8. Useful Training Flags + +```bash +--batch-size 8 +--image-size 260 +--freeze-epochs 8 +--finetune-epochs 20 +--head-lr 1e-4 +--encoder-lr 1e-5 +--weight-decay 1e-4 +--patience 6 +--amp +``` + +Example with AMP: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --loss ldam \ + --weighted-sampler \ + --sampler-power 0.5 \ + --amp \ + --output-dir milk10k_effb2_ldam_amp +``` + +## 9. Smoke Checks + +Syntax check: + +```bash +python -m py_compile train_milk10k_effb2_dual_metadata.py milk10k_effb2_metadata/*.py +``` + +Zero-epoch single split: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --freeze-epochs 0 \ + --finetune-epochs 0 \ + --loss ldam \ + --output-dir /tmp/milk10k_effb2_smoke_single +``` + +Zero-epoch k-fold: + +```bash +python train_milk10k_effb2_dual_metadata.py \ + --clinical-checkpoint best_effnetb2_ufes_clinical.pth \ + --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \ + --freeze-epochs 0 \ + --finetune-epochs 0 \ + --loss ldam \ + --k-folds 2 \ + --output-dir /tmp/milk10k_effb2_smoke_kfold +``` + +## 10. Files To Compare After Training + +Per run: + +```text +history.csv +metrics.json +per_class_metrics.csv +confusion_matrix.csv +val_predictions.csv +run_config.json +``` + +For minority classes, inspect these rows in `per_class_metrics.csv`: + +```text +BEN_OTH +DF +INF +MAL_OTH +VASC +``` + +## 11. Inference With best.pt + +Use the saved checkpoint directly. You do not need to pass the original branch checkpoints for inference because `best.pt` contains the full model state. + +```bash +python predict_milk10k_effb2_dual_metadata.py \ + --checkpoint milk10k_effb2_ldam_sampler_p05/best.pt \ + --data-dir /marimo/milk10k \ + --output milk10k_effb2_test_predictions.csv \ + --batch-size 16 \ + --image-size 384 \ + --num-workers 4 +``` + +By default, the output has no labels. If you explicitly pass `--groundtruth-csv`, the script also writes: + +```text +milk10k_effb2_test_predictions.metrics.json +``` + +For an unlabeled test set, pass image root and metadata CSV explicitly: + +```bash +python predict_milk10k_effb2_dual_metadata.py \ + --checkpoint milk10k_effb2_ldam_sampler_p05/best.pt \ + --input-dir /path/to/MILK10k_Test_Input \ + --metadata-csv /path/to/MILK10k_Test_Metadata.csv \ + --output milk10k_effb2_test_predictions.csv \ + --batch-size 16 \ + --image-size 384 \ + --num-workers 4 +``` + +Default output is submission-ready and includes only: + +```text +lesion_id +AKIEC ... VASC +``` + +For a local debug file with lesion IDs, file names, predicted label, and confidence, add: + +```bash +--include-debug-columns +``` diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__init__.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4b177b7643716beb9197ff1a6f13ddc082bcf679 --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/__init__.py @@ -0,0 +1,2 @@ +"""EfficientNet-B2 dual-branch MILK10k metadata trainer.""" + diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/__init__.cpython-310.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0896243fe721016e63775ed3d25d17e47ecb9d29 Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/__init__.cpython-310.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/__init__.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/__init__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f749dc60d0e290f7836d8c2c8f07bf1a4b3f8092 Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/__init__.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/checkpoints.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/checkpoints.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..887412cccb05670924444266c84da488c3cb550f Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/checkpoints.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/cli.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/cli.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce5cd31c5d096545450b3aed64e390174aea63b9 Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/cli.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/data.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/data.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..21fb58ebca7f90dfeb7195c920ab27911ac5ab8c Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/data.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/engine.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/engine.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e89b8d88db2be56d6410184d98bb075f99bc90d Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/engine.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/inference.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/inference.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ad0dfe1ca92a3387c3fd8474dab8695005431091 Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/inference.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/losses.cpython-310.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/losses.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dc43b0d3f3a6c7e77371155a67a730881f96634c Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/losses.cpython-310.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/losses.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/losses.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bf1619a2288cc0ee7b5d2b249d53d909ed360af1 Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/losses.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/metrics.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/metrics.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b5170ee786353b800dde0d44d791970638f4636a Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/metrics.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/model_setup.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/model_setup.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..de2a323440f202c195e1e1cdae98d765194a7b16 Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/model_setup.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/models.cpython-310.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/models.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d38b14cad04e5a63a1fd0ac34908ce69f8bcd187 Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/models.cpython-310.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/models.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/models.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4bf400dccd3d9408e5c8a9807985a89cac755036 Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/models.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/runner.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/runner.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2adad6e794c23dc4cb79c863489f74f2729433b2 Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/runner.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/train_milk10k_effb2_dual_metadata.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/train_milk10k_effb2_dual_metadata.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a40d0d3068febb913fda09370729e9b28c82eaf6 Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/train_milk10k_effb2_dual_metadata.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/training.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/training.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4771785a8235d1f0e3041cd34e2a5a092afb2400 Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/training.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/training_utils.cpython-314.pyc b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/training_utils.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dde1b437f9be4c34656fe7da71950094e28d21db Binary files /dev/null and b/milk10k_effb2_metadata/milk10k_effb2_metadata/__pycache__/training_utils.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/checkpoints.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/checkpoints.py new file mode 100644 index 0000000000000000000000000000000000000000..ca041bd29958b95380013b4c1ab77a377241a5b6 --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/checkpoints.py @@ -0,0 +1,94 @@ +"""Checkpoint loading utilities for mixed timm/torchvision EfficientNet-B2 branches.""" + +from __future__ import annotations + +import argparse +from pathlib import Path +from typing import Any + +import torch +from torch import nn + +CHECKPOINT_STATE_KEYS = ("model_state", "model_state_dict", "state_dict") +PREFIXES_TO_STRIP = ("module.", "model.", "_orig_mod.") + + +def extract_state_dict(checkpoint: Any) -> dict[str, torch.Tensor]: + if isinstance(checkpoint, dict): + for key in CHECKPOINT_STATE_KEYS: + value = checkpoint.get(key) + if isinstance(value, dict): + return value + if isinstance(checkpoint, dict) and all(torch.is_tensor(value) for value in checkpoint.values()): + return checkpoint + raise ValueError("Checkpoint does not contain a supported state dict.") + + +def load_raw_checkpoint(path: Path, device: torch.device, branch_name: str) -> Any: + if not path.exists(): + raise FileNotFoundError(f"{branch_name} checkpoint not found: {path}") + try: + return torch.load(path, map_location=device, weights_only=False) + except TypeError: + return torch.load(path, map_location=device) + + +def normalize_key(key: str) -> str: + changed = True + while changed: + changed = False + for prefix in PREFIXES_TO_STRIP: + if key.startswith(prefix): + key = key.removeprefix(prefix) + changed = True + return key + + +def infer_checkpoint_backend(path: Path, device: torch.device, branch_name: str) -> str: + checkpoint = load_raw_checkpoint(path, device, branch_name) + state = extract_state_dict(checkpoint) + keys = {normalize_key(key) for key in state} + timm_prefixes = ("conv_stem.", "bn1.", "blocks.", "conv_head.", "bn2.", "stages.", "stem.") + torchvision_prefixes = ("features.", "avgpool.", "classifier.") + timm_hits = sum(key.startswith(timm_prefixes) for key in keys) + torchvision_hits = sum(key.startswith(torchvision_prefixes) for key in keys) + if timm_hits > torchvision_hits: + return "timm" + if torchvision_hits > timm_hits: + return "torchvision" + if any(key.startswith("layer") for key in keys): + return "timm" + raise RuntimeError( + f"{branch_name}: cannot infer checkpoint backend from {path}. " + "Pass --backbone-backend timm or --backbone-backend torchvision explicitly." + ) + + +def resolve_backbone_backends(args: argparse.Namespace, device: torch.device) -> tuple[str, str]: + if args.backbone_backend != "auto": + return args.backbone_backend, args.backbone_backend + + clinical_backend = infer_checkpoint_backend(args.clinical_checkpoint, device, "clinical") + dermoscopic_backend = infer_checkpoint_backend(args.dermoscopic_checkpoint, device, "dermoscopic") + print(f"Auto-detected backbone backends: clinical={clinical_backend}, dermoscopic={dermoscopic_backend}") + return clinical_backend, dermoscopic_backend + + +def load_encoder_checkpoint(path: Path, encoder: nn.Module, branch_name: str, device: torch.device) -> None: + checkpoint = load_raw_checkpoint(path, device, branch_name) + raw_state = extract_state_dict(checkpoint) + source_state = {normalize_key(key): value for key, value in raw_state.items()} + target_state = encoder.state_dict() + matched = { + key: value + for key, value in source_state.items() + if key in target_state and tuple(value.shape) == tuple(target_state[key].shape) + } + skipped = len(source_state) - len(matched) + if not matched: + raise RuntimeError(f"{branch_name}: no matching encoder weights loaded from {path}") + + target_state.update(matched) + encoder.load_state_dict(target_state) + print(f"{branch_name}: loaded {len(matched)} keys from {path}; skipped {skipped} keys") + diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/cli.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/cli.py new file mode 100644 index 0000000000000000000000000000000000000000..0933fcff93ab77e5d39a989c822149dad5d91657 --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/cli.py @@ -0,0 +1,175 @@ +"""CLI for the EfficientNet-B2 dual metadata trainer.""" + +from __future__ import annotations + +import argparse +from pathlib import Path + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser(description="Train MILK10k dual EfficientNet-B2 with metadata fusion.") + parser.add_argument("--data-dir", type=Path, default=None) + parser.add_argument( + "--clinical-checkpoint", + type=Path, + default=None, + help="Optional clinical encoder checkpoint. If omitted, the clinical branch uses ImageNet-pretrained backbone weights.", + ) + parser.add_argument( + "--dermoscopic-checkpoint", + type=Path, + default=None, + help="Optional dermoscopic encoder checkpoint. If omitted, the dermoscopic branch uses ImageNet-pretrained backbone weights.", + ) + parser.add_argument( + "--resume-checkpoint", + type=Path, + default=None, + help="Resume model weights/best score from an EffB2 metadata checkpoint, usually output-dir/best.pt.", + ) + parser.add_argument("--output-dir", type=Path, default=Path("milk10k_dual_effb2_metadata_runs")) + parser.add_argument("--freeze-epochs", type=int, default=8) + parser.add_argument("--finetune-epochs", type=int, default=20) + parser.add_argument("--batch-size", type=int, default=8) + parser.add_argument("--image-size", type=int, default=None, help="Input image size. Defaults to backbone-specific optimal size if None.") + parser.add_argument( + "--backbone", + default="efficientnet_b2", + help="Backbone model architecture (efficientnet_b2, efficientnet_b1, resnet50, convnext_base).", + ) + parser.add_argument( + "--num-workers", + type=int, + default=0, + help="DataLoader workers. Keep 0 in small Docker/Marimo containers to avoid /dev/shm exhaustion.", + ) + parser.add_argument("--head-lr", type=float, default=1e-4) + parser.add_argument("--encoder-lr", type=float, default=1e-5) + parser.add_argument( + "--metadata-lr", + type=float, + default=None, + help="Optional LR for metadata_head and metadata gates. Defaults to --head-lr.", + ) + parser.add_argument( + "--metadata-fusion", + choices=["concat", "gated_concat", "gated_only"], + default="concat", + help="Metadata fusion mode. concat keeps the baseline; gated modes use metadata for channel gating.", + ) + parser.add_argument( + "--image-fusion", + choices=[ + "concat", + "cross_attention", + "co_attention", + "compact_bilinear", + "low_rank_bilinear", + "adaptive_gate", + "moe", + "shared_private", + ], + default="concat", + help="Image representation fusion mode. concat keeps the baseline final fusion.", + ) + parser.add_argument( + "--metadata-gate-hidden-dim", + type=int, + default=None, + help="Hidden dimension for metadata channel gates. Defaults to --metadata-dim.", + ) + parser.add_argument( + "--disable-metadata", + action="store_true", + help="Ignore metadata values by feeding zero metadata representation and all-one metadata gates.", + ) + parser.add_argument( + "--freeze-metadata-head", + action="store_true", + help="Freeze metadata_head and metadata gate parameters while still using their current outputs.", + ) + parser.add_argument("--weight-decay", type=float, default=1e-4) + parser.add_argument("--val-size", type=float, default=0.20) + parser.add_argument( + "--synthetic-train-only", + action="store_true", + help="Keep synthetic lesion IDs containing __sdpair_ in train only; validation is split from real lesions.", + ) + parser.add_argument("--seed", type=int, default=42) + parser.add_argument("--branch-dim", type=int, default=512) + parser.add_argument("--metadata-dim", type=int, default=64) + parser.add_argument("--classifier-hidden-dim", type=int, default=512) + parser.add_argument("--dropout", type=float, default=0.3) + parser.add_argument( + "--logit-fusion-mode", + choices=["single", "fixed"], + default="single", + help="single uses one fused classifier. fixed adds clinical/dermoscopic logits and mixes them with fixed weights.", + ) + parser.add_argument("--fusion-logit-weight", type=float, default=0.6) + parser.add_argument("--clinical-logit-weight", type=float, default=0.2) + parser.add_argument("--dermoscopic-logit-weight", type=float, default=0.2) + parser.add_argument("--class-weight", action="store_true") + parser.add_argument("--weighted-sampler", action="store_true") + parser.add_argument("--sampler-power", type=float, default=1.0) + parser.add_argument("--loss", choices=["ce", "focal", "ldam", "ce_dice", "ce_f1"], default="ce") + parser.add_argument("--focal-gamma", type=float, default=2.0) + parser.add_argument("--dice-weight", type=float, default=0.3) + parser.add_argument("--f1-weight", type=float, default=0.3) + parser.add_argument( + "--f1-ignore-classes", + nargs="*", + default=[], + help="Class names excluded from the soft macro-F1 auxiliary term, e.g. --f1-ignore-classes MAL_OTH.", + ) + parser.add_argument( + "--f1-class-weight", + action="append", + default=[], + help="Optional CLASS=VALUE override for the soft macro-F1 auxiliary term. Can be passed multiple times.", + ) + parser.add_argument("--ldam-beta", type=float, default=0.9999) + parser.add_argument("--ldam-max-margin", type=float, default=0.5) + parser.add_argument("--ldam-drw-start-epoch", type=int, default=0) + parser.add_argument("--ldam-alpha-max", type=float, default=10.0) + parser.add_argument( + "--tail-num-classes", + type=int, + default=4, + help="Number of lowest-support train classes to track for LDAM tail_best.pt.", + ) + parser.add_argument("--k-folds", type=int, default=1) + parser.add_argument("--amp", action="store_true") + parser.add_argument( + "--backbone-backend", + choices=["auto", "timm", "torchvision"], + default="auto", + help="Backbone implementation used by checkpoints. auto detects timm vs torchvision from checkpoint keys.", + ) + parser.add_argument( + "--imagenet-pretrained", + action="store_true", + help="Initialize backbones with ImageNet weights before loading any branch checkpoints. Enabled automatically when no branch checkpoints are passed.", + ) + parser.add_argument( + "--selection-metric", + choices=["f1_macro", "dice_macro"], + default="f1_macro", + help="Validation metric used for best.pt checkpoint selection and LR scheduling.", + ) + parser.add_argument( + "--calibrate-bias", + action="store_true", + help="Tune per-class logit biases on validation predictions after training and save calibration.json.", + ) + parser.add_argument( + "--calibration-metric", + choices=["f1_macro", "dice_macro"], + default="dice_macro", + help="Metric optimized by post-hoc class-bias calibration.", + ) + parser.add_argument("--calibration-max-bias", type=float, default=1.5) + parser.add_argument("--calibration-step", type=float, default=0.25) + parser.add_argument("--calibration-passes", type=int, default=3) + parser.add_argument("--patience", type=int, default=6) + return parser.parse_args() diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/data.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/data.py new file mode 100644 index 0000000000000000000000000000000000000000..18280e8278d5c3309d25807787869b5399200cfa --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/data.py @@ -0,0 +1,263 @@ +"""Dataframe, metadata, split, and dataloader helpers.""" + +from __future__ import annotations + +import argparse +from pathlib import Path +from typing import Any + +import numpy as np +import pandas as pd +import torch +from PIL import Image, ImageFile +from sklearn.model_selection import StratifiedKFold, train_test_split +from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler +from torchvision import transforms + +from datasets import LABEL_COLUMNS, normalize_image_type + +ImageFile.LOAD_TRUNCATED_IMAGES = True + +METADATA_COLUMNS = ("age_approx", "sex", "skin_tone_class", "site") + + +class PairedMilk10kMetadataDataset(Dataset): + def __init__( + self, + df: pd.DataFrame, + label_to_idx: dict[str, int], + metadata_spec: dict[str, Any], + transform=None, + ) -> None: + self.df = df.reset_index(drop=True) + self.labels = [label_to_idx[label] for label in self.df["label"].tolist()] + self.metadata = np.stack([metadata_vector(row, metadata_spec) for _, row in self.df.iterrows()]) + self.transform = transform + + def __len__(self) -> int: + return len(self.df) + + def _load_image(self, path: str) -> torch.Tensor: + with Image.open(path) as img: + image = img.convert("RGB") + if self.transform is not None: + image = self.transform(image) + return image + + def __getitem__(self, idx: int) -> dict[str, torch.Tensor]: + row = self.df.iloc[idx] + return { + "clinical": self._load_image(row["clinical_path"]), + "dermoscopic": self._load_image(row["dermoscopic_path"]), + "metadata": torch.from_numpy(self.metadata[idx]), + "label": torch.tensor(self.labels[idx], dtype=torch.long), + } + + +def load_paired_dataframe(data_dir: Path) -> pd.DataFrame: + input_dir = data_dir / "MILK10k_Training_Input" + gt = pd.read_csv(data_dir / "MILK10k_Training_GroundTruth.csv") + meta = pd.read_csv(data_dir / "MILK10k_Training_Metadata.csv") + monet_columns = resolve_monet_columns(meta) + + gt["label"] = gt[LABEL_COLUMNS].idxmax(axis=1) + meta["image_type_norm"] = meta["image_type"].map(normalize_image_type) + meta["path"] = meta.apply(lambda r: input_dir / r["lesion_id"] / f"{r['isic_id']}.jpg", axis=1) + meta = meta[meta["path"].map(lambda p: p.exists())].copy() + meta["path"] = meta["path"].map(str) + + keep = ["lesion_id", "path", *METADATA_COLUMNS, *monet_columns] + clinical = meta[meta["image_type_norm"] == "clinical_close_up"][keep].drop_duplicates("lesion_id") + dermoscopic = meta[meta["image_type_norm"] == "dermoscopic"][keep].drop_duplicates("lesion_id") + paired = ( + gt[["lesion_id", "label"]] + .merge(clinical.add_prefix("clinical_"), left_on="lesion_id", right_on="clinical_lesion_id") + .merge(dermoscopic.add_prefix("dermoscopic_"), left_on="lesion_id", right_on="dermoscopic_lesion_id") + .drop(columns=["clinical_lesion_id", "dermoscopic_lesion_id"]) + ) + if paired.empty: + raise ValueError(f"No paired clinical/dermoscopic lesions found under {input_dir}") + return paired + + +def resolve_monet_columns(meta: pd.DataFrame) -> list[str]: + try: + from milk10k_dual_encoder.config import MONET_COLUMNS + + configured = [column for column in MONET_COLUMNS if column in meta.columns] + if configured: + return configured + except Exception: + pass + return sorted(column for column in meta.columns if column.startswith("MONET_")) + + +def lesion_split(df: pd.DataFrame, val_size: float, seed: int) -> tuple[pd.DataFrame, pd.DataFrame]: + lesion_df = df[["lesion_id", "label"]].drop_duplicates("lesion_id") + train_lesions, val_lesions = train_test_split( + lesion_df, + test_size=val_size, + stratify=lesion_df["label"], + random_state=seed, + ) + return split_by_lesion_ids(df, train_lesions["lesion_id"], val_lesions["lesion_id"]) + + +def kfold_splits(df: pd.DataFrame, k_folds: int, seed: int) -> list[tuple[pd.DataFrame, pd.DataFrame]]: + if k_folds < 2: + raise ValueError("--k-folds must be 1 for single split or at least 2 for k-fold training.") + + lesion_df = df[["lesion_id", "label"]].drop_duplicates("lesion_id").reset_index(drop=True) + min_class_count = int(lesion_df["label"].value_counts().min()) + if k_folds > min_class_count: + raise ValueError( + f"--k-folds={k_folds} is larger than the smallest class count ({min_class_count}). " + "Use fewer folds or merge/remove ultra-rare classes." + ) + + splitter = StratifiedKFold(n_splits=k_folds, shuffle=True, random_state=seed) + splits = [] + for train_idx, val_idx in splitter.split(lesion_df["lesion_id"], lesion_df["label"]): + train_lesions = lesion_df.iloc[train_idx]["lesion_id"] + val_lesions = lesion_df.iloc[val_idx]["lesion_id"] + splits.append(split_by_lesion_ids(df, train_lesions, val_lesions)) + return splits + + +def split_by_lesion_ids( + df: pd.DataFrame, + train_lesions: pd.Series, + val_lesions: pd.Series, +) -> tuple[pd.DataFrame, pd.DataFrame]: + return ( + df[df["lesion_id"].isin(train_lesions)].copy(), + df[df["lesion_id"].isin(val_lesions)].copy(), + ) + + +def fit_metadata_spec(train_df: pd.DataFrame) -> dict[str, Any]: + sex_values = sorted({"unknown"} | collect_string_values(train_df, "sex")) + site_values = sorted({"unknown"} | collect_string_values(train_df, "site")) + return { + "sex_values": sex_values, + "site_values": site_values, + "monet_columns": infer_paired_monet_columns(train_df), + } + + +def collect_string_values(df: pd.DataFrame, field: str) -> set[str]: + values: set[str] = set() + for prefix in ("clinical", "dermoscopic"): + series = df[f"{prefix}_{field}"].fillna("unknown").astype(str).str.strip() + values.update(value if value else "unknown" for value in series.tolist()) + return values + + +def infer_paired_monet_columns(df: pd.DataFrame) -> list[str]: + clinical_prefix = "clinical_MONET_" + return sorted( + column.removeprefix("clinical_") + for column in df.columns + if column.startswith(clinical_prefix) and f"dermoscopic_{column.removeprefix('clinical_')}" in df.columns + ) + + +def metadata_vector(row: pd.Series, spec: dict[str, Any]) -> np.ndarray: + age = first_numeric(row, "age_approx") + skin_tone = first_numeric(row, "skin_tone_class") + sex = first_string(row, "sex") + site = first_string(row, "site") + + values: list[float] = [ + 0.0 if age is None else float(age) / 100.0, + 0.0 if skin_tone is None else float(skin_tone) / 6.0, + ] + values.extend(1.0 if sex == item else 0.0 for item in spec["sex_values"]) + values.extend(1.0 if site == item else 0.0 for item in spec["site_values"]) + + for prefix in ("clinical", "dermoscopic"): + for column in spec.get("monet_columns", []): + value = pd.to_numeric(row.get(f"{prefix}_{column}"), errors="coerce") + values.append(0.0 if pd.isna(value) else float(value)) + + return np.asarray(values, dtype=np.float32) + + +def first_numeric(row: pd.Series, field: str) -> float | None: + for prefix in ("clinical", "dermoscopic"): + value = pd.to_numeric(row.get(f"{prefix}_{field}"), errors="coerce") + if not pd.isna(value): + return float(value) + return None + + +def first_string(row: pd.Series, field: str) -> str: + for prefix in ("clinical", "dermoscopic"): + value = row.get(f"{prefix}_{field}") + if pd.notna(value): + value = str(value).strip() + if value: + return value + return "unknown" + + +def make_transforms(image_size: int): + normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) + eval_resize = round(image_size * 1.12) + train_transform = transforms.Compose( + [ + transforms.RandomResizedCrop(image_size, scale=(0.75, 1.0), ratio=(1.2, 1.45)), + transforms.RandomHorizontalFlip(), + transforms.RandomVerticalFlip(), + transforms.RandomRotation(20), + transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2), + transforms.ToTensor(), + normalize, + ] + ) + eval_transform = transforms.Compose( + [ + transforms.Resize(eval_resize), + transforms.CenterCrop(image_size), + transforms.ToTensor(), + normalize, + ] + ) + return train_transform, eval_transform + + +def make_loaders( + train_df: pd.DataFrame, + val_df: pd.DataFrame, + label_to_idx: dict[str, int], + metadata_spec: dict[str, Any], + args: argparse.Namespace, +) -> tuple[DataLoader, DataLoader]: + train_transform, eval_transform = make_transforms(args.image_size) + train_ds = PairedMilk10kMetadataDataset(train_df, label_to_idx, metadata_spec, train_transform) + val_ds = PairedMilk10kMetadataDataset(val_df, label_to_idx, metadata_spec, eval_transform) + common = dict( + batch_size=args.batch_size, + num_workers=args.num_workers, + pin_memory=torch.cuda.is_available(), + drop_last=False, + ) + sampler = build_weighted_sampler(train_ds, args) if args.weighted_sampler else None + train_loader = DataLoader(train_ds, shuffle=sampler is None, sampler=sampler, **common) + val_loader = DataLoader(val_ds, shuffle=False, **common) + return train_loader, val_loader + + +def build_weighted_sampler( + dataset: PairedMilk10kMetadataDataset, + args: argparse.Namespace, +) -> WeightedRandomSampler: + labels = np.asarray(dataset.labels) + counts = np.bincount(labels) + if np.any(counts == 0): + raise ValueError("Cannot build weighted sampler because at least one class has zero training samples.") + class_weights = 1.0 / np.power(counts.astype(np.float64), args.sampler_power) + sample_weights = torch.as_tensor(class_weights[labels], dtype=torch.double) + generator = torch.Generator() + generator.manual_seed(args.seed) + return WeightedRandomSampler(sample_weights, num_samples=len(dataset), replacement=True, generator=generator) diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/engine.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/engine.py new file mode 100644 index 0000000000000000000000000000000000000000..20df4ea6a286d16f98dfae953dfafca5a3f1cd61 --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/engine.py @@ -0,0 +1,323 @@ +"""Epoch and phase execution for metadata model training.""" + +from __future__ import annotations + +import argparse +from pathlib import Path +from typing import Any + +import numpy as np +import pandas as pd +import torch +from sklearn.metrics import balanced_accuracy_score, confusion_matrix, precision_recall_fscore_support +from torch import nn +from torch.amp import GradScaler, autocast +from torch.utils.data import DataLoader +from tqdm.auto import tqdm + +from milk10k_effb2_metadata.metrics import macro_dice_from_confusion_matrix, move_batch +from milk10k_effb2_metadata.model_setup import build_optimizer +from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier, set_encoder_trainable +from milk10k_effb2_metadata.training_utils import json_safe + + +def metric_name(label: str) -> str: + return "".join(char if char.isalnum() else "_" for char in label).strip("_") + + +def run_epoch( + model: DualEffB2MetadataClassifier, + loader: DataLoader, + criterion: nn.Module, + device: torch.device, + optimizer: torch.optim.Optimizer | None = None, + scaler: GradScaler | None = None, + use_amp: bool = False, + tail_class_indices: list[int] | None = None, + class_names: list[str] | None = None, +) -> dict[str, float]: + training = optimizer is not None + model.train(training) + total_loss = 0.0 + correct = 0 + top3_correct = 0 + total = 0 + preds_all = [] + labels_all = [] + + for batch in tqdm(loader, leave=False): + clinical, dermoscopic, metadata, labels = move_batch(batch, device) + if training: + optimizer.zero_grad(set_to_none=True) + + with torch.set_grad_enabled(training): + with autocast("cuda", enabled=use_amp): + logits = model(clinical, dermoscopic, metadata) + loss = criterion(logits, labels) + if training: + if scaler is not None and use_amp: + scaler.scale(loss).backward() + scaler.unscale_(optimizer) + torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) + scaler.step(optimizer) + scaler.update() + else: + loss.backward() + torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) + optimizer.step() + + batch_size = labels.size(0) + total_loss += float(loss.detach().item()) * batch_size + correct += (logits.argmax(dim=1) == labels).sum().item() + topk = min(3, logits.size(1)) + top3_correct += logits.topk(topk, dim=1).indices.eq(labels[:, None]).any(dim=1).sum().item() + total += batch_size + preds_all.append(logits.argmax(dim=1).detach().cpu().numpy()) + labels_all.append(labels.detach().cpu().numpy()) + + y_pred = np.concatenate(preds_all) if preds_all else np.array([]) + y_true = np.concatenate(labels_all) if labels_all else np.array([]) + + stats = { + "loss": total_loss / max(total, 1), + "accuracy": correct / max(total, 1), + "balanced_accuracy": float(balanced_accuracy_score(y_true, y_pred)) if total else 0.0, + "f1_macro": float(precision_recall_fscore_support(y_true, y_pred, average="macro", zero_division=0)[2]) if total else 0.0, + "top3_accuracy": top3_correct / max(total, 1), + } + if total and class_names: + labels = list(range(len(class_names))) + precision, recall, f1, support = precision_recall_fscore_support( + y_true, + y_pred, + labels=labels, + average=None, + zero_division=0, + ) + cm = confusion_matrix(y_true, y_pred, labels=labels) + stats["dice_macro"] = macro_dice_from_confusion_matrix(cm) + for idx, class_name in enumerate(class_names): + name = metric_name(class_name) + row_total = int(cm[idx, :].sum()) + stats[f"support_{name}"] = float(support[idx]) + stats[f"precision_{name}"] = float(precision[idx]) + stats[f"recall_{name}"] = float(recall[idx]) + stats[f"f1_{name}"] = float(f1[idx]) + stats[f"correct_{name}"] = float(cm[idx, idx]) + for pred_idx, pred_name in enumerate(class_names): + if pred_idx == idx: + continue + count = int(cm[idx, pred_idx]) + if count <= 0: + continue + pred_metric = metric_name(pred_name) + stats[f"conf_{name}_to_{pred_metric}_count"] = float(count) + stats[f"conf_{name}_to_{pred_metric}_rate"] = count / row_total if row_total else 0.0 + if tail_class_indices: + recalls = precision_recall_fscore_support( + y_true, + y_pred, + labels=tail_class_indices, + average=None, + zero_division=0, + )[1] + stats["tail_recall_macro"] = float(np.mean(recalls)) if len(recalls) else 0.0 + return stats + + +def format_class_diagnostics(stats: dict[str, float], class_name: str, class_names: list[str]) -> str: + name = metric_name(class_name) + support = int(stats.get(f"support_{name}", 0.0)) + correct = int(stats.get(f"correct_{name}", 0.0)) + recall = stats.get(f"recall_{name}", 0.0) + precision = stats.get(f"precision_{name}", 0.0) + f1 = stats.get(f"f1_{name}", 0.0) + wrongs = [] + for pred_name in class_names: + if pred_name == class_name: + continue + pred_metric = metric_name(pred_name) + count = int(stats.get(f"conf_{name}_to_{pred_metric}_count", 0.0)) + if count > 0: + rate = stats.get(f"conf_{name}_to_{pred_metric}_rate", 0.0) + wrongs.append((count, pred_name, rate)) + wrongs.sort(reverse=True) + wrong_text = ", ".join(f"{pred}={count} ({rate:.0%})" for count, pred, rate in wrongs[:3]) or "none" + return ( + f"{class_name}: n={support} correct={correct} recall={recall:.3f} " + f"precision={precision:.3f} f1={f1:.3f} wrong_to=[{wrong_text}]" + ) + + +def save_checkpoint( + path: Path, + model: DualEffB2MetadataClassifier, + optimizer: torch.optim.Optimizer, + epoch: int, + phase: str, + best_val_f1: float, + class_names: list[str], + label_to_idx: dict[str, int], + metadata_spec: dict[str, Any], + args: argparse.Namespace, + extra: dict[str, Any] | None = None, +) -> None: + payload = { + "epoch": epoch, + "phase": phase, + "model_state": model.state_dict(), + "optimizer_state": optimizer.state_dict(), + "best_val_f1_macro": best_val_f1, + "best_selection_metric": best_val_f1, + "selection_metric_name": args.selection_metric, + "class_names": class_names, + "label_to_idx": label_to_idx, + "metadata_spec": metadata_spec, + "args": json_safe(vars(args)), + } + if extra: + payload.update(json_safe(extra)) + torch.save(payload, path) + + +def train_phase( + phase: str, + num_epochs: int, + start_epoch: int, + model: DualEffB2MetadataClassifier, + train_loader: DataLoader, + val_loader: DataLoader, + criterion: nn.Module, + device: torch.device, + args: argparse.Namespace, + class_names: list[str], + label_to_idx: dict[str, int], + metadata_spec: dict[str, Any], + output_dir: Path, + history: list[dict[str, Any]], + best_val_f1: float, + skip_until_epoch: int = 1, + tail_class_indices: list[int] | None = None, + tail_class_names: list[str] | None = None, + train_class_counts: dict[str, int] | None = None, + best_val_tail_recall: float = float("-inf"), +) -> tuple[int, float, float]: + if num_epochs <= 0: + return start_epoch, best_val_f1, best_val_tail_recall + + encoders_trainable = phase == "finetune" + set_encoder_trainable(model, encoders_trainable) + optimizer = build_optimizer(model, args, encoders_trainable) + scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode="max", factor=0.2, patience=2) + scaler = GradScaler("cuda", enabled=args.amp and device.type == "cuda") + use_amp = args.amp and device.type == "cuda" + patience_count = 0 + + print(f"\nPhase: {phase}, epochs={num_epochs}, encoders_trainable={encoders_trainable}") + for local_epoch in range(1, num_epochs + 1): + epoch = start_epoch + local_epoch - 1 + if epoch < skip_until_epoch: + print(f"Skipping already completed {phase} epoch {epoch:03d}") + continue + if hasattr(criterion, "set_epoch"): + criterion.set_epoch(epoch) + train_stats = run_epoch( + model, + train_loader, + criterion, + device, + optimizer, + scaler, + use_amp, + tail_class_indices, + class_names, + ) + val_stats = run_epoch( + model, + val_loader, + criterion, + device, + tail_class_indices=tail_class_indices, + class_names=class_names, + ) + selection_metric = args.selection_metric + scheduler.step(val_stats[selection_metric]) + row = { + "phase": phase, + "epoch": epoch, + **{f"train_{key}": value for key, value in train_stats.items()}, + **{f"val_{key}": value for key, value in val_stats.items()}, + } + history.append(row) + pd.DataFrame(history).to_csv(output_dir / "history.csv", index=False) + print( + f"{phase} epoch {epoch:03d}: " + f"train_loss={train_stats['loss']:.4f} val_loss={val_stats['loss']:.4f} " + f"train_bal_acc={train_stats['balanced_accuracy']:.4f} train_f1={train_stats['f1_macro']:.4f} " + f"val_acc={val_stats['accuracy']:.4f} val_bal_acc={val_stats['balanced_accuracy']:.4f} " + f"val_f1={val_stats['f1_macro']:.4f} val_dice={val_stats.get('dice_macro', 0.0):.4f} " + f"val_top3={val_stats['top3_accuracy']:.4f}" + ) + if tail_class_indices: + print( + f"LDAM tail: classes={tail_class_names} " + f"train_tail_recall={train_stats['tail_recall_macro']:.4f} " + f"val_tail_recall={val_stats['tail_recall_macro']:.4f}" + ) + for class_name in tail_class_names or []: + print(f" train {format_class_diagnostics(train_stats, class_name, class_names)}") + print(f" val {format_class_diagnostics(val_stats, class_name, class_names)}") + + if val_stats[selection_metric] > best_val_f1: + best_val_f1 = val_stats[selection_metric] + patience_count = 0 + save_checkpoint( + output_dir / "best.pt", + model, + optimizer, + epoch, + phase, + best_val_f1, + class_names, + label_to_idx, + metadata_spec, + args, + ) + print( + f"Saved best checkpoint: phase={phase} epoch={epoch:03d} " + f"best_{selection_metric}={best_val_f1:.4f} path={output_dir / 'best.pt'}" + ) + else: + patience_count += 1 + + if tail_class_indices and val_stats["tail_recall_macro"] > best_val_tail_recall: + best_val_tail_recall = val_stats["tail_recall_macro"] + save_checkpoint( + output_dir / "tail_best.pt", + model, + optimizer, + epoch, + phase, + best_val_f1, + class_names, + label_to_idx, + metadata_spec, + args, + { + "best_val_tail_recall_macro": best_val_tail_recall, + "tail_class_names": tail_class_names or [], + "tail_class_indices": tail_class_indices, + "train_class_counts": train_class_counts or {}, + "selection_metric": "val_tail_recall_macro", + }, + ) + print( + f"Saved tail checkpoint: phase={phase} epoch={epoch:03d} " + f"best_val_tail_recall_macro={best_val_tail_recall:.4f} path={output_dir / 'tail_best.pt'}" + ) + + if patience_count >= args.patience: + print(f"Early stopping {phase} at epoch {epoch}") + break + + return epoch + 1, best_val_f1, best_val_tail_recall diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/inference.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/inference.py new file mode 100644 index 0000000000000000000000000000000000000000..b961b7ffd7521255919846ebdcc9baebaa7c201d --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/inference.py @@ -0,0 +1,333 @@ +"""Inference CLI for EffB2 dual metadata checkpoints.""" + +from __future__ import annotations + +import argparse +import json +from pathlib import Path +from typing import Any + +import numpy as np +import pandas as pd +import torch +from PIL import Image +from torch.utils.data import DataLoader, Dataset +from tqdm.auto import tqdm + +from datasets import LABEL_COLUMNS, normalize_image_type +from milk10k_effb2_metadata.data import METADATA_COLUMNS, make_transforms, metadata_vector, resolve_monet_columns +from milk10k_effb2_metadata.metrics import apply_class_bias, compute_metrics +from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier +from milk10k_effb2_metadata.training import json_safe + + +class InferencePairedDataset(Dataset): + def __init__(self, df: pd.DataFrame, metadata_spec: dict[str, Any], transform=None) -> None: + self.df = df.reset_index(drop=True) + self.metadata = np.stack([metadata_vector(row, metadata_spec) for _, row in self.df.iterrows()]) + self.transform = transform + + def __len__(self) -> int: + return len(self.df) + + def _load_image(self, path: str) -> torch.Tensor: + with Image.open(path) as img: + image = img.convert("RGB") + if self.transform is not None: + image = self.transform(image) + return image + + def __getitem__(self, idx: int) -> dict[str, torch.Tensor]: + row = self.df.iloc[idx] + return { + "clinical": self._load_image(row["clinical_path"]), + "dermoscopic": self._load_image(row["dermoscopic_path"]), + "metadata": torch.from_numpy(self.metadata[idx]), + } + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser(description="Run inference with a MILK10k dual EffB2 metadata checkpoint.") + parser.add_argument("--checkpoint", type=Path, nargs="*", default=None, help="One or more checkpoint paths.") + parser.add_argument( + "--checkpoint-dir", + type=Path, + default=None, + help="Optional run directory. If it contains fold_*/best.pt those checkpoints are ensembled; otherwise uses best.pt in the directory.", + ) + parser.add_argument("--data-dir", type=Path, default=None, help="Directory containing MILK10k input/metadata files.") + parser.add_argument("--input-dir", type=Path, default=None, help="Image root. Overrides --data-dir/MILK10k_Training_Input.") + parser.add_argument("--metadata-csv", type=Path, default=None, help="Metadata CSV. Overrides --data-dir/MILK10k_Training_Metadata.csv.") + parser.add_argument("--groundtruth-csv", type=Path, default=None, help="Optional ground-truth CSV for metrics.") + parser.add_argument("--output", type=Path, default=Path("test_predictions.csv")) + parser.add_argument("--batch-size", type=int, default=16) + parser.add_argument("--image-size", type=int, default=None, help="Defaults to checkpoint args image_size.") + parser.add_argument("--num-workers", type=int, default=0) + parser.add_argument("--tta-flips", action="store_true", help="Average original, H-flip, V-flip, and HV-flip predictions.") + parser.add_argument( + "--calibration-file", + type=Path, + default=None, + help="Optional calibration.json override. By default calibration.json next to each checkpoint is loaded automatically.", + ) + parser.add_argument("--no-auto-calibration", action="store_true", help="Disable auto-loading calibration.json next to checkpoints.") + parser.add_argument("--include-debug-columns", action="store_true", help="Include lesion/file IDs and predicted labels before class probabilities.") + return parser.parse_args() + + +def load_inference_dataframe( + input_dir: Path, + metadata_csv: Path, + groundtruth_csv: Path | None, +) -> pd.DataFrame: + meta = pd.read_csv(metadata_csv) + monet_columns = resolve_monet_columns(meta) + meta["image_type_norm"] = meta["image_type"].map(normalize_image_type) + meta["path"] = meta.apply(lambda r: input_dir / r["lesion_id"] / f"{r['isic_id']}.jpg", axis=1) + meta = meta[meta["path"].map(lambda p: p.exists())].copy() + meta["path"] = meta["path"].map(str) + + keep = ["lesion_id", "isic_id", "path", *METADATA_COLUMNS, *monet_columns] + if "id" in meta.columns: + keep.insert(0, "id") + clinical = meta[meta["image_type_norm"] == "clinical_close_up"][keep].drop_duplicates("lesion_id") + dermoscopic = meta[meta["image_type_norm"] == "dermoscopic"][keep].drop_duplicates("lesion_id") + paired = ( + clinical.add_prefix("clinical_") + .merge(dermoscopic.add_prefix("dermoscopic_"), left_on="clinical_lesion_id", right_on="dermoscopic_lesion_id") + .rename(columns={"clinical_lesion_id": "lesion_id"}) + .drop(columns=["dermoscopic_lesion_id"]) + ) + if "clinical_id" in paired.columns: + paired["id"] = paired["clinical_id"] + + if groundtruth_csv is not None and groundtruth_csv.exists(): + gt = pd.read_csv(groundtruth_csv) + gt["label"] = gt[LABEL_COLUMNS].idxmax(axis=1) + paired = paired.merge(gt[["lesion_id", "label"]], on="lesion_id", how="left") + + if paired.empty: + raise ValueError(f"No paired clinical/dermoscopic lesions found under {input_dir}") + return paired + + +def resolve_input_paths(args: argparse.Namespace) -> tuple[Path, Path, Path | None]: + if args.data_dir is None and (args.input_dir is None or args.metadata_csv is None): + raise ValueError("Pass --data-dir, or pass both --input-dir and --metadata-csv.") + + data_dir = args.data_dir.expanduser().resolve() if args.data_dir is not None else None + input_dir = args.input_dir or data_dir / "MILK10k_Training_Input" + metadata_csv = args.metadata_csv or data_dir / "MILK10k_Training_Metadata.csv" + groundtruth_csv = args.groundtruth_csv + return input_dir.expanduser().resolve(), metadata_csv.expanduser().resolve(), groundtruth_csv + + +def infer_backend_from_model_state(state: dict[str, torch.Tensor], branch_prefix: str) -> str: + keys = [key.removeprefix(branch_prefix) for key in state if key.startswith(branch_prefix)] + timm_prefixes = ("conv_stem.", "bn1.", "blocks.", "conv_head.", "bn2.", "stages.", "stem.") + torchvision_prefixes = ("features.", "avgpool.", "classifier.") + timm_hits = sum(key.startswith(timm_prefixes) for key in keys) + torchvision_hits = sum(key.startswith(torchvision_prefixes) for key in keys) + if timm_hits > torchvision_hits: + return "timm" + if torchvision_hits > timm_hits: + return "torchvision" + if any(key.startswith("layer") for key in keys): + return "timm" + raise RuntimeError(f"Cannot infer backend for checkpoint branch prefix {branch_prefix!r}.") + + +def checkpoint_arg(checkpoint_args: dict[str, Any], key: str, default: Any) -> Any: + value = checkpoint_args.get(key, default) + if isinstance(default, bool): + return bool(value) + if isinstance(default, int): + return int(value) + if isinstance(default, float): + return float(value) + return value + + +def resolve_checkpoint_paths(args: argparse.Namespace) -> list[Path]: + checkpoint_paths = [path.expanduser().resolve() for path in (args.checkpoint or [])] + if args.checkpoint_dir is not None: + checkpoint_dir = args.checkpoint_dir.expanduser().resolve() + fold_paths = sorted(path for path in checkpoint_dir.glob("fold_*/best.pt") if path.is_file()) + if fold_paths: + checkpoint_paths.extend(fold_paths) + else: + best_path = checkpoint_dir / "best.pt" + if best_path.is_file(): + checkpoint_paths.append(best_path) + if not checkpoint_paths: + raise ValueError("Pass --checkpoint, or pass --checkpoint-dir containing best.pt or fold_*/best.pt.") + return checkpoint_paths + + +def build_model_from_checkpoint(checkpoint: dict[str, Any], metadata_dim: int, device: torch.device) -> DualEffB2MetadataClassifier: + state = checkpoint["model_state"] + checkpoint_args = checkpoint.get("args", {}) + class_names = checkpoint["class_names"] + clinical_backend = infer_backend_from_model_state(state, "clinical_encoder.") + dermoscopic_backend = infer_backend_from_model_state(state, "dermoscopic_encoder.") + model = DualEffB2MetadataClassifier( + num_classes=len(class_names), + metadata_input_dim=metadata_dim, + branch_dim=checkpoint_arg(checkpoint_args, "branch_dim", 512), + metadata_dim=checkpoint_arg(checkpoint_args, "metadata_dim", 64), + classifier_hidden_dim=checkpoint_arg(checkpoint_args, "classifier_hidden_dim", 512), + dropout=checkpoint_arg(checkpoint_args, "dropout", 0.3), + imagenet_pretrained=False, + clinical_backbone_backend=clinical_backend, + dermoscopic_backbone_backend=dermoscopic_backend, + backbone=checkpoint_arg(checkpoint_args, "backbone", "efficientnet_b2"), + disable_metadata=checkpoint_arg(checkpoint_args, "disable_metadata", False), + metadata_fusion=checkpoint_arg(checkpoint_args, "metadata_fusion", "concat"), + image_fusion=checkpoint_arg(checkpoint_args, "image_fusion", "concat"), + metadata_gate_hidden_dim=checkpoint_args.get("metadata_gate_hidden_dim"), + logit_fusion_mode=checkpoint_arg(checkpoint_args, "logit_fusion_mode", "single"), + fusion_logit_weight=checkpoint_arg(checkpoint_args, "fusion_logit_weight", 0.6), + clinical_logit_weight=checkpoint_arg(checkpoint_args, "clinical_logit_weight", 0.2), + dermoscopic_logit_weight=checkpoint_arg(checkpoint_args, "dermoscopic_logit_weight", 0.2), + ).to(device) + model.load_state_dict(state) + model.eval() + return model + + +@torch.no_grad() +def predict_dataframe(model: DualEffB2MetadataClassifier, loader: DataLoader, device: torch.device, tta_flips: bool = False) -> np.ndarray: + probs_all = [] + for batch in tqdm(loader, leave=False): + clinical = batch["clinical"].to(device, non_blocking=True) + dermoscopic = batch["dermoscopic"].to(device, non_blocking=True) + metadata = batch["metadata"].to(device, non_blocking=True) + views = [(clinical, dermoscopic)] + if tta_flips: + views.extend( + [ + (torch.flip(clinical, dims=(-1,)), torch.flip(dermoscopic, dims=(-1,))), + (torch.flip(clinical, dims=(-2,)), torch.flip(dermoscopic, dims=(-2,))), + (torch.flip(clinical, dims=(-2, -1)), torch.flip(dermoscopic, dims=(-2, -1))), + ] + ) + probs = None + for clinical_view, dermoscopic_view in views: + logits = model(clinical_view, dermoscopic_view, metadata) + view_prob = torch.softmax(logits, dim=1) + probs = view_prob if probs is None else probs + view_prob + probs_all.append((probs / len(views)).cpu().numpy()) + return np.concatenate(probs_all) + + +def load_calibration_bias( + checkpoint_path: Path, + args: argparse.Namespace, + expected_class_names: list[str], +) -> np.ndarray | None: + if args.calibration_file is not None: + calibration_path = args.calibration_file.expanduser().resolve() + elif args.no_auto_calibration: + return None + else: + calibration_path = checkpoint_path.parent / "calibration.json" + if not calibration_path.exists(): + return None + with open(calibration_path, encoding="utf-8") as f: + payload = json.load(f) + class_names = payload.get("class_names", []) + if class_names != expected_class_names: + raise ValueError( + f"Calibration class_names mismatch for {calibration_path}: " + f"expected {expected_class_names}, got {class_names}" + ) + return np.asarray(payload["class_bias"], dtype=np.float32) + + +def save_inference_outputs( + df: pd.DataFrame, + y_prob: np.ndarray, + class_names: list[str], + output: Path, + include_debug_columns: bool = False, +) -> None: + probability_df = pd.DataFrame(y_prob, columns=class_names) + probability_df.insert(0, "lesion_id", df["lesion_id"].tolist()) + output.parent.mkdir(parents=True, exist_ok=True) + if not include_debug_columns: + probability_df.to_csv(output, index=False) + return + + y_pred = y_prob.argmax(axis=1) + prediction_df = pd.DataFrame( + { + "lesion_id": df["lesion_id"].tolist(), + "clinical_file": [Path(path).name for path in df["clinical_path"].tolist()], + "dermoscopic_file": [Path(path).name for path in df["dermoscopic_path"].tolist()], + "clinical_isic_id": df.get("clinical_isic_id", pd.Series([""] * len(df))).tolist(), + "dermoscopic_isic_id": df.get("dermoscopic_isic_id", pd.Series([""] * len(df))).tolist(), + "y_pred": y_pred, + "label_pred": [class_names[idx] for idx in y_pred], + "confidence": y_prob.max(axis=1), + } + ) + if "label" in df.columns: + prediction_df["label_true"] = df["label"].tolist() + pd.concat([prediction_df, probability_df], axis=1).to_csv(output, index=False) + + +def main() -> None: + args = parse_args() + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + input_dir, metadata_csv, groundtruth_csv = resolve_input_paths(args) + df = load_inference_dataframe(input_dir, metadata_csv, groundtruth_csv) + checkpoint_paths = resolve_checkpoint_paths(args) + ensemble_probs = [] + class_names: list[str] | None = None + + for checkpoint_path in checkpoint_paths: + checkpoint = torch.load(checkpoint_path, map_location=device, weights_only=False) + checkpoint_class_names = checkpoint["class_names"] + if class_names is None: + class_names = checkpoint_class_names + elif checkpoint_class_names != class_names: + raise ValueError( + f"Checkpoint class_names mismatch: expected {class_names}, got {checkpoint_class_names} from {checkpoint_path}" + ) + checkpoint_args = checkpoint.get("args", {}) + image_size = args.image_size or int(checkpoint_args.get("image_size", 260)) + _, eval_transform = make_transforms(image_size) + dataset = InferencePairedDataset(df, checkpoint["metadata_spec"], eval_transform) + loader = DataLoader( + dataset, + batch_size=args.batch_size, + num_workers=args.num_workers, + pin_memory=torch.cuda.is_available(), + shuffle=False, + ) + model = build_model_from_checkpoint(checkpoint, dataset.metadata.shape[1], device) + y_prob = predict_dataframe(model, loader, device, tta_flips=args.tta_flips) + class_bias = load_calibration_bias(checkpoint_path, args, checkpoint_class_names) + if class_bias is not None: + y_prob = apply_class_bias(y_prob, class_bias) + ensemble_probs.append(y_prob) + + assert class_names is not None + y_prob = np.mean(ensemble_probs, axis=0) + save_inference_outputs(df, y_prob, class_names, args.output, args.include_debug_columns) + + print(f"Saved predictions: {args.output}") + if "label" in df.columns and df["label"].notna().all(): + label_to_idx = {label: idx for idx, label in enumerate(class_names)} + y_true = np.array([label_to_idx[label] for label in df["label"]]) + metrics, _, _ = compute_metrics(y_true, y_prob, class_names) + metrics_path = args.output.with_suffix(".metrics.json") + with open(metrics_path, "w", encoding="utf-8") as f: + import json + + json.dump(json_safe(metrics), f, indent=2) + print(f"Saved metrics: {metrics_path}") + + +if __name__ == "__main__": + main() diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/losses.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/losses.py new file mode 100644 index 0000000000000000000000000000000000000000..a9f264a556310e3492c808a55e3091fda8b37a01 --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/losses.py @@ -0,0 +1,189 @@ +"""Classification losses for the EffB2 metadata trainer.""" + +from __future__ import annotations + +import argparse + +import numpy as np +import pandas as pd +import torch +import torch.nn.functional as F +from sklearn.utils.class_weight import compute_class_weight +from torch import nn + + +class FocalLoss(nn.Module): + def __init__(self, weight: torch.Tensor | None = None, gamma: float = 2.0) -> None: + super().__init__() + self.weight = weight + self.gamma = gamma + + def forward(self, logits: torch.Tensor, labels: torch.Tensor) -> torch.Tensor: + ce = F.cross_entropy(logits, labels, reduction="none") + pt = torch.exp(-ce) + loss = (1.0 - pt) ** self.gamma * ce + if self.weight is not None: + loss = loss * self.weight[labels] + return loss.mean() + + +class LDAMLoss(nn.Module): + """LDAM with deferred effective-number reweighting.""" + + def __init__( + self, + class_counts: torch.Tensor, + beta: float = 0.9999, + max_margin: float = 0.5, + deferred_start_epoch: int = 0, + alpha_max: float = 10.0, + ) -> None: + super().__init__() + counts = class_counts.float().clamp_min(1.0) + margins = 1.0 / torch.sqrt(torch.sqrt(counts)) + margins = margins * (max_margin / margins.max().clamp_min(1e-12)) + alpha = effective_number_alpha(counts, beta) + alpha = alpha.clamp(max=alpha_max) + alpha = alpha * (counts.numel() / alpha.sum().clamp_min(1e-12)) + + self.register_buffer("margins", margins) + self.register_buffer("alpha", alpha) + self.deferred_start_epoch = deferred_start_epoch + self.current_epoch = 0 + + def set_epoch(self, epoch: int) -> None: + self.current_epoch = epoch + + def forward(self, logits: torch.Tensor, labels: torch.Tensor) -> torch.Tensor: + margins = self.margins.to(device=logits.device, dtype=logits.dtype) + alpha = self.alpha.to(device=logits.device, dtype=logits.dtype) + adjusted_logits = logits.clone() + rows = torch.arange(labels.size(0), device=labels.device) + adjusted_logits[rows, labels] = adjusted_logits[rows, labels] - margins[labels] + loss = F.cross_entropy(adjusted_logits, labels, reduction="none") + if self.current_epoch >= self.deferred_start_epoch: + loss = loss * alpha[labels] + return loss.mean() + + +class SoftMacroDiceLoss(nn.Module): + def __init__(self, eps: float = 1e-6) -> None: + super().__init__() + self.eps = eps + + def forward(self, logits: torch.Tensor, labels: torch.Tensor) -> torch.Tensor: + probs = torch.softmax(logits, dim=1) + one_hot = F.one_hot(labels, num_classes=logits.size(1)).to(dtype=probs.dtype) + intersection = (probs * one_hot).sum(dim=0) + denominator = probs.sum(dim=0) + one_hot.sum(dim=0) + dice = (2.0 * intersection + self.eps) / (denominator + self.eps) + return 1.0 - dice.mean() + + +class SoftMacroF1Loss(nn.Module): + def __init__(self, class_weights: torch.Tensor | None = None, eps: float = 1e-6) -> None: + super().__init__() + if class_weights is not None: + self.register_buffer("class_weights", class_weights.float()) + else: + self.class_weights = None + self.eps = eps + + def forward(self, logits: torch.Tensor, labels: torch.Tensor) -> torch.Tensor: + probs = torch.softmax(logits, dim=1) + one_hot = F.one_hot(labels, num_classes=logits.size(1)).to(dtype=probs.dtype) + tp = (probs * one_hot).sum(dim=0) + fp = (probs * (1.0 - one_hot)).sum(dim=0) + fn = ((1.0 - probs) * one_hot).sum(dim=0) + f1 = (2.0 * tp + self.eps) / (2.0 * tp + fp + fn + self.eps) + if self.class_weights is None: + return 1.0 - f1.mean() + weights = self.class_weights.to(device=logits.device, dtype=probs.dtype) + if weights.numel() != logits.size(1): + raise RuntimeError(f"Expected {logits.size(1)} F1 class weights, got {weights.numel()}.") + denominator = weights.sum().clamp_min(self.eps) + return 1.0 - (f1 * weights).sum() / denominator + + +class CompositeClassificationLoss(nn.Module): + def __init__(self, ce_loss: nn.Module, auxiliary_loss: nn.Module, auxiliary_weight: float) -> None: + super().__init__() + self.ce_loss = ce_loss + self.auxiliary_loss = auxiliary_loss + self.auxiliary_weight = auxiliary_weight + + def forward(self, logits: torch.Tensor, labels: torch.Tensor) -> torch.Tensor: + return self.ce_loss(logits, labels) + self.auxiliary_weight * self.auxiliary_loss(logits, labels) + + +def effective_number_alpha(counts: torch.Tensor, beta: float) -> torch.Tensor: + if beta <= 0.0: + return torch.ones_like(counts) + if beta >= 1.0: + raise ValueError("--ldam-beta must be less than 1.0") + beta_tensor = torch.tensor(beta, dtype=counts.dtype, device=counts.device) + effective_num = 1.0 - torch.pow(beta_tensor, counts) + alpha = (1.0 - beta_tensor) / effective_num.clamp_min(1e-12) + return alpha + + +def class_count_tensor(train_df: pd.DataFrame, label_to_idx: dict[str, int], device: torch.device) -> torch.Tensor: + y = np.array([label_to_idx[label] for label in train_df["label"]]) + counts = np.bincount(y, minlength=len(label_to_idx)) + if np.any(counts == 0): + missing = [label for label, idx in label_to_idx.items() if counts[idx] == 0] + raise ValueError(f"Cannot build loss because train split has zero samples for classes: {missing}") + return torch.tensor(counts, dtype=torch.float32, device=device) + + +def resolve_label_name(label_to_idx: dict[str, int], name: str) -> str: + normalized = {label.upper(): label for label in label_to_idx} + key = name.strip().upper() + if key not in normalized: + raise ValueError(f"Unknown class name for F1 loss: {name!r}. Choices: {sorted(label_to_idx)}") + return normalized[key] + + +def f1_class_weight_tensor(label_to_idx: dict[str, int], args: argparse.Namespace, device: torch.device) -> torch.Tensor: + weights = torch.ones(len(label_to_idx), dtype=torch.float32, device=device) + for class_name in getattr(args, "f1_ignore_classes", []): + resolved = resolve_label_name(label_to_idx, class_name) + weights[label_to_idx[resolved]] = 0.0 + for item in getattr(args, "f1_class_weight", []): + if "=" not in item: + raise ValueError(f"--f1-class-weight expects CLASS=VALUE, got {item!r}.") + class_name, value = item.split("=", 1) + resolved = resolve_label_name(label_to_idx, class_name) + weight = float(value) + if weight < 0.0: + raise ValueError(f"--f1-class-weight must be non-negative, got {item!r}.") + weights[label_to_idx[resolved]] = weight + if float(weights.sum().item()) <= 0.0: + raise ValueError("F1 class weights sum to zero. Keep at least one class active for --loss ce_f1.") + return weights + + +def build_loss(train_df: pd.DataFrame, label_to_idx: dict[str, int], args: argparse.Namespace, device: torch.device) -> nn.Module: + if args.loss == "ldam": + counts = class_count_tensor(train_df, label_to_idx, device) + return LDAMLoss( + class_counts=counts, + beta=args.ldam_beta, + max_margin=args.ldam_max_margin, + deferred_start_epoch=args.ldam_drw_start_epoch, + alpha_max=args.ldam_alpha_max, + ) + + weight = None + if args.class_weight: + y = np.array([label_to_idx[label] for label in train_df["label"]]) + weights = compute_class_weight(class_weight="balanced", classes=np.arange(len(label_to_idx)), y=y) + weight = torch.tensor(weights, dtype=torch.float32, device=device) + ce_loss: nn.Module = nn.CrossEntropyLoss(weight=weight) + if args.loss == "focal": + return FocalLoss(weight=weight, gamma=args.focal_gamma) + if args.loss == "ce_dice": + return CompositeClassificationLoss(ce_loss, SoftMacroDiceLoss(), args.dice_weight) + if args.loss == "ce_f1": + return CompositeClassificationLoss(ce_loss, SoftMacroF1Loss(f1_class_weight_tensor(label_to_idx, args, device)), args.f1_weight) + return ce_loss diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/metrics.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..350b8c2c12a305b4d908d8bd904a8fc484f83bfd --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/metrics.py @@ -0,0 +1,211 @@ +"""Prediction and classification metric helpers.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Any + +import numpy as np +import pandas as pd +import torch +from sklearn.metrics import ( + accuracy_score, + balanced_accuracy_score, + classification_report, + confusion_matrix, + precision_recall_fscore_support, + roc_auc_score, +) +from sklearn.preprocessing import label_binarize +from torch.utils.data import DataLoader +from tqdm.auto import tqdm + +from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier + + +def move_batch(batch: dict[str, torch.Tensor], device: torch.device) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + clinical = batch["clinical"].to(device, non_blocking=True) + dermoscopic = batch["dermoscopic"].to(device, non_blocking=True) + metadata = batch["metadata"].to(device, non_blocking=True) + labels = batch["label"].to(device, non_blocking=True) + return clinical, dermoscopic, metadata, labels + + +@torch.no_grad() +def predict(model: DualEffB2MetadataClassifier, loader: DataLoader, device: torch.device) -> tuple[np.ndarray, np.ndarray]: + model.eval() + labels_all = [] + probs_all = [] + for batch in tqdm(loader, leave=False): + clinical, dermoscopic, metadata, labels = move_batch(batch, device) + logits = model(clinical, dermoscopic, metadata) + labels_all.append(labels.cpu().numpy()) + probs_all.append(torch.softmax(logits, dim=1).cpu().numpy()) + return np.concatenate(labels_all), np.concatenate(probs_all) + + +def macro_dice_from_confusion_matrix(cm: np.ndarray) -> float: + per_class = [] + for idx in range(cm.shape[0]): + tp = float(cm[idx, idx]) + fn = float(cm[idx, :].sum() - tp) + fp = float(cm[:, idx].sum() - tp) + denom = 2.0 * tp + fp + fn + per_class.append(0.0 if denom <= 0.0 else (2.0 * tp) / denom) + return float(np.mean(per_class)) if per_class else 0.0 + + +def compute_metrics(y_true: np.ndarray, y_prob: np.ndarray, class_names: list[str]) -> tuple[dict[str, Any], pd.DataFrame, np.ndarray]: + y_pred = y_prob.argmax(axis=1) + labels = list(range(len(class_names))) + y_true_bin = label_binarize(y_true, classes=labels) + cm = confusion_matrix(y_true, y_pred, labels=labels) + + precision_macro, recall_macro, f1_macro, _ = precision_recall_fscore_support( + y_true, y_pred, labels=labels, average="macro", zero_division=0 + ) + precision_weighted, recall_weighted, f1_weighted, _ = precision_recall_fscore_support( + y_true, y_pred, labels=labels, average="weighted", zero_division=0 + ) + precision_per_class, recall_per_class, f1_per_class, support_per_class = precision_recall_fscore_support( + y_true, y_pred, labels=labels, average=None, zero_division=0 + ) + + total = cm.sum() + per_class_rows = [] + for idx, class_name in enumerate(class_names): + tp = int(cm[idx, idx]) + fn = int(cm[idx, :].sum() - tp) + fp = int(cm[:, idx].sum() - tp) + tn = int(total - tp - fn - fp) + try: + auc_ovr = float(roc_auc_score(y_true_bin[:, idx], y_prob[:, idx])) + except ValueError: + auc_ovr = None + per_class_rows.append( + { + "class": class_name, + "support": int(support_per_class[idx]), + "precision": float(precision_per_class[idx]), + "recall_sensitivity": float(recall_per_class[idx]), + "specificity": tn / (tn + fp) if (tn + fp) else 0.0, + "f1": float(f1_per_class[idx]), + "auc_ovr": auc_ovr, + } + ) + + metrics = { + "accuracy": float(accuracy_score(y_true, y_pred)), + "balanced_accuracy": float(balanced_accuracy_score(y_true, y_pred)), + "top2_accuracy": float(np.mean((np.argsort(y_prob, axis=1)[:, -min(2, len(class_names)) :] == y_true[:, None]).any(axis=1))), + "top3_accuracy": float(np.mean((np.argsort(y_prob, axis=1)[:, -min(3, len(class_names)) :] == y_true[:, None]).any(axis=1))), + "precision_macro": float(precision_macro), + "recall_macro": float(recall_macro), + "f1_macro": float(f1_macro), + "precision_weighted": float(precision_weighted), + "recall_weighted": float(recall_weighted), + "f1_weighted": float(f1_weighted), + "dice_macro": macro_dice_from_confusion_matrix(cm), + "roc_auc_macro_ovr": safe_roc_auc(y_true_bin, y_prob, "macro"), + "roc_auc_weighted_ovr": safe_roc_auc(y_true_bin, y_prob, "weighted"), + "roc_auc_micro_ovr": safe_roc_auc(y_true_bin, y_prob, "micro"), + "specificity_macro": float(np.mean([row["specificity"] for row in per_class_rows])), + "per_class": per_class_rows, + "classification_report": classification_report( + y_true, + y_pred, + labels=labels, + target_names=class_names, + zero_division=0, + output_dict=True, + ), + "class_names": class_names, + } + return metrics, pd.DataFrame(per_class_rows), cm + + +def safe_roc_auc(y_true_bin: np.ndarray, y_prob: np.ndarray, average: str | None) -> float | None: + try: + return float(roc_auc_score(y_true_bin, y_prob, average=average, multi_class="ovr")) + except ValueError: + return None + + +def save_predictions( + val_df: pd.DataFrame, + y_true: np.ndarray, + y_prob: np.ndarray, + class_names: list[str], + output_dir: Path, +) -> None: + y_pred = y_prob.argmax(axis=1) + prediction_df = pd.DataFrame( + { + "lesion_id": val_df["lesion_id"].tolist(), + "clinical_path": val_df["clinical_path"].tolist(), + "dermoscopic_path": val_df["dermoscopic_path"].tolist(), + "y_true": y_true, + "y_pred": y_pred, + "label_true": [class_names[idx] for idx in y_true], + "label_pred": [class_names[idx] for idx in y_pred], + "confidence": y_prob.max(axis=1), + } + ) + probability_df = pd.DataFrame(y_prob, columns=[f"prob_{name}" for name in class_names]) + pd.concat([prediction_df, probability_df], axis=1).to_csv(output_dir / "val_predictions.csv", index=False) + + +def apply_class_bias(y_prob: np.ndarray, bias: np.ndarray) -> np.ndarray: + log_prob = np.log(np.clip(y_prob, 1e-12, 1.0)) + adjusted = log_prob + bias[None, :] + adjusted -= adjusted.max(axis=1, keepdims=True) + exp_scores = np.exp(adjusted) + return exp_scores / exp_scores.sum(axis=1, keepdims=True) + + +def metric_value_from_probabilities( + y_true: np.ndarray, + y_prob: np.ndarray, + class_names: list[str], + metric_name: str, +) -> float: + metrics, _, _ = compute_metrics(y_true, y_prob, class_names) + return float(metrics[metric_name]) + + +def optimize_class_bias( + y_true: np.ndarray, + y_prob: np.ndarray, + class_names: list[str], + metric_name: str = "dice_macro", + max_bias: float = 1.5, + step: float = 0.25, + passes: int = 3, +) -> tuple[np.ndarray, float]: + bias = np.zeros(len(class_names), dtype=np.float32) + best_score = metric_value_from_probabilities(y_true, y_prob, class_names, metric_name) + current_step = step + + for _ in range(max(1, passes)): + deltas = np.arange(-max_bias, max_bias + current_step * 0.5, current_step, dtype=np.float32) + improved = False + for class_idx in range(len(class_names)): + best_class_bias = float(bias[class_idx]) + best_class_score = best_score + for delta in deltas: + trial_bias = bias.copy() + trial_bias[class_idx] = best_class_bias + float(delta) + trial_prob = apply_class_bias(y_prob, trial_bias) + score = metric_value_from_probabilities(y_true, trial_prob, class_names, metric_name) + if score > best_class_score + 1e-12: + best_class_score = score + best_class_bias = float(trial_bias[class_idx]) + if best_class_score > best_score + 1e-12: + bias[class_idx] = best_class_bias + best_score = best_class_score + improved = True + current_step = max(current_step / 2.0, 0.01) + if not improved: + break + + return bias, best_score diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/model_setup.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/model_setup.py new file mode 100644 index 0000000000000000000000000000000000000000..7309cfdf20bf669152539e7926da2308bcb04118 --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/model_setup.py @@ -0,0 +1,166 @@ +"""Model, optimizer, and checkpoint setup for metadata training.""" + +from __future__ import annotations + +import argparse +from pathlib import Path + +import torch + +from milk10k_effb2_metadata.checkpoints import ( + infer_checkpoint_backend, + load_encoder_checkpoint, + resolve_backbone_backends, +) +from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier + + +def infer_branch_backend_from_state(state: dict[str, torch.Tensor], branch_prefix: str) -> str: + keys = [key.removeprefix(branch_prefix) for key in state if key.startswith(branch_prefix)] + timm_prefixes = ("conv_stem.", "bn1.", "blocks.", "conv_head.", "bn2.", "stages.", "stem.") + torchvision_prefixes = ("features.", "avgpool.", "classifier.") + timm_hits = sum(key.startswith(timm_prefixes) for key in keys) + torchvision_hits = sum(key.startswith(torchvision_prefixes) for key in keys) + if timm_hits > torchvision_hits: + return "timm" + if torchvision_hits > timm_hits: + return "torchvision" + if any(key.startswith("layer") for key in keys): + return "timm" + raise RuntimeError(f"Cannot infer backend for resume checkpoint branch prefix {branch_prefix!r}.") + + +def resolve_training_backbone_backends(args: argparse.Namespace, device: torch.device) -> tuple[str, str]: + if args.backbone_backend != "auto": + return args.backbone_backend, args.backbone_backend + if args.clinical_checkpoint is not None and args.dermoscopic_checkpoint is not None: + return resolve_backbone_backends(args, device) + if args.clinical_checkpoint is not None: + clinical_backend = infer_checkpoint_backend(args.clinical_checkpoint, device, "clinical") + print( + "Auto-detected clinical backbone backend: " + f"clinical={clinical_backend}, dermoscopic={clinical_backend} (ImageNet initialized)" + ) + return clinical_backend, clinical_backend + if args.dermoscopic_checkpoint is not None: + dermoscopic_backend = infer_checkpoint_backend(args.dermoscopic_checkpoint, device, "dermoscopic") + print( + "Auto-detected dermoscopic backbone backend: " + f"clinical={dermoscopic_backend} (ImageNet initialized), dermoscopic={dermoscopic_backend}" + ) + return dermoscopic_backend, dermoscopic_backend + if args.resume_checkpoint is None: + print("No branch checkpoints passed; using torchvision backbones initialized from ImageNet weights.") + return "torchvision", "torchvision" + checkpoint = torch.load(args.resume_checkpoint.expanduser().resolve(), map_location=device, weights_only=False) + state = checkpoint["model_state"] + clinical_backend = infer_branch_backend_from_state(state, "clinical_encoder.") + dermoscopic_backend = infer_branch_backend_from_state(state, "dermoscopic_encoder.") + checkpoint_args = checkpoint.get("args", {}) + if checkpoint_args.get("backbone") and args.backbone == "efficientnet_b2": + args.backbone = checkpoint_args["backbone"] + print(f"Auto-detected resume backends: clinical={clinical_backend}, dermoscopic={dermoscopic_backend}") + return clinical_backend, dermoscopic_backend + + +def build_optimizer( + model: DualEffB2MetadataClassifier, + args: argparse.Namespace, + encoders_trainable: bool, +) -> torch.optim.Optimizer: + head_params = [] + encoder_params = [] + metadata_params = [] + for name, param in model.named_parameters(): + if not param.requires_grad: + continue + if name.startswith(("clinical_encoder.", "dermoscopic_encoder.")): + encoder_params.append(param) + elif name.startswith(("metadata_head.", "clinical_metadata_gate.", "dermoscopic_metadata_gate.")): + metadata_params.append(param) + else: + head_params.append(param) + + groups = [{"params": head_params, "lr": args.head_lr}] + if metadata_params: + groups.append({"params": metadata_params, "lr": args.metadata_lr if args.metadata_lr is not None else args.head_lr}) + if encoders_trainable and encoder_params: + groups.append({"params": encoder_params, "lr": args.encoder_lr}) + return torch.optim.AdamW(groups, weight_decay=args.weight_decay) + + +def set_metadata_head_trainable(model: DualEffB2MetadataClassifier, trainable: bool) -> None: + for param in model.metadata_head.parameters(): + param.requires_grad = trainable + for module_name in ("clinical_metadata_gate", "dermoscopic_metadata_gate"): + module = getattr(model, module_name, None) + if module is not None: + for param in module.parameters(): + param.requires_grad = trainable + + +def load_resume_checkpoint( + checkpoint_path: Path | None, + model: DualEffB2MetadataClassifier, + device: torch.device, +) -> tuple[int, float, str | None]: + if checkpoint_path is None: + return 1, float("-inf"), None + checkpoint_path = checkpoint_path.expanduser().resolve() + if not checkpoint_path.exists(): + raise FileNotFoundError(f"Resume checkpoint not found: {checkpoint_path}") + checkpoint = torch.load(checkpoint_path, map_location=device, weights_only=False) + model.load_state_dict(checkpoint["model_state"]) + next_epoch = int(checkpoint.get("epoch", 0)) + 1 + best_val_f1 = float( + checkpoint.get( + "best_selection_metric", + checkpoint.get("best_val_f1_macro", float("-inf")), + ) + ) + phase = checkpoint.get("phase") + selection_metric_name = checkpoint.get("selection_metric_name", "f1_macro") + print( + f"Resumed checkpoint: {checkpoint_path}, phase={phase}, " + f"last_epoch={next_epoch - 1}, best_{selection_metric_name}={best_val_f1:.4f}" + ) + print("Optimizer is re-created from current CLI LR settings.") + return next_epoch, best_val_f1, str(phase) if phase is not None else None + + +def build_model( + class_names: list[str], + metadata_dim: int, + args: argparse.Namespace, + device: torch.device, + clinical_backbone_backend: str, + dermoscopic_backbone_backend: str, +) -> DualEffB2MetadataClassifier: + model = DualEffB2MetadataClassifier( + num_classes=len(class_names), + metadata_input_dim=metadata_dim, + branch_dim=args.branch_dim, + metadata_dim=args.metadata_dim, + classifier_hidden_dim=args.classifier_hidden_dim, + dropout=args.dropout, + imagenet_pretrained=args.imagenet_pretrained, + clinical_backbone_backend=clinical_backbone_backend, + dermoscopic_backbone_backend=dermoscopic_backbone_backend, + backbone=args.backbone, + disable_metadata=args.disable_metadata, + metadata_fusion=args.metadata_fusion, + image_fusion=getattr(args, "image_fusion", "concat"), + metadata_gate_hidden_dim=args.metadata_gate_hidden_dim, + logit_fusion_mode=args.logit_fusion_mode, + fusion_logit_weight=args.fusion_logit_weight, + clinical_logit_weight=args.clinical_logit_weight, + dermoscopic_logit_weight=args.dermoscopic_logit_weight, + ).to(device) + if args.resume_checkpoint is None: + if args.clinical_checkpoint is not None: + load_encoder_checkpoint(args.clinical_checkpoint, model.clinical_encoder, "clinical", device) + if args.dermoscopic_checkpoint is not None: + load_encoder_checkpoint(args.dermoscopic_checkpoint, model.dermoscopic_encoder, "dermoscopic", device) + if args.disable_metadata or args.freeze_metadata_head: + set_metadata_head_trainable(model, False) + return model diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/models.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/models.py new file mode 100644 index 0000000000000000000000000000000000000000..4fc4c66853cd110a3e9b8cb48f89ad5d7e615c11 --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/models.py @@ -0,0 +1,481 @@ +"""Model components for the dual EfficientNet-B2 metadata classifier.""" + +from __future__ import annotations + +import timm +import torch +import torch.nn.functional as F +from torch import nn + + +class ProjectionHead(nn.Module): + def __init__(self, in_dim: int, out_dim: int, dropout: float) -> None: + super().__init__() + self.net = nn.Sequential( + nn.LayerNorm(in_dim), + nn.Dropout(dropout), + nn.Linear(in_dim, out_dim), + nn.GELU(), + nn.LayerNorm(out_dim), + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return self.net(x) + + +class BranchClassifier(nn.Module): + def __init__(self, in_dim: int, num_classes: int, dropout: float) -> None: + super().__init__() + self.net = nn.Sequential( + nn.LayerNorm(in_dim), + nn.Dropout(dropout), + nn.Linear(in_dim, num_classes), + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return self.net(x) + + +class GatedExpertClassifier(nn.Module): + def __init__(self, in_dim: int, hidden_dim: int, num_classes: int, dropout: float) -> None: + super().__init__() + self.net = nn.Sequential( + nn.LayerNorm(in_dim), + nn.Dropout(dropout), + nn.Linear(in_dim, hidden_dim), + nn.GELU(), + nn.Dropout(dropout), + nn.Linear(hidden_dim, num_classes), + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return self.net(x) + + +class MetadataHead(nn.Module): + def __init__(self, in_dim: int, out_dim: int, dropout: float) -> None: + super().__init__() + hidden_dim = max(out_dim * 2, 32) + self.net = nn.Sequential( + nn.LayerNorm(in_dim), + nn.Linear(in_dim, hidden_dim), + nn.GELU(), + nn.Dropout(dropout), + nn.Linear(hidden_dim, out_dim), + nn.GELU(), + nn.LayerNorm(out_dim), + ) + + def forward(self, metadata: torch.Tensor) -> torch.Tensor: + return self.net(metadata) + + +class MetadataChannelGate(nn.Module): + def __init__(self, metadata_input_dim: int, channel_dim: int, hidden_dim: int, dropout: float) -> None: + super().__init__() + self.norm = nn.LayerNorm(metadata_input_dim) + self.fc1 = nn.Linear(metadata_input_dim, hidden_dim) + self.act = nn.GELU() + self.dropout = nn.Dropout(dropout) + self.fc2 = nn.Linear(hidden_dim, channel_dim) + nn.init.zeros_(self.fc2.weight) + nn.init.constant_(self.fc2.bias, 2.0) + + def forward(self, metadata: torch.Tensor) -> torch.Tensor: + gate = self.norm(metadata) + gate = self.fc1(gate) + gate = self.act(gate) + gate = self.dropout(gate) + gate = torch.sigmoid(self.fc2(gate)) + return gate + + +class DualEffB2MetadataClassifier(nn.Module): + def __init__( + self, + num_classes: int, + metadata_input_dim: int, + branch_dim: int, + metadata_dim: int, + classifier_hidden_dim: int, + dropout: float, + imagenet_pretrained: bool, + clinical_backbone_backend: str, + dermoscopic_backbone_backend: str, + backbone: str = "efficientnet_b2", + disable_metadata: bool = False, + metadata_fusion: str = "concat", + image_fusion: str = "concat", + metadata_gate_hidden_dim: int | None = None, + logit_fusion_mode: str = "single", + fusion_logit_weight: float = 0.6, + clinical_logit_weight: float = 0.2, + dermoscopic_logit_weight: float = 0.2, + ) -> None: + super().__init__() + if metadata_fusion not in ("concat", "gated_concat", "gated_only"): + raise ValueError(f"Unsupported metadata_fusion: {metadata_fusion}") + if image_fusion not in ( + "concat", + "cross_attention", + "co_attention", + "compact_bilinear", + "low_rank_bilinear", + "adaptive_gate", + "moe", + "shared_private", + ): + raise ValueError(f"Unsupported image_fusion: {image_fusion}") + if logit_fusion_mode not in ("single", "fixed"): + raise ValueError(f"Unsupported logit_fusion_mode: {logit_fusion_mode}") + self.clinical_backbone_backend = clinical_backbone_backend + self.dermoscopic_backbone_backend = dermoscopic_backbone_backend + self.backbone = normalize_backbone_name(backbone) + self.disable_metadata = disable_metadata + self.metadata_dim = metadata_dim + self.metadata_fusion = metadata_fusion + self.image_fusion = image_fusion + self.logit_fusion_mode = logit_fusion_mode + self.fusion_logit_weight = fusion_logit_weight + self.clinical_logit_weight = clinical_logit_weight + self.dermoscopic_logit_weight = dermoscopic_logit_weight + self.clinical_encoder, clinical_feature_dim = build_feature_encoder( + backbone, + clinical_backbone_backend, + imagenet_pretrained, + ) + self.dermoscopic_encoder, dermoscopic_feature_dim = build_feature_encoder( + backbone, + dermoscopic_backbone_backend, + imagenet_pretrained, + ) + + self.clinical_head = ProjectionHead(clinical_feature_dim, branch_dim, dropout) + self.dermoscopic_head = ProjectionHead(dermoscopic_feature_dim, branch_dim, dropout) + self.metadata_head = MetadataHead(metadata_input_dim, metadata_dim, dropout) + if metadata_fusion in ("gated_concat", "gated_only"): + gate_hidden_dim = metadata_gate_hidden_dim if metadata_gate_hidden_dim is not None else metadata_dim + self.clinical_metadata_gate = MetadataChannelGate( + metadata_input_dim, + clinical_feature_dim, + gate_hidden_dim, + dropout, + ) + self.dermoscopic_metadata_gate = MetadataChannelGate( + metadata_input_dim, + dermoscopic_feature_dim, + gate_hidden_dim, + dropout, + ) + metadata_output_dim = 0 if metadata_fusion == "gated_only" else metadata_dim + fused_dim = self._fusion_dim(branch_dim, metadata_output_dim, image_fusion) + heads = 4 if branch_dim % 4 == 0 else 1 + if image_fusion == "cross_attention": + self.cross_attention = nn.MultiheadAttention(branch_dim, heads, dropout=dropout, batch_first=True) + self.cross_attention_norm = nn.LayerNorm(branch_dim * 2) + elif image_fusion == "co_attention": + self.co_attention = nn.MultiheadAttention(branch_dim, heads, dropout=dropout, batch_first=True) + self.co_attention_norm = nn.LayerNorm(branch_dim * 4) + elif image_fusion in ("compact_bilinear", "low_rank_bilinear"): + self.bilinear_clinical = nn.Linear(branch_dim, branch_dim) + self.bilinear_dermoscopic = nn.Linear(branch_dim, branch_dim) + self.bilinear_norm = nn.LayerNorm(branch_dim) + elif image_fusion == "adaptive_gate": + gate_input_dim = branch_dim * 2 + metadata_output_dim + self.image_gate = nn.Sequential( + nn.LayerNorm(gate_input_dim), + nn.Linear(gate_input_dim, max(branch_dim, 64)), + nn.GELU(), + nn.Dropout(dropout), + nn.Linear(max(branch_dim, 64), branch_dim), + nn.Sigmoid(), + ) + elif image_fusion == "moe": + clinical_expert_dim = branch_dim + metadata_output_dim + dermoscopic_expert_dim = branch_dim + metadata_output_dim + joint_expert_dim = branch_dim * 2 + metadata_output_dim + router_dim = branch_dim * 2 + metadata_output_dim + self.clinical_expert = GatedExpertClassifier(clinical_expert_dim, classifier_hidden_dim, num_classes, dropout) + self.dermoscopic_expert = GatedExpertClassifier( + dermoscopic_expert_dim, + classifier_hidden_dim, + num_classes, + dropout, + ) + self.joint_expert = GatedExpertClassifier(joint_expert_dim, classifier_hidden_dim, num_classes, dropout) + self.expert_router = nn.Sequential( + nn.LayerNorm(router_dim), + nn.Dropout(dropout), + nn.Linear(router_dim, 3), + ) + elif image_fusion == "shared_private": + if clinical_feature_dim != dermoscopic_feature_dim: + raise ValueError("shared_private image fusion requires matching branch feature dimensions.") + self.shared_head = ProjectionHead(clinical_feature_dim, branch_dim, dropout) + self.classifier = None if image_fusion == "moe" else self._classifier(fused_dim, classifier_hidden_dim, num_classes, dropout) + if logit_fusion_mode == "fixed": + self.clinical_classifier = BranchClassifier(branch_dim, num_classes, dropout) + self.dermoscopic_classifier = BranchClassifier(branch_dim, num_classes, dropout) + else: + self.clinical_classifier = None + self.dermoscopic_classifier = None + + @staticmethod + def _classifier(in_dim: int, hidden_dim: int, num_classes: int, dropout: float) -> nn.Sequential: + return nn.Sequential( + nn.LayerNorm(in_dim), + nn.Dropout(dropout), + nn.Linear(in_dim, hidden_dim), + nn.GELU(), + nn.Dropout(dropout), + nn.Linear(hidden_dim, num_classes), + ) + + @staticmethod + def _fusion_dim(branch_dim: int, metadata_dim: int, image_fusion: str) -> int: + if image_fusion in ("concat", "cross_attention"): + image_dim = branch_dim * 2 + elif image_fusion in ("compact_bilinear", "low_rank_bilinear", "adaptive_gate", "shared_private"): + image_dim = branch_dim * 3 + elif image_fusion == "co_attention": + image_dim = branch_dim * 4 + elif image_fusion == "moe": + image_dim = branch_dim * 2 + else: + raise ValueError(f"Unsupported image_fusion: {image_fusion}") + return image_dim + metadata_dim + + def forward( + self, + clinical: torch.Tensor, + dermoscopic: torch.Tensor, + metadata: torch.Tensor, + ) -> torch.Tensor: + if self.metadata_fusion in ("gated_concat", "gated_only"): + clinical_features = self.encode_with_metadata_gate( + self.clinical_encoder, + self.clinical_backbone_backend, + clinical, + metadata, + self.clinical_metadata_gate, + ) + dermoscopic_features = self.encode_with_metadata_gate( + self.dermoscopic_encoder, + self.dermoscopic_backbone_backend, + dermoscopic, + metadata, + self.dermoscopic_metadata_gate, + ) + else: + clinical_features = self.clinical_encoder(clinical) + dermoscopic_features = self.dermoscopic_encoder(dermoscopic) + clinical_features = torch.flatten(clinical_features, 1) + dermoscopic_features = torch.flatten(dermoscopic_features, 1) + clinical_repr = self.clinical_head(clinical_features) + dermoscopic_repr = self.dermoscopic_head(dermoscopic_features) + metadata_repr = None + if self.metadata_fusion == "gated_only": + metadata_repr = None + else: + if self.disable_metadata: + metadata_repr = clinical_repr.new_zeros((clinical_repr.size(0), self.metadata_dim)) + else: + metadata_repr = self.metadata_head(metadata) + if self.image_fusion == "moe": + fusion_logits = self._moe_logits(clinical_repr, dermoscopic_repr, metadata_repr) + else: + fused = self._fused_features(clinical_features, dermoscopic_features, clinical_repr, dermoscopic_repr, metadata_repr) + fusion_logits = self.classifier(fused) + if self.logit_fusion_mode != "fixed": + return fusion_logits + clinical_logits = self.clinical_classifier(clinical_repr) + dermoscopic_logits = self.dermoscopic_classifier(dermoscopic_repr) + return ( + self.fusion_logit_weight * fusion_logits + + self.clinical_logit_weight * clinical_logits + + self.dermoscopic_logit_weight * dermoscopic_logits + ) + + def _append_metadata(self, features: torch.Tensor, metadata_repr: torch.Tensor | None) -> torch.Tensor: + if metadata_repr is None: + return features + return torch.cat([features, metadata_repr], dim=1) + + def _fused_features( + self, + clinical_features: torch.Tensor, + dermoscopic_features: torch.Tensor, + clinical_repr: torch.Tensor, + dermoscopic_repr: torch.Tensor, + metadata_repr: torch.Tensor | None, + ) -> torch.Tensor: + if self.image_fusion == "concat": + fused = torch.cat([clinical_repr, dermoscopic_repr], dim=1) + elif self.image_fusion == "cross_attention": + tokens = torch.stack([clinical_repr, dermoscopic_repr], dim=1) + attended, _ = self.cross_attention(tokens, tokens, tokens) + fused = self.cross_attention_norm(attended.reshape(attended.size(0), -1)) + elif self.image_fusion == "co_attention": + tokens = torch.stack([clinical_repr, dermoscopic_repr], dim=1) + attended, _ = self.co_attention(tokens, tokens, tokens) + updated = tokens + attended + fused = torch.cat( + [ + clinical_repr, + dermoscopic_repr, + updated[:, 0], + updated[:, 1], + ], + dim=1, + ) + fused = self.co_attention_norm(fused) + elif self.image_fusion in ("compact_bilinear", "low_rank_bilinear"): + bilinear = self.bilinear_clinical(clinical_repr) * self.bilinear_dermoscopic(dermoscopic_repr) + bilinear = self.bilinear_norm(bilinear) + fused = torch.cat([clinical_repr, dermoscopic_repr, bilinear], dim=1) + elif self.image_fusion == "adaptive_gate": + gate_input = torch.cat([clinical_repr, dermoscopic_repr], dim=1) + if metadata_repr is not None: + gate_input = torch.cat([gate_input, metadata_repr], dim=1) + gate = self.image_gate(gate_input) + gated = gate * clinical_repr + (1.0 - gate) * dermoscopic_repr + fused = torch.cat([gated, torch.abs(clinical_repr - dermoscopic_repr), clinical_repr * dermoscopic_repr], dim=1) + elif self.image_fusion == "shared_private": + clinical_shared = self.shared_head(clinical_features) + dermoscopic_shared = self.shared_head(dermoscopic_features) + shared = 0.5 * (clinical_shared + dermoscopic_shared) + fused = torch.cat([clinical_repr, dermoscopic_repr, shared], dim=1) + else: + raise ValueError(f"Unsupported image_fusion: {self.image_fusion}") + return self._append_metadata(fused, metadata_repr) + + def _moe_logits( + self, + clinical_repr: torch.Tensor, + dermoscopic_repr: torch.Tensor, + metadata_repr: torch.Tensor | None, + ) -> torch.Tensor: + clinical_input = self._append_metadata(clinical_repr, metadata_repr) + dermoscopic_input = self._append_metadata(dermoscopic_repr, metadata_repr) + joint_input = self._append_metadata(torch.cat([clinical_repr, dermoscopic_repr], dim=1), metadata_repr) + expert_logits = torch.stack( + [ + self.clinical_expert(clinical_input), + self.dermoscopic_expert(dermoscopic_input), + self.joint_expert(joint_input), + ], + dim=1, + ) + router_weights = torch.softmax(self.expert_router(joint_input), dim=1) + return (expert_logits * router_weights[:, :, None]).sum(dim=1) + + def encode_with_metadata_gate( + self, + encoder: nn.Module, + backbone_backend: str, + images: torch.Tensor, + metadata: torch.Tensor, + gate_module: MetadataChannelGate, + ) -> torch.Tensor: + feature_map = extract_spatial_features(encoder, backbone_backend, self.backbone, images) + if self.disable_metadata: + gate = feature_map.new_ones((feature_map.size(0), feature_map.size(1))) + else: + gate = gate_module(metadata).to(device=feature_map.device, dtype=feature_map.dtype) + gated = feature_map * gate[:, :, None, None] + return F.adaptive_avg_pool2d(gated, 1) + + +def normalize_backbone_name(name: str) -> str: + name = name.lower().replace(" ", "").replace("_", "").replace("-", "") + if name in ("efficientnetb2", "effnetb2", "effb2"): + return "efficientnet_b2" + if name in ("efficientnetb1", "effnetb1", "effb1"): + return "efficientnet_b1" + if name in ("resnet50", "resnet_50"): + return "resnet50" + if name in ("convnextbase", "convxbase"): + return "convnext_base" + raise ValueError(f"Unknown backbone: {name}") + + +def extract_spatial_features(encoder: nn.Module, backbone_backend: str, backbone: str, images: torch.Tensor) -> torch.Tensor: + if backbone_backend == "timm": + features = encoder.forward_features(images) + if isinstance(features, (tuple, list)): + features = features[-1] + elif backbone_backend == "torchvision": + if backbone in ("efficientnet_b2", "efficientnet_b1", "convnext_base"): + features = encoder.features(images) + elif backbone == "resnet50": + features = encoder.conv1(images) + features = encoder.bn1(features) + features = encoder.relu(features) + features = encoder.maxpool(features) + features = encoder.layer1(features) + features = encoder.layer2(features) + features = encoder.layer3(features) + features = encoder.layer4(features) + else: + raise ValueError(f"Unsupported torchvision backbone for gated fusion: {backbone}") + else: + raise ValueError(f"Unsupported backbone backend: {backbone_backend}") + + if features.ndim != 4: + raise RuntimeError( + f"Expected spatial feature map [B, C, H, W] for gated fusion, got shape {tuple(features.shape)}" + ) + return features + + +def build_feature_encoder(backbone: str, backbone_backend: str, imagenet_pretrained: bool) -> tuple[nn.Module, int]: + backbone = normalize_backbone_name(backbone) + if backbone_backend == "timm": + model = timm.create_model( + backbone, + pretrained=imagenet_pretrained, + num_classes=0, + global_pool="avg", + ) + return model, int(model.num_features) + + if backbone_backend == "torchvision": + if backbone == "efficientnet_b2": + from torchvision.models import efficientnet_b2, EfficientNet_B2_Weights + weights = EfficientNet_B2_Weights.IMAGENET1K_V1 if imagenet_pretrained else None + model = efficientnet_b2(weights=weights) + feature_dim = int(model.classifier[1].in_features) + model.classifier = nn.Identity() + return model, feature_dim + elif backbone == "efficientnet_b1": + from torchvision.models import efficientnet_b1, EfficientNet_B1_Weights + weights = EfficientNet_B1_Weights.IMAGENET1K_V1 if imagenet_pretrained else None + model = efficientnet_b1(weights=weights) + feature_dim = int(model.classifier[1].in_features) + model.classifier = nn.Identity() + return model, feature_dim + elif backbone == "resnet50": + from torchvision.models import resnet50, ResNet50_Weights + weights = ResNet50_Weights.IMAGENET1K_V1 if imagenet_pretrained else None + model = resnet50(weights=weights) + feature_dim = int(model.fc.in_features) + model.fc = nn.Identity() + return model, feature_dim + elif backbone == "convnext_base": + from torchvision.models import convnext_base, ConvNeXt_Base_Weights + weights = ConvNeXt_Base_Weights.IMAGENET1K_V1 if imagenet_pretrained else None + model = convnext_base(weights=weights) + feature_dim = int(model.classifier[2].in_features) + model.classifier = nn.Identity() + return model, feature_dim + else: + raise ValueError(f"Unsupported torchvision backbone: {backbone}") + + raise ValueError(f"Unsupported backbone backend: {backbone_backend}") + + +def set_encoder_trainable(model: DualEffB2MetadataClassifier, trainable: bool) -> None: + for param in model.clinical_encoder.parameters(): + param.requires_grad = trainable + for param in model.dermoscopic_encoder.parameters(): + param.requires_grad = trainable diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/runner.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/runner.py new file mode 100644 index 0000000000000000000000000000000000000000..eda03cc8d9d46bcb51ce88ae0c62ea6de61bc063 --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/runner.py @@ -0,0 +1,289 @@ +"""Single-split and k-fold training runners.""" + +from __future__ import annotations + +import argparse +import json +from pathlib import Path +from typing import Any + +import pandas as pd +import torch + +from milk10k_effb2_metadata.data import ( + fit_metadata_spec, + kfold_splits, + lesion_split, + make_loaders, + metadata_vector, +) +from milk10k_effb2_metadata.engine import train_phase +from milk10k_effb2_metadata.losses import build_loss +from milk10k_effb2_metadata.metrics import apply_class_bias, compute_metrics, optimize_class_bias, predict, save_predictions +from milk10k_effb2_metadata.model_setup import build_model, load_resume_checkpoint +from milk10k_effb2_metadata.training_utils import json_safe, save_kfold_summary, save_run_config + + +def build_tail_tracking_config( + train_df: pd.DataFrame, + class_names: list[str], + label_to_idx: dict[str, int], + args: argparse.Namespace, +) -> dict[str, Any] | None: + if args.loss != "ldam" or args.tail_num_classes <= 0: + return None + + counts_series = train_df["label"].value_counts().reindex(class_names, fill_value=0) + train_class_counts = {label: int(counts_series[label]) for label in class_names} + tail_class_names = sorted(class_names, key=lambda label: (train_class_counts[label], label))[ + : min(args.tail_num_classes, len(class_names)) + ] + return { + "tail_class_names": tail_class_names, + "tail_class_indices": [label_to_idx[label] for label in tail_class_names], + "train_class_counts": train_class_counts, + } + + +def run_training_split( + df: pd.DataFrame, + train_df: pd.DataFrame, + val_df: pd.DataFrame, + class_names: list[str], + label_to_idx: dict[str, int], + args: argparse.Namespace, + device: torch.device, + clinical_backbone_backend: str, + dermoscopic_backbone_backend: str, + output_dir: Path, + fold: int | None = None, +) -> dict[str, Any]: + output_dir.mkdir(parents=True, exist_ok=True) + split_dir = output_dir / "splits" + split_dir.mkdir(exist_ok=True) + train_df.to_csv(split_dir / "train.csv", index=False) + val_df.to_csv(split_dir / "val.csv", index=False) + + metadata_spec = fit_metadata_spec(train_df) + metadata_dim = len(metadata_vector(train_df.iloc[0], metadata_spec)) + save_run_config( + output_dir, + args, + class_names, + metadata_spec, + train_df, + val_df, + clinical_backbone_backend, + dermoscopic_backbone_backend, + fold, + ) + + model = build_model( + class_names, + metadata_dim, + args, + device, + clinical_backbone_backend, + dermoscopic_backbone_backend, + ) + resume_epoch, resume_best_val_f1, resume_phase = load_resume_checkpoint(args.resume_checkpoint, model, device) + train_loader, val_loader = make_loaders(train_df, val_df, label_to_idx, metadata_spec, args) + criterion = build_loss(train_df, label_to_idx, args, device) + tail_config = build_tail_tracking_config(train_df, class_names, label_to_idx, args) + + print(f"Output dir: {output_dir}") + print(f"Device: {device}") + print(f"Classes: {class_names}") + print(f"Paired lesions: train={len(train_df)}, val={len(val_df)}, total={len(df)}") + print(f"Metadata input dim: {metadata_dim}") + print(f"MONET columns: {len(metadata_spec.get('monet_columns', []))}") + print( + f"Metadata mode: disable_metadata={args.disable_metadata}, " + f"freeze_metadata_head={args.freeze_metadata_head}, metadata_lr={args.metadata_lr}, " + f"metadata_fusion={args.metadata_fusion}, image_fusion={getattr(args, 'image_fusion', 'concat')}, " + f"gate_hidden_dim={args.metadata_gate_hidden_dim}" + ) + print(f"Loss: {args.loss}, class_weight={args.class_weight}, weighted_sampler={args.weighted_sampler}") + if getattr(args, "image_fusion", "concat") == "moe" and args.logit_fusion_mode == "fixed": + print("Note: --image-fusion moe already mixes expert logits; --logit-fusion-mode fixed adds extra branch logits.") + if args.loss == "ce_f1": + print(f"Soft-F1 class controls: ignore={args.f1_ignore_classes}, weights={args.f1_class_weight}") + if args.loss == "ldam" and args.class_weight: + print("Note: --class-weight is ignored for --loss ldam because LDAM+DRW uses effective-number alpha.") + if tail_config is not None: + tail_counts = {label: tail_config["train_class_counts"][label] for label in tail_config["tail_class_names"]} + print(f"LDAM tail tracking: tail_num_classes={args.tail_num_classes}, tail_counts={tail_counts}") + + history: list[dict[str, Any]] = [] + history_path = output_dir / "history.csv" + if args.resume_checkpoint is not None and history_path.exists(): + history = pd.read_csv(history_path).to_dict("records") + best_start = resume_best_val_f1 if args.resume_checkpoint is not None else float("-inf") + best_tail_start = float("-inf") + tail_best_path = output_dir / "tail_best.pt" + if args.resume_checkpoint is not None and tail_best_path.exists(): + tail_checkpoint = torch.load(tail_best_path, map_location=device, weights_only=False) + best_tail_start = float(tail_checkpoint.get("best_val_tail_recall_macro", float("-inf"))) + skip_freeze_until = resume_epoch if resume_phase == "freeze" else 1 + if resume_phase == "finetune": + skip_freeze_until = args.freeze_epochs + 1 + skip_finetune_until = resume_epoch if resume_phase == "finetune" else 1 + epoch, best_val_f1, best_val_tail_recall = train_phase( + "freeze", + args.freeze_epochs, + 1, + model, + train_loader, + val_loader, + criterion, + device, + args, + class_names, + label_to_idx, + metadata_spec, + output_dir, + history, + best_start, + skip_freeze_until, + **(tail_config or {}), + best_val_tail_recall=best_tail_start, + ) + epoch, best_val_f1, best_val_tail_recall = train_phase( + "finetune", + args.finetune_epochs, + epoch, + model, + train_loader, + val_loader, + criterion, + device, + args, + class_names, + label_to_idx, + metadata_spec, + output_dir, + history, + best_val_f1, + skip_finetune_until, + **(tail_config or {}), + best_val_tail_recall=best_val_tail_recall, + ) + + best_path = output_dir / "best.pt" + if best_path.exists(): + checkpoint = torch.load(best_path, map_location=device, weights_only=False) + model.load_state_dict(checkpoint["model_state"]) + y_true, y_prob = predict(model, val_loader, device) + metrics, per_class_df, cm = compute_metrics(y_true, y_prob, class_names) + metrics = { + "best_selection_metric": float(best_val_f1), + "selection_metric_name": args.selection_metric, + "best_val_f1_macro": float(best_val_f1) if args.selection_metric == "f1_macro" else None, + **metrics, + } + if tail_config is not None: + metrics["best_val_tail_recall_macro"] = float(best_val_tail_recall) + metrics["tail_class_names"] = tail_config["tail_class_names"] + if args.calibrate_bias: + class_bias, calibrated_score = optimize_class_bias( + y_true, + y_prob, + class_names, + metric_name=args.calibration_metric, + max_bias=args.calibration_max_bias, + step=args.calibration_step, + passes=args.calibration_passes, + ) + calibrated_prob = apply_class_bias(y_prob, class_bias) + calibrated_metrics, calibrated_per_class_df, calibrated_cm = compute_metrics(y_true, calibrated_prob, class_names) + calibration_payload = { + "metric": args.calibration_metric, + "optimized_score": float(calibrated_score), + "class_names": class_names, + "class_bias": [float(item) for item in class_bias.tolist()], + "metrics": calibrated_metrics, + } + with open(output_dir / "calibration.json", "w", encoding="utf-8") as f: + json.dump(json_safe(calibration_payload), f, indent=2) + calibrated_per_class_df.to_csv(output_dir / "per_class_metrics_calibrated.csv", index=False) + pd.DataFrame(calibrated_cm, index=class_names, columns=class_names).to_csv( + output_dir / "confusion_matrix_calibrated.csv" + ) + metrics["calibrated"] = calibrated_metrics + with open(output_dir / "metrics.json", "w", encoding="utf-8") as f: + json.dump(json_safe(metrics), f, indent=2) + pd.DataFrame(cm, index=class_names, columns=class_names).to_csv(output_dir / "confusion_matrix.csv") + per_class_df.to_csv(output_dir / "per_class_metrics.csv", index=False) + save_predictions(val_df, y_true, y_prob, class_names, output_dir) + print( + f"Done: best_val_f1_macro={best_val_f1:.4f}, " + f"val_acc={metrics['accuracy']:.4f}, balanced_acc={metrics['balanced_accuracy']:.4f}, " + f"f1_macro={metrics['f1_macro']:.4f}, top3={metrics['top3_accuracy']:.4f}, " + f"auc_macro={metrics['roc_auc_macro_ovr']}" + ) + return metrics + + +def train_single_run( + df: pd.DataFrame, + class_names: list[str], + label_to_idx: dict[str, int], + args: argparse.Namespace, + device: torch.device, + clinical_backbone_backend: str, + dermoscopic_backbone_backend: str, +) -> dict[str, Any]: + if args.synthetic_train_only: + synthetic_mask = df["lesion_id"].astype(str).str.contains("__sdpair_", regex=False) + real_df = df[~synthetic_mask].copy() + synthetic_df = df[synthetic_mask].copy() + train_df, val_df = lesion_split(real_df, args.val_size, args.seed) + train_df = pd.concat([train_df, synthetic_df], ignore_index=True, sort=False) + print( + f"Synthetic train-only split: real_train={len(train_df) - len(synthetic_df)}, " + f"synthetic_train={len(synthetic_df)}, val_real={len(val_df)}" + ) + else: + train_df, val_df = lesion_split(df, args.val_size, args.seed) + return run_training_split( + df, + train_df, + val_df, + class_names, + label_to_idx, + args, + device, + clinical_backbone_backend, + dermoscopic_backbone_backend, + args.output_dir, + ) + + +def train_kfold( + df: pd.DataFrame, + class_names: list[str], + label_to_idx: dict[str, int], + args: argparse.Namespace, + device: torch.device, + clinical_backbone_backend: str, + dermoscopic_backbone_backend: str, +) -> list[dict[str, Any]]: + fold_metrics = [] + for fold_idx, (train_df, val_df) in enumerate(kfold_splits(df, args.k_folds, args.seed)): + print(f"\nK-fold {fold_idx + 1}/{args.k_folds}") + metrics = run_training_split( + df, + train_df, + val_df, + class_names, + label_to_idx, + args, + device, + clinical_backbone_backend, + dermoscopic_backbone_backend, + args.output_dir / f"fold_{fold_idx:02d}", + fold_idx, + ) + fold_metrics.append({"fold": fold_idx, **metrics}) + save_kfold_summary(fold_metrics, args.output_dir) + return fold_metrics diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/train_milk10k_effb2_dual_metadata.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/train_milk10k_effb2_dual_metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..da1072ea523e7c2a806284dfafacbb6dba6a1293 --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/train_milk10k_effb2_dual_metadata.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python3 +"""Train a MILK10k dual EfficientNet-B2 classifier with metadata fusion.""" + +from milk10k_effb2_metadata.cli import parse_args + + +def main() -> None: + args = parse_args() + from milk10k_effb2_metadata.training import run + + run(args) + + +if __name__ == "__main__": + main() diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/training.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/training.py new file mode 100644 index 0000000000000000000000000000000000000000..72e7f7b777bddfa3c6e4ed06cf40cf230d8696ee --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/training.py @@ -0,0 +1,65 @@ +"""Training orchestration facade for the EffB2 dual metadata classifier.""" + +from __future__ import annotations + +import argparse + +from milk10k_effb2_metadata.training_utils import json_safe + + +def run(args: argparse.Namespace) -> None: + import torch + + from datasets import resolve_data_dir, set_seed + from milk10k_effb2_metadata.data import load_paired_dataframe + from milk10k_effb2_metadata.model_setup import resolve_training_backbone_backends + from milk10k_effb2_metadata.models import normalize_backbone_name + from milk10k_effb2_metadata.runner import train_kfold, train_single_run + + if args.k_folds < 1: + raise ValueError("--k-folds must be at least 1.") + + set_seed(args.seed) + data_dir = resolve_data_dir(args.data_dir) + args.output_dir.mkdir(parents=True, exist_ok=True) + + args.backbone = normalize_backbone_name(args.backbone) + if args.metadata_gate_hidden_dim is None: + args.metadata_gate_hidden_dim = args.metadata_dim + if args.resume_checkpoint is None and args.clinical_checkpoint is None and args.dermoscopic_checkpoint is None: + args.imagenet_pretrained = True + if args.image_size is None: + if args.backbone == "efficientnet_b2": + args.image_size = 260 + elif args.backbone == "efficientnet_b1": + args.image_size = 240 + else: # resnet50, convnext_base + args.image_size = 224 + + df = load_paired_dataframe(data_dir) + class_names = sorted(df["label"].unique()) + label_to_idx = {label: idx for idx, label in enumerate(class_names)} + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + clinical_backbone_backend, dermoscopic_backbone_backend = resolve_training_backbone_backends(args, device) + + print(f"Data dir: {data_dir}") + if args.k_folds == 1: + train_single_run( + df, + class_names, + label_to_idx, + args, + device, + clinical_backbone_backend, + dermoscopic_backbone_backend, + ) + else: + train_kfold( + df, + class_names, + label_to_idx, + args, + device, + clinical_backbone_backend, + dermoscopic_backbone_backend, + ) diff --git a/milk10k_effb2_metadata/milk10k_effb2_metadata/training_utils.py b/milk10k_effb2_metadata/milk10k_effb2_metadata/training_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..83a29b0a597d6f31b863c18badb2dc0f8d1b70a9 --- /dev/null +++ b/milk10k_effb2_metadata/milk10k_effb2_metadata/training_utils.py @@ -0,0 +1,85 @@ +"""Shared training serialization and reporting helpers.""" + +from __future__ import annotations + +import argparse +import json +from pathlib import Path +from typing import Any + +try: + import numpy as np +except ModuleNotFoundError: # pragma: no cover - keeps json_safe importable in minimal CLI environments. + np = None + + +def save_run_config( + output_dir: Path, + args: argparse.Namespace, + class_names: list[str], + metadata_spec: dict[str, Any], + train_df: pd.DataFrame, + val_df: pd.DataFrame, + clinical_backbone_backend: str, + dermoscopic_backbone_backend: str, + fold: int | None = None, +) -> None: + import pandas as pd + + payload = { + "args": json_safe(vars(args)), + "class_names": class_names, + "metadata_spec": json_safe(metadata_spec), + "train_size": len(train_df), + "val_size": len(val_df), + "fold": fold, + "metadata_fusion": args.metadata_fusion, + "image_fusion": getattr(args, "image_fusion", "concat"), + "clinical_backbone": f"{clinical_backbone_backend} {args.backbone}", + "dermoscopic_backbone": f"{dermoscopic_backbone_backend} {args.backbone}", + } + with open(output_dir / "run_config.json", "w", encoding="utf-8") as f: + json.dump(payload, f, indent=2) + + +def save_kfold_summary(fold_metrics: list[dict[str, Any]], output_dir: Path) -> None: + import pandas as pd + + summary_keys = [ + "best_val_f1_macro", + "best_selection_metric", + "best_val_tail_recall_macro", + "accuracy", + "balanced_accuracy", + "dice_macro", + "f1_macro", + "roc_auc_macro_ovr", + "top3_accuracy", + ] + rows = [] + for metrics in fold_metrics: + rows.append({key: metrics.get(key) for key in ["fold", *summary_keys]}) + summary_df = pd.DataFrame(rows) + summary_df.to_csv(output_dir / "kfold_summary.csv", index=False) + + aggregate: dict[str, Any] = {"folds": json_safe(rows), "mean": {}, "std": {}} + for key in summary_keys: + values = pd.to_numeric(summary_df[key], errors="coerce").dropna() + aggregate["mean"][key] = None if values.empty else float(values.mean()) + aggregate["std"][key] = None if values.empty else float(values.std(ddof=0)) + with open(output_dir / "kfold_summary.json", "w", encoding="utf-8") as f: + json.dump(aggregate, f, indent=2) + + +def json_safe(value): + if isinstance(value, Path): + return str(value) + if isinstance(value, dict): + return {key: json_safe(item) for key, item in value.items()} + if isinstance(value, (list, tuple)): + return [json_safe(item) for item in value] + if np is not None and isinstance(value, np.ndarray): + return value.tolist() + if np is not None and isinstance(value, np.generic): + return value.item() + return value diff --git a/milk10k_effb2_metadata/predict_milk10k_effb2_dual_metadata.py b/milk10k_effb2_metadata/predict_milk10k_effb2_dual_metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..15f35146cc23e29e3348f85ea82d19bcfbc4f1f0 --- /dev/null +++ b/milk10k_effb2_metadata/predict_milk10k_effb2_dual_metadata.py @@ -0,0 +1,8 @@ +#!/usr/bin/env python3 +"""Run inference with a MILK10k dual EfficientNet-B2 metadata checkpoint.""" + +from milk10k_effb2_metadata.inference import main + + +if __name__ == "__main__": + main() diff --git a/milk10k_effb2_metadata/tests/__pycache__/test_fusion_and_f1_loss.cpython-314.pyc b/milk10k_effb2_metadata/tests/__pycache__/test_fusion_and_f1_loss.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4b9e8c365cae97d8dd1b008dd5f592051eab6535 Binary files /dev/null and b/milk10k_effb2_metadata/tests/__pycache__/test_fusion_and_f1_loss.cpython-314.pyc differ diff --git a/milk10k_effb2_metadata/tests/test_fusion_and_f1_loss.py b/milk10k_effb2_metadata/tests/test_fusion_and_f1_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..025cf7b220d5d836f3a91938e26f330b663715ab --- /dev/null +++ b/milk10k_effb2_metadata/tests/test_fusion_and_f1_loss.py @@ -0,0 +1,170 @@ +from __future__ import annotations + +import argparse +import tempfile +from pathlib import Path +import unittest +from unittest.mock import patch + +MISSING_DEPENDENCY: str | None = None + +try: + import torch + from torch import nn +except ModuleNotFoundError as exc: # pragma: no cover - local minimal env may omit ML deps. + MISSING_DEPENDENCY = exc.name + +if MISSING_DEPENDENCY is None: + try: + import numpy as np + import pandas as pd + from PIL import Image + from milk10k_effb2_metadata.data import PairedMilk10kMetadataDataset + from milk10k_effb2_metadata.losses import SoftMacroF1Loss, f1_class_weight_tensor + from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier + except ModuleNotFoundError as exc: # pragma: no cover - local minimal env may omit ML deps. + MISSING_DEPENDENCY = exc.name + + +if MISSING_DEPENDENCY is not None: + class MissingDependencyTest(unittest.TestCase): + @unittest.skip(f"Missing ML test dependency: {MISSING_DEPENDENCY}") + def test_missing_dependency(self) -> None: + pass + + +if MISSING_DEPENDENCY is None: + class FakeEncoder(nn.Module): + def __init__(self, feature_dim: int) -> None: + super().__init__() + self.feature_dim = feature_dim + + def forward(self, images: torch.Tensor) -> torch.Tensor: + pooled = images.mean(dim=(2, 3)) + repeats = (self.feature_dim + pooled.size(1) - 1) // pooled.size(1) + return pooled.repeat(1, repeats)[:, : self.feature_dim] + + def features(self, images: torch.Tensor) -> torch.Tensor: + return self.forward(images).view(images.size(0), self.feature_dim, 1, 1) + + + def fake_build_feature_encoder(backbone: str, backbone_backend: str, imagenet_pretrained: bool): + feature_dim = 16 + return FakeEncoder(feature_dim), feature_dim + + + class FusionSmokeTest(unittest.TestCase): + def test_all_image_and_metadata_fusions_forward(self) -> None: + modes = [ + "concat", + "cross_attention", + "co_attention", + "compact_bilinear", + "low_rank_bilinear", + "adaptive_gate", + "moe", + "shared_private", + ] + metadata_modes = ["concat", "gated_concat", "gated_only"] + with patch("milk10k_effb2_metadata.models.build_feature_encoder", side_effect=fake_build_feature_encoder): + for mode in modes: + for metadata_mode in metadata_modes: + with self.subTest(mode=mode, metadata_mode=metadata_mode): + model = DualEffB2MetadataClassifier( + num_classes=4, + metadata_input_dim=5, + branch_dim=8, + metadata_dim=6, + classifier_hidden_dim=12, + dropout=0.0, + imagenet_pretrained=False, + clinical_backbone_backend="torchvision", + dermoscopic_backbone_backend="torchvision", + backbone="efficientnet_b2", + metadata_fusion=metadata_mode, + image_fusion=mode, + ) + logits = model( + torch.randn(2, 3, 8, 8), + torch.randn(2, 3, 8, 8), + torch.randn(2, 5), + ) + self.assertEqual(tuple(logits.shape), (2, 4)) + + def test_expected_fused_dims(self) -> None: + branch_dim = 8 + metadata_dim = 6 + expected = { + "concat": 22, + "cross_attention": 22, + "co_attention": 38, + "compact_bilinear": 30, + "low_rank_bilinear": 30, + "adaptive_gate": 30, + "shared_private": 30, + "moe": 22, + } + for mode, expected_dim in expected.items(): + with self.subTest(mode=mode): + self.assertEqual(DualEffB2MetadataClassifier._fusion_dim(branch_dim, metadata_dim, mode), expected_dim) + gated_only_dim = expected_dim - metadata_dim + self.assertEqual(DualEffB2MetadataClassifier._fusion_dim(branch_dim, 0, mode), gated_only_dim) + + + class MetadataAugmentationTest(unittest.TestCase): + def test_image_transform_does_not_change_metadata(self) -> None: + with tempfile.TemporaryDirectory() as tmp_dir: + image_path = Path(tmp_dir) / "image.jpg" + Image.fromarray(np.full((8, 8, 3), 127, dtype=np.uint8)).save(image_path) + df = pd.DataFrame( + [ + { + "lesion_id": "L1", + "label": "BCC", + "clinical_path": str(image_path), + "dermoscopic_path": str(image_path), + "clinical_age_approx": 60, + "dermoscopic_age_approx": 60, + "clinical_skin_tone_class": 3, + "dermoscopic_skin_tone_class": 3, + "clinical_sex": "female", + "dermoscopic_sex": "female", + "clinical_site": "arm", + "dermoscopic_site": "arm", + } + ] + ) + metadata_spec = {"sex_values": ["female"], "site_values": ["arm"], "monet_columns": []} + + def noisy_transform(image): + return torch.rand(3, image.height, image.width) + + dataset = PairedMilk10kMetadataDataset(df, {"BCC": 0}, metadata_spec, noisy_transform) + first = dataset[0]["metadata"] + second = dataset[0]["metadata"] + self.assertTrue(torch.equal(first, second)) + + + class F1LossControlTest(unittest.TestCase): + def test_f1_class_controls_ignore_and_weight_classes(self) -> None: + label_to_idx = {"BCC": 0, "MAL_OTH": 1, "MEL": 2} + args = argparse.Namespace(f1_ignore_classes=["MAL_OTH"], f1_class_weight=["BCC=2.5"]) + weights = f1_class_weight_tensor(label_to_idx, args, torch.device("cpu")) + self.assertTrue(torch.equal(weights, torch.tensor([2.5, 0.0, 1.0]))) + + def test_soft_f1_ignores_zero_weight_class(self) -> None: + logits = torch.tensor([[4.0, 0.0, 0.0], [0.0, 4.0, 0.0], [0.0, 0.0, 4.0]]) + labels = torch.tensor([0, 1, 2]) + masked = SoftMacroF1Loss(torch.tensor([1.0, 0.0, 1.0]))(logits, labels) + probs = torch.softmax(logits, dim=1) + one_hot = torch.nn.functional.one_hot(labels, num_classes=3).float() + tp = (probs * one_hot).sum(dim=0) + fp = (probs * (1.0 - one_hot)).sum(dim=0) + fn = ((1.0 - probs) * one_hot).sum(dim=0) + f1 = (2.0 * tp + 1e-6) / (2.0 * tp + fp + fn + 1e-6) + manual = 1.0 - (f1[0] + f1[2]) / 2.0 + self.assertAlmostEqual(float(masked), float(manual), places=6) + + +if __name__ == "__main__": + unittest.main()