diff --git a/OpenMidnight/.gitignore b/OpenMidnight/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..b6a48b8895d9898774abaf30af3d9af9fa14d100 --- /dev/null +++ b/OpenMidnight/.gitignore @@ -0,0 +1,46 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] + +# Distribution / packaging +build/ +dist/ +*.egg-info/ +_version.py + +# IDE +.vscode/ + +# Virtual environment +.venv/ +.python-version + +# Environment variables +.env +.env.* + +# Jupyter Notebook +.ipynb_checkpoints + +# Local data +slurms +checkpoints +wandb +jobs + +# Local scratch/tmp +.scratch +tmp +.tmp* + +# specific files +output* +sample_dataset_30.txt +uv.lock +watch_run.sh +wandb/ +HEST/ +eva-probe/ +eval/ +CLAUDE.md +AGENTS.md \ No newline at end of file diff --git a/OpenMidnight/HEST_evaluation.py b/OpenMidnight/HEST_evaluation.py new file mode 100644 index 0000000000000000000000000000000000000000..9013a171b52168feaa65244fe94e6e4f4687e5e2 --- /dev/null +++ b/OpenMidnight/HEST_evaluation.py @@ -0,0 +1,51 @@ +from hest.bench import benchmark +import torch +from torchvision import transforms + +print("loading base") +dinov2 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitg14_reg') + +ours = torch.load("checkpoints/teacher_epoch250000.pth") +checkpoint = ours["teacher"] +checkpoint_new = {} + +for key in list(checkpoint.keys()): + if "dino" in str(key) or "ibot" in str(key): + checkpoint.pop(key, None) + +for key, keyb in zip(checkpoint.keys(), dinov2.state_dict().keys()): + checkpoint_new[keyb] = checkpoint[key] + +checkpoint = checkpoint_new + +new_shape = checkpoint["pos_embed"] #The pos embed is the only different shape +dinov2.pos_embed = torch.nn.parameter.Parameter(new_shape) + +dinov2.load_state_dict(checkpoint) + +PATH_TO_CONFIG = "./HEST/bench_config/bench_config.yaml" +model = dinov2 + +RESIZE_DIM = 224 +NORMALIZE_MEAN = [0.485, 0.456, 0.406] +NORMALIZE_STD = [0.229, 0.224, 0.225] + +model_transforms = transforms.Compose([ + #transforms.Resize(224), # Resize the smaller side of the image to 256 + #transforms.CenterCrop(RESIZE_DIM), # Crop the center of the image to 224x224 + + # Step 2: Convert the image (PIL/numpy) to a PyTorch tensor + transforms.ToTensor(), + + # Step 3: Normalize the tensor + transforms.Normalize( + mean=NORMALIZE_MEAN, + std=NORMALIZE_STD) + ]) + +benchmark( + model, + model_transforms, + torch.float32, + config=PATH_TO_CONFIG, +) \ No newline at end of file diff --git a/OpenMidnight/LICENSE b/OpenMidnight/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..5471dc10377b76db85a2feca7a99a7eef4980ba8 --- /dev/null +++ b/OpenMidnight/LICENSE @@ -0,0 +1,203 @@ + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/OpenMidnight/README.md b/OpenMidnight/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7d04ac94d1d84d7b6f34110a07b863e8620454e5 --- /dev/null +++ b/OpenMidnight/README.md @@ -0,0 +1,225 @@ +

OpenMidnight

+ +

2PJpVl2k51pfjFg2Vs-oS

+

Fully open-source and improved replication of Kaiko.AI's pathology foundation model Midnight.

+
+ + +
+

Sophont · MedARC

+ +This is a publicly developed, open-source project by [MedARC](https://www.medarc.ai/). If you are interested in helping out, [join our Discord server](https://discord.gg/tVR4TWnRM9) and introduce yourself in our `#path-fm` channel. + + +## Features +- Trains faster with improved average benchmarking performance compared to the original Midnight-12K model (~3 days to train using 1×8×H100) +- Supports single‑GPU up to multi‑node training with FSDP +- Robust resuming from last checkpoint functionality if training gets interrupted +- Weights & Biases (wandb) logging for monitoring/tracking model training +- Optionally stream data from Hugging Face so no need to download any data in advance (TCGA-12K is approximately 12 TB) + +# Installation + +Clone the repository: + +```bash +git clone https://github.com/MedARC-AI/openmidnight.git +``` + +Change into the directory, then run the installation script: + +```bash +./install.sh +``` + +This will create a virtual environment, "pathologydino", with all necessary packages pre-installed, located as a .venv folder in the same directory as openmidnight. It will automatically detect your machine's CUDA version and install packages appropriately. + +Note: We have only personally verified training works as intended with this repository using H100 GPUs. + +```bash +source .venv/bin/activate +wandb init +``` + +By default, we log model training to wandb. Run `wandb init` inside of `openmidnight/` before starting your training run so that wandb is properly configured. + +You can now run one of our `run*.sh` scripts to train your model (see Training section below), using the YAML config specified in that script. + +Once you have successfully completed model training (or have downloaded [our pretrained checkpoint](https://huggingface.co/SophontAI/OpenMidnight/blob/main/teacher_checkpoint.pth)), you can evaluate using [Kaiko.AI's eva framework](https://github.com/kaiko-ai/eva) and the [Mahmood Lab's HEST benchmark](https://github.com/mahmoodlab/HEST) (skip to the Evaluation section below). + +# Training + +We use `run*.sh` to initiate training runs via torchrun. Depending on your compute setting, modify and run the corresponding shell script described in the relevant subsection below. + +We use YAML configs for specifying important hyperparameters during training. These files are located in `dinov2/configs/train/` (not in `eval_configs/`, which stores YAML configs for eva evaluation benchmarking). Our replication checkpoint specifically used `dinov2/configs/train/vitg14_reg4.yaml`. + +There are some variables that are specified in `run*.sh` directly (as opposed to the YAML config), such as the output directory for saving checkpoints, whether to enable resume functionality, and the specific CUDA devices you want to train with. + +If you are getting rate limited by huggingface, one easy method to increase your rate is to first `export HF_TOKEN=` before running your code (https://huggingface.co/settings/tokens). + +## Dataset prep + +If you are wanting to exactly replicate our checkpoint, note that we did not train via streaming from huggingface. This feature was subsequently added and needs to be enabled in your YAML config (`train.streaming_from_hf=[True,False]`). Unless you enable this, you will need to first locally download the TCGA-12K dataset (~12TB) and then use the scripts provided in `prepatching_scripts/` to create a txt file containing the svs filepaths and locations/magnitude from which to create patches on-the-fly during model training. You can alternatively use [our original sample_dataset_30.txt file](https://huggingface.co/SophontAI/OpenMidnight/blob/main/sample_dataset_30.txt), but note you would need to modify that txt to correct its use of absolute filepaths. + +## Training Single GPU (Short Config) + +```bash +./run_ablation.sh +``` + +This does finetuning with a YAML config (`dinov2/configs/train/vits14_reg_ablations.yaml`) tweaked to support an informative, short training run on a single GPU that can be completed in under 24 hours. We hope this can be particularly useful for debugging and ablation experiments. + +## Training Single Node, Multi‑GPU (Full Reproduction) + +```bash +./run_1node.sh +``` + +Train across multiple GPUs on a single node. Our released checkpoint used this script for training. + +## Training Multi‑Node (Full Reproduction) + +Same as training single‑node multi‑GPU, except increase `NNODES` in both `run_master_node.sh` and `run_other_nodes.sh` to the number of total nodes you are training across. Then run the corresponding scripts. + +```bash +./run_master_node.sh # on master node +``` +```bash +./run_other_nodes.sh # on non-master nodes +``` + +If during training you get HTTP Error 429, try reducing the number of workers (set in the YAML config) and lowering the DataLoader's `prefetch_factor` (defined in `dinov2/train/train.py`). This error can happen when Hugging Face is being pinged too frequently during streaming. Another solution is to [download the data locally](https://huggingface.co/datasets/medarc/TCGA-12K-parquet) and replace `medarc/TCGA-12K-parquet` in `dinov2/train/train.py` with the full path to your locally downloaded dataset folder. + +# Methods / Training Recipe + +Below is a high‑level overview of our training recipe, with particular attention to deviations from the original DINOv2 paper. For additional context, refer to the [Midnight paper](https://arxiv.org/abs/2504.05186). + +- Base model + init + - Student/teacher are ViT‑G/14 with 4 register tokens. + - We initialize the student backbone from Meta’s DINOv2 ViT‑G/14 register checkpoint via `torch.hub`. + - Heads are re‑initialized, as Meta only shared pretrained weights for their model backbone. + +- Objectives and heads + - DINO self‑distillation on CLS tokens, with 131072 prototypes and a 384‑dim bottleneck head. iBOT masked patch prediction on global crops. + - DINOv2's KoLeo regularization is replaced by a KDE‑based entropy regularizer as done in the Midnight paper. + +- Data and augmentations + - Streaming directly from a Parquet dataset of pre-patched TCGA slides hosted on Hugging Face (medarc/TCGA-12K-parquet). See `prepatching_scripts/` and read our [hf dataset card](https://huggingface.co/datasets/medarc/TCGA-12K-parquet/blob/main/README.md) for more information on pre-patching. We read `image_bytes`, decode to RGB, and apply DINO augmentations. + - H&E augmentation: before normalization, images are converted to HED space and perturbed, then converted back to RGB. See `DataAugmentationDINO` in `dinov2/data/augmentations.py`. + - Multi‑crop: 2 global crops (224) and multiple local crops (98). iBOT masks are sampled per‑image with ratios drawn uniformly from a min/max range. + +- Optimization and schedules + - LR is scaled with sqrt(batch/1024) from a base LR of 2e‑4. Midnight paper originally used a base LR of 3.5e-4 but we observed that this led to training collapse. + - We train for 8000 “epochs” by schedule (1 epoch = 1250 steps), but early‑stop at 200 epochs. We found early stopping was necessary to prevent worsening downstream performance with longer model training. + +- Checkpointing, evaluation, logging + - We save LOCAL_STATE_DICT FSDP checkpoints per rank and tag `last_checkpoint.rank_*` files (for resuming functionality). + - The teacher weights are exported every cfg.evaluation.eval_period_iterations steps to `output_dir/eval/training_/teacher_checkpoint.pth`. + - Weights & Biases logging is enabled with a persistent run id stored in the output directory to support resuming, in case model training gets interrupted. + +# Downstream Evaluation + +## eva Benchmarks + +First ensure you have a checkpoint ready to be evaluated. Place your .pth file for your teacher checkpoint in the /checkpoints folder. You can download our pretrained checkpoint here: https://huggingface.co/SophontAI/OpenMidnight/blob/main/teacher_checkpoint.pth + +Then, `cd` into the same `openmidnight` folder cloned from our Installation steps and clone our modified GitHub repo forked from the original [kaiko-eva](https://github.com/kaiko-ai/eva): + +```bash +cd openmidnight +source .venv/bin/activate +git clone https://github.com/MedARC-AI/eva-probe +``` + +Then, install the eva framework to enable use of the `eva` command in your terminal (using `--no-deps` because the `openmidnight` virtual environment already contains the necessary packages): + +```bash +uv pip install -e './eva-probe[vision]' --no-deps +``` + +We provide every YAML config file we used in our replication in `openmidnight/eval_configs/`. Not every dataset permits automatic downloading. For datasets like BACH that do, we automatically download the dataset when you specify `DOWNLOAD_DATA=true` when calling `eva predict_fit`. For other datasets, follow the manual download steps described in the [eva datasets documentation](https://kaiko-ai.github.io/eva/main/datasets/) and revise each YAML config to provide the path to your downloaded dataset prior to eva benchmarking. + +Below are the steps for running the [BACH](https://kaiko-ai.github.io/eva/main/datasets/bach/) evaluation. If your teacher checkpoint is not stored as `openmidnight/checkpoints/teacher_epoch250000.pth`, you will first need to modify your eva YAML file's `checkpoint_path` variable to specify the path to your model weights. + +```bash +cd eva-probe # should be located in openmidnight/eva-probe +CUDA_VISIBLE_DEVICES=0 DOWNLOAD_DATA=true eva predict_fit --config ../eval_configs/bach.yaml +``` + +All eva evaluations should be run on a single GPU by setting `CUDA_VISIBLE_DEVICES=0`. We observed inconsistent and worse results when trying to evaluate using multiple GPUs. + +## HEST Benchmark + +First ensure you have a checkpoint ready to be evaluated. Place the .pth file for your teacher model in the /checkpoints folder. You can download our pretrained checkpoint here: https://huggingface.co/SophontAI/OpenMidnight/blob/main/teacher_checkpoint.pth + +Then, `cd` into the same `openmidnight` folder cloned from our Installation steps and clone the [Mahmood Lab's HEST GitHub repo](https://github.com/mahmoodlab/HEST): + +```bash +cd openmidnight +source .venv/bin/activate +git clone https://github.com/mahmoodlab/HEST.git +cd HEST +git checkout afd42c3143092c51e6bcc0f1df65bbf58a467e5e +cd .. # cd back to openmidnight/ for subsequent install steps +``` + +Then install HEST framework so that we can import invoke their benchmark function (using `--no-deps` because the `openmidnight` virtual environment already contains the necessary packages). + +```bash +uv pip install -e ./HEST --no-deps +``` + +Now uncomment out specific lines in the HEST YAML config to enable PCA dimensionality reduction, benchmark across all HEST datasets used in the original paper, and solely benchmark our DINOv2 model as the encoder: + +```bash +sed -i -E '/^datasets:/,/^\]/{s/^([[:space:]]*)#([[:space:]]*)"([^"]+)",/\1"\3",/;s/^([[:space:]]*)"HCC"(,?)/\1# "HCC"\2/}; s/^[[:space:]]*#([[:space:]]*dimreduce:[[:space:]]*".*")/\1/; /^encoders:/,/^\]/{s/^([[:space:]]*)"resnet50"(,?)/\1# "resnet50"\2/}' ./HEST/bench_config/bench_config.yaml +``` + +Then finally run our HEST_evaluation.py script to benchmark your checkpoint. Running HEST_evaluation.py will automatically download the necessary preprocessed patches and patch encoders and output results into a new `openmidnight/eval` folder (specifically, the benchmark results dump to the `ST_pred_results/` subfolder). + +```bash +python HEST_evaluation.py +``` + +## Related Work / Citation + +This repository adapts and extends Meta AI's DINOv2 codebase and follows modifications introduced by Kaiko's Midnight work. If you use this repository or models in academic work, please cite their and our work: + +Kaplan, D., Grandhi, R. S., Lane, C., Warner, B., Abraham, T. M., & Scotti, P. S. (2025). How to train a state-of-the-art pathology foundation model with $1.6k. Sophont. https://sophont.med/blog/openmidnight + +``` +@article{kaplan2025openmidnight, + author = {Kaplan, Daniel and Grandhi, Ratna Sagari and Lane, Connor and Warner, Benjamin and Abraham, Tanishq Mathew and Scotti, Paul S.}, + title = {How to Train a State-of-the-Art Pathology Foundation Model with \$1.6k}, + year = {2025}, + url = {https://sophont.med/blog/openmidnight}, + } +``` + +Karasikov, M., van Doorn, J., Känzig, N., Erdal Cesur, M., Horlings, H. M., Berke, R., ... & Otálora, S. (2025). Training state-of-the-art pathology foundation models with orders of magnitude less data. In International Conference on Medical Image Computing and Computer-Assisted Intervention (pp. 573-583). Cham: Springer Nature Switzerland. + +``` +@inproceedings{karasikov2025training, + title={Training state-of-the-art pathology foundation models with orders of magnitude less data}, + author={Karasikov, Mikhail and van Doorn, Joost and K{\"a}nzig, Nicolas and Erdal Cesur, Melis and Horlings, Hugo Mark and Berke, Robert and Tang, Fei and Ot{\'a}lora, Sebastian}, + booktitle={International Conference on Medical Image Computing and Computer-Assisted Intervention}, + pages={573—583}, + year={2025}, + organization={Springer} +} +``` + +Oquab, M., Darcet, T., Moutakanni, T., Vo, H., Szafraniec, M., Khalidov, V., ... & Bojanowski, P. (2023). DINOv2: Learning robust visual features without supervision. arXiv preprint arXiv:2304.07193. + +``` +@article{oquab2023dinov2, + title={DINOv2: Learning Robust Visual Features without Supervision}, + author={Maxime Oquab and Timothée Darcet and Théo Moutakanni and Huy Vo and Marc Szafraniec and Vasil Khalidov and Pierre Fernandez and Daniel Haziza and Francisco Massa and Alaaeldin El-Nouby and Mahmoud Assran and Nicolas Ballas and Wojciech Galuba and Russell Howes and Po-Yao Huang and Shang-Wen Li and Ishan Misra and Michael Rabbat and Vasu Sharma and Gabriel Synnaeve and Hu Xu and Hervé Jegou and Julien Mairal and Patrick Labatut and Armand Joulin and Piotr Bojanowski}, + year={2024}, + eprint={2304.07193}, + archivePrefix={arXiv}, + primaryClass={cs.CV}, + url={https://arxiv.org/abs/2304.07193}, +} +``` + diff --git a/OpenMidnight/_utils.py b/OpenMidnight/_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..399f00c438bd4f45e27ed18a432f997f0b0c5c14 --- /dev/null +++ b/OpenMidnight/_utils.py @@ -0,0 +1,166 @@ +"""Utilities and helper functions for models.""" + +#/home/daniel/pathologyDino/dino_env/lib/python3.11/site-packages/eva/core/models/wrappers + +import hashlib +import os +import sys +from typing import Any, Dict + +import torch +from fsspec.core import url_to_fs +from lightning_fabric.utilities import cloud_io +from loguru import logger +from torch import hub, nn + +from eva.core.utils.progress_bar import tqdm + + +def load_model_weights(model: nn.Module, checkpoint_path: str) -> None: + """Loads (local or remote) weights to the model in-place. + + Args: + model: The model to load the weights to. + checkpoint_path: The path to the model weights/checkpoint. + """ + logger.info(f"Loading '{model.__class__.__name__}' model from checkpoint '{checkpoint_path}'") + + print("tstingi") + print(model.state_dict().keys()) + fs = cloud_io.get_filesystem(checkpoint_path) + with fs.open(checkpoint_path, "rb") as file: + checkpoint = cloud_io._load(file, map_location="cpu") # type: ignore + if isinstance(checkpoint, dict) and "state_dict" in checkpoint: + checkpoint = checkpoint["state_dict"] + + + if "teacher" in checkpoint: + checkpoint = checkpoint["teacher"] + #Need to remove the word backbone from everything I think? + checkpoint_new = {} + for key in list(checkpoint.keys()): + if "dino" in str(key) or "ibot" in str(key): + checkpoint.pop(key, None) + for key, keyb in zip(checkpoint.keys(), model.state_dict().keys()): + checkpoint_new[keyb] = checkpoint[key] + + checkpoint = checkpoint_new + #The pos embed is the only different one, idk why + new_shape = checkpoint["pos_embed"] + model.pos_embed = torch.nn.parameter.Parameter(new_shape) + + model.load_state_dict(checkpoint, strict=True) + + + logger.info(f"Loading weights from '{checkpoint_path}' completed successfully.") + + +def load_state_dict_from_url( + url: str, + *, + model_dir: str | None = None, + filename: str | None = None, + progress: bool = True, + md5: str | None = None, + force: bool = False, +) -> Dict[str, Any]: + """Loads the Torch serialized object at the given URL. + + If the object is already present and valid in `model_dir`, it's + deserialized and returned. + + The default value of ``model_dir`` is ``/checkpoints`` where + ``hub_dir`` is the directory returned by :func:`~torch.hub.get_dir`. + + Args: + url: URL of the object to download. + model_dir: Directory in which to save the object. + filename: Name for the downloaded file. Filename from ``url`` will be used if not set. + progress: Whether or not to display a progress bar to stderr. + md5: MD5 file code to check whether the file is valid. If not, it will re-download it. + force: Whether to download the file regardless if it exists. + """ + model_dir = model_dir or os.path.join(hub.get_dir(), "checkpoints") + os.makedirs(model_dir, exist_ok=True) + + cached_file = os.path.join(model_dir, filename or os.path.basename(url)) + if force or not os.path.exists(cached_file) or not _check_integrity(cached_file, md5): + sys.stderr.write(f"Downloading: '{url}' to {cached_file}\n") + _download_url_to_file(url, cached_file, progress=progress) + if md5 is None or not _check_integrity(cached_file, md5): + sys.stderr.write(f"File MD5: {_calculate_md5(cached_file)}\n") + + return torch.load(cached_file, map_location="cpu") + + +def _download_url_to_file( + url: str, + dst: str, + *, + progress: bool = True, +) -> None: + """Download object at the given URL to a local path. + + Args: + url: URL of the object to download. + dst: Full path where object will be saved. + chunk_size: The size of each chunk to read in bytes. + progress: Whether or not to display a progress bar to stderr. + """ + try: + _download_with_fsspec(url=url, dst=dst, progress=progress) + except Exception: + try: + hub.download_url_to_file(url=url, dst=dst, progress=progress) + except Exception as hub_e: + raise RuntimeError( + f"Failed to download file from {url} using both fsspec and hub." + ) from hub_e + + +def _download_with_fsspec( + url: str, + dst: str, + *, + chunk_size: int = 1024 * 1024, + progress: bool = True, +) -> None: + """Download object at the given URL to a local path using fsspec. + + Args: + url: URL of the object to download. + dst: Full path where object will be saved. + chunk_size: The size of each chunk to read in bytes. + progress: Whether or not to display a progress bar to stderr. + """ + filesystem, _ = url_to_fs(url, anon=False) + total_size_bytes = filesystem.size(url) + with ( + filesystem.open(url, "rb") as remote_file, + tqdm( + total=total_size_bytes, + unit="iB", + unit_scale=True, + unit_divisor=1024, + disable=not progress, + ) as pbar, + ): + with open(dst, "wb") as local_file: + while True: + data = remote_file.read(chunk_size) + if not data: + break + + local_file.write(data) + pbar.update(chunk_size) + + +def _calculate_md5(path: str) -> str: + """Calculate the md5 hash of a file.""" + with open(path, "rb") as file: + return hashlib.md5(file.read(), usedforsecurity=False).hexdigest() + + +def _check_integrity(path: str, md5: str | None) -> bool: + """Check if the file matches the specified md5 hash.""" + return (md5 is None) or (md5 == _calculate_md5(path)) diff --git a/OpenMidnight/dinov2/__init__.py b/OpenMidnight/dinov2/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ae847e46898077fe3d8701b8a181d7b4e3d41cd9 --- /dev/null +++ b/OpenMidnight/dinov2/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +__version__ = "0.0.1" diff --git a/OpenMidnight/dinov2/configs/__init__.py b/OpenMidnight/dinov2/configs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..68e0830c62ea19649b6cd2361995f6df309d7640 --- /dev/null +++ b/OpenMidnight/dinov2/configs/__init__.py @@ -0,0 +1,22 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import pathlib + +from omegaconf import OmegaConf + + +def load_config(config_name: str): + config_filename = config_name + ".yaml" + return OmegaConf.load(pathlib.Path(__file__).parent.resolve() / config_filename) + + +dinov2_default_config = load_config("ssl_default_config") + + +def load_and_merge_config(config_name: str): + default_config = OmegaConf.create(dinov2_default_config) + loaded_config = load_config(config_name) + return OmegaConf.merge(default_config, loaded_config) diff --git a/OpenMidnight/dinov2/configs/eval/vitb14_pretrain.yaml b/OpenMidnight/dinov2/configs/eval/vitb14_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..117d0f027ca26cd8ce6c010bb78d5a8fac42c70e --- /dev/null +++ b/OpenMidnight/dinov2/configs/eval/vitb14_pretrain.yaml @@ -0,0 +1,6 @@ +student: + arch: vit_base + patch_size: 14 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/OpenMidnight/dinov2/configs/eval/vitb14_reg4_pretrain.yaml b/OpenMidnight/dinov2/configs/eval/vitb14_reg4_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..d53edc04a0761b4b35c147d63e04d55c90092c8f --- /dev/null +++ b/OpenMidnight/dinov2/configs/eval/vitb14_reg4_pretrain.yaml @@ -0,0 +1,9 @@ +student: + arch: vit_base + patch_size: 14 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/OpenMidnight/dinov2/configs/eval/vitg14_pretrain.yaml b/OpenMidnight/dinov2/configs/eval/vitg14_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a96dd5b117b4d59ee210b65037821f1b3e3f16e3 --- /dev/null +++ b/OpenMidnight/dinov2/configs/eval/vitg14_pretrain.yaml @@ -0,0 +1,7 @@ +student: + arch: vit_giant2 + patch_size: 14 + ffn_layer: swiglufused +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/OpenMidnight/dinov2/configs/eval/vitg14_reg4_pretrain.yaml b/OpenMidnight/dinov2/configs/eval/vitg14_reg4_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..15948f8589ea0a6e04717453eb88c18388e7f1b2 --- /dev/null +++ b/OpenMidnight/dinov2/configs/eval/vitg14_reg4_pretrain.yaml @@ -0,0 +1,10 @@ +student: + arch: vit_giant2 + patch_size: 14 + ffn_layer: swiglufused + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/OpenMidnight/dinov2/configs/eval/vitl14_pretrain.yaml b/OpenMidnight/dinov2/configs/eval/vitl14_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7a984548bd034f762d455419d7193917fa462dd8 --- /dev/null +++ b/OpenMidnight/dinov2/configs/eval/vitl14_pretrain.yaml @@ -0,0 +1,6 @@ +student: + arch: vit_large + patch_size: 14 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/OpenMidnight/dinov2/configs/eval/vitl14_reg4_pretrain.yaml b/OpenMidnight/dinov2/configs/eval/vitl14_reg4_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0e2bc4e7b24b1a64d0369a24927996d0f184e283 --- /dev/null +++ b/OpenMidnight/dinov2/configs/eval/vitl14_reg4_pretrain.yaml @@ -0,0 +1,9 @@ +student: + arch: vit_large + patch_size: 14 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/OpenMidnight/dinov2/configs/eval/vits14_pretrain.yaml b/OpenMidnight/dinov2/configs/eval/vits14_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..afbdb4ba14f1c97130a25b579360f4d817cda495 --- /dev/null +++ b/OpenMidnight/dinov2/configs/eval/vits14_pretrain.yaml @@ -0,0 +1,6 @@ +student: + arch: vit_small + patch_size: 14 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/OpenMidnight/dinov2/configs/eval/vits14_reg4_pretrain.yaml b/OpenMidnight/dinov2/configs/eval/vits14_reg4_pretrain.yaml new file mode 100644 index 0000000000000000000000000000000000000000..d25fd638389bfba9220792302dc9dbf5d9a2406a --- /dev/null +++ b/OpenMidnight/dinov2/configs/eval/vits14_reg4_pretrain.yaml @@ -0,0 +1,9 @@ +student: + arch: vit_small + patch_size: 14 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +crops: + global_crops_size: 518 # this is to set up the position embeddings properly + local_crops_size: 98 \ No newline at end of file diff --git a/OpenMidnight/dinov2/configs/ssl_default_config.yaml b/OpenMidnight/dinov2/configs/ssl_default_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5682e81607993999e0989975e2e1eda8e7378d3f --- /dev/null +++ b/OpenMidnight/dinov2/configs/ssl_default_config.yaml @@ -0,0 +1,129 @@ +MODEL: + WEIGHTS: '' +compute_precision: + grad_scaler: true + teacher: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: + param_dtype: fp16 + reduce_dtype: fp16 + buffer_dtype: fp32 + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: + param_dtype: fp16 + reduce_dtype: fp16 + buffer_dtype: fp32 + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: + param_dtype: fp16 + reduce_dtype: fp16 + buffer_dtype: fp32 + student: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: + param_dtype: fp16 + reduce_dtype: fp16 + buffer_dtype: fp32 + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: + param_dtype: fp16 + reduce_dtype: fp32 + buffer_dtype: fp32 + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: + param_dtype: fp16 + reduce_dtype: fp32 + buffer_dtype: fp32 +dino: + loss_weight: 1.0 + head_n_prototypes: 65536 + head_bottleneck_dim: 256 + head_nlayers: 3 + head_hidden_dim: 2048 + koleo_loss_weight: 0.1 +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.5 + separate_head: false + head_n_prototypes: 65536 + head_bottleneck_dim: 256 + head_nlayers: 3 + head_hidden_dim: 2048 +train: + batch_size_per_gpu: 64 + dataset_path: ImageNet:split=TRAIN + output_dir: . + saveckp_freq: 20 + skip_checkpointer: null # if null, auto-skip when running on a single GPU + seed: 0 + num_workers: 10 + OFFICIAL_EPOCH_LENGTH: 1250 + cache_dataset: true + centering: "centering" # or "sinkhorn_knopp" + unfreeze_last_n_blocks: 40 +student: + arch: vit_large + patch_size: 16 + drop_path_rate: 0.3 + layerscale: 1.0e-05 + drop_path_uniform: true + pretrained_weights: '' + ffn_layer: "mlp" + block_chunks: 0 + qkv_bias: true + proj_bias: true + ffn_bias: true + num_register_tokens: 0 + interpolate_antialias: false + interpolate_offset: 0.1 +teacher: + momentum_teacher: 0.992 + final_momentum_teacher: 1 + warmup_teacher_temp: 0.04 + teacher_temp: 0.07 + warmup_teacher_temp_epochs: 30 +optim: + epochs: 100 + weight_decay: 0.04 + weight_decay_end: 0.4 + base_lr: 0.004 # learning rate for a batch size of 1024 + lr: 0. # will be set after applying scaling rule + warmup_epochs: 10 + min_lr: 1.0e-06 + clip_grad: 3.0 + freeze_last_layer_epochs: 1 + scaling_rule: sqrt_wrt_1024 + patch_embed_lr_mult: 0.2 + layerwise_decay: 0.9 + adamw_beta1: 0.9 + adamw_beta2: 0.999 +crops: + global_crops_scale: + - 0.32 + - 1.0 + local_crops_number: 8 + local_crops_scale: + - 0.05 + - 0.32 + global_crops_size: 224 + local_crops_size: 96 +evaluation: + eval_period_iterations: 12500 + bach_root: /data/eva-data/bach +gram: + use_loss: false + normalized: true + remove_neg: true + loss_weight: 1.0 + it_first_update: 34000 + ramp_iters: 5000 + ckpt: "" diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_bs64_test.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_bs64_test.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5c03c74b60913f51697e2c46c0ae2fa9510f009a --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_bs64_test.yaml @@ -0,0 +1,84 @@ +# bs=64 대용량 batch 검증 — full+CPTAC(582.0M) ViT-g/14, 48 GPU, bs=64/GPU(global 3072). +# ★ 공정비교: batch 8배↑ → steps 1/8↓ = 같은 데이터노출. bs=8 full+cptac 137.5k스케줄을 통째로 1/8 축소. +# = OFFICIAL_EPOCH_LENGTH 1250→156(=1250/8), 나머지 epoch-단위 파라미터는 bs=8 config와 동일. +# → 데이터·스케줄위치 완벽 1/8 복제. LR만 sqrt스케일로 자동상향(1.84e-4→5.20e-4). +# 판정: early_stop 80(=12,480 iters ≈ bs8의 100k/8, 동일 38.4M samples)서 정지 → HEST probe. +# bs=8 full+cptac 100k=0.3753(full 100k=0.3834)와 비교. 유지되면 bs=64로 1epoch 최종학습. +# ★ fp16→bf16 전환(아래 compute_precision): 1차 bs=64 런이 iter~8695서 fp16 오버플로로 NaN 크래시 +# (loss는 7.9서 평탄·안정하다 단발 NaN=고LR발산 아님). bf16은 fp32 표현범위라 오버플로 원천차단. +# bf16이므로 grad_scaler off(loss scaling 불필요). LR·batch·스케줄은 1차와 동일(bf16만 변경). +compute_precision: + grad_scaler: false # bf16은 loss scaling 불필요 → off + teacher: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + student: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/tiles/shards/w*/*.tar,/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data_cptac/tiles/shards/w*/*.tar" + streaming_from_hf: false + batch_size_per_gpu: 64 # × 48 GPU = global 3072 (bs=8의 8배) + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 156 # = 1250/8 → 전 스케줄 1/8 축소(데이터노출 동일) + saveckp_freq: 16 # resume ckpt = 16×156 = 2,496 iters + num_workers: 10 + prefetch_factor: 4 + skip_checkpointer: false +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 + warmup_teacher_temp_epochs: 30 # = bs=8 동일(30×156=4,680 iters = 37,500/8) +optim: + epochs: 110 # × 156 = 17,160 iters (≈137.5k/8) — schedule 지평 + early_stop: 80 # ★ 12,480 iters서 정지(=100k/8, 동일 38.4M samples) → probe + weight_decay_end: 0.2 + base_lr: 3.0e-04 # 원래값 유지(LR 안 건드림). NaN 원인은 LR 아닌 fp16 오버플로였음 → bf16으로 해결 + warmup_epochs: 10 # = bs=8 동일(10×156=1,560 = 12,500/8) + freeze_last_layer_epochs: 1 # 156 iters (=1,250/8) + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 2496 # probe ckpt at 2496,4992,7488,9984,12480 (~5개) + bach_root: "" + breakhis_root: "" + pcam_root: "" diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_curated.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_curated.yaml new file mode 100644 index 0000000000000000000000000000000000000000..aaa71d767994bd1b003ab5b7f4129e44a932e9df --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_curated.yaml @@ -0,0 +1,57 @@ +# OpenPath × OpenMidnight — ViT-g/14 warm-start, 우리 mag20 데이터(큐레이션). +# 목적: 2×2의 빈 칸 채우기 = ViT-g × 우리데이터(mag20). +# ViT-L 우리데이터=0.264, ViT-g 그들데이터(native)=0.382. 이 런이 ViT-g 우리데이터. +# 결과로 "남은 격차 중 데이터 해상도 몫"을 분리 → native 재추출 가치 판정. +# 레시피·아키텍처는 openpath_vitg14_testB.yaml과 동일(깨끗한 A/B), 데이터만 우리 TAR(큐레이션 암@20x). +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + # openpath: 분기 → openpath_wds.py TAR 로더(interleave=24 수정 = ~22 WSI/배치 다양성). + # 큐레이션: 암 41659 WSI @ 20x (GTEx 제거 + mag20). ViT-L 0.264와 동일 데이터 셀. + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/tiles/shards/w*/*.tar:split=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/splits/pretrain_train_cancer.txt:mag=20" + streaming_from_hf: false + batch_size_per_gpu: 8 # × 48 GPU = global 384 (Test B와 동일) + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + num_workers: 10 # 다운로드 타일워커와 CPU 공유 → 약간 보수적 + prefetch_factor: 4 + skip_checkpointer: false # resume 가능 +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused # ★ Meta vitg14 = swiglu + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 +optim: + epochs: 110 + early_stop: 110 + weight_decay_end: 0.2 + base_lr: 3.0e-04 + warmup_epochs: 10 + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 2500 + bach_root: "" + breakhis_root: "" + pcam_root: "" diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_final.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_final.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a3888055bc6e159853c2e0682e540cdef4323468 --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_final.yaml @@ -0,0 +1,80 @@ +# ★★ OpenPath 최종 학습 — full+CPTAC(582.0M) ViT-g/14, 48 GPU, bs=64+bf16, 1 EPOCH. +# 검증완료(2026-07-01): bs=64+bf16 @12,480 = 0.3721 ≈ bs=8 @100k 0.3753(품질유지). throughput 4배(~1.8일). +# 1 epoch = 582.0M / global3072 = 189,453 iters. schedule 지평 190,000(OEL 1250 × epochs 152). +# 체크포인트 0.05 epoch(=9,473 iters)마다 = eval_period 9500 → 정확히 20개 teacher_checkpoint(probe용). +# ★ bf16 필수(fp16은 bs=64서 오버플로 NaN). grad_scaler off. LR=sqrt스케일 eff 5.2e-4(검증런 동일). +compute_precision: + grad_scaler: false + teacher: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + student: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/tiles/shards/w*/*.tar,/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data_cptac/tiles/shards/w*/*.tar" + streaming_from_hf: false + batch_size_per_gpu: 64 # × 48 GPU = global 3072 + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + saveckp_freq: 8 # resume ckpt = 8×1250 = 10,000 iters ≈ 0.05 epoch + num_workers: 10 + prefetch_factor: 4 + skip_checkpointer: false +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 + warmup_teacher_temp_epochs: 41 # 0.27 epoch (검증 27% 비율) = 51,250 iters +optim: + epochs: 152 # × 1250 = 190,000 iters ≈ 1 epoch(189,453) + early_stop: 152 # 완주(테스트의 early_stop 80 제거) + weight_decay_end: 0.2 + base_lr: 3.0e-04 # sqrt_wrt_1024 → 실효 5.20e-4 (검증런 동일) + warmup_epochs: 14 # 0.09 epoch (검증 9% 비율) = 17,500 iters + freeze_last_layer_epochs: 1 # 1250 iters + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 9500 # 0.05 epoch마다 teacher_checkpoint(probe용) → 190000/9500 = 정확히 20개 + bach_root: "" + breakhis_root: "" + pcam_root: "" diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_final_1ep.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_final_1ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c65136b9db13093f5f31331f7da7d38163a2ed5a --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_final_1ep.yaml @@ -0,0 +1,59 @@ +# ★ OpenPath 최종 학습 — full + CPTAC 코퍼스(582.0M 타일) ViT-g/14, 48 GPU, 1 EPOCH. +# 코퍼스: full(566.2M, 전 슬라이드·전 배율) + CPTAC(15.79M, 6암종) = 582.0M 타일. +# 1 epoch 정의: 582.0M / global384 = 1,516,250 iters (OFFICIAL_EPOCH_LENGTH 1250 × epochs 1213). +# per-epoch 단위 파라미터(warmup/ttemp/freeze)는 1250-iter 단위 유지 → 검증레시피(0.3873) 비율을 1ep로 stretch. +# 체크포인트: 0.1 epoch(=151,250 iters)마다 = saveckp_freq 121 + eval_period 151250 → 약 10개. +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + # openpath TAR 로더(interleave=24). 콤마구분 다중 glob = full + cptac union. split·mag 필터 없음. + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/tiles/shards/w*/*.tar,/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data_cptac/tiles/shards/w*/*.tar" + streaming_from_hf: false + batch_size_per_gpu: 8 # × 48 GPU = global 384 (검증 레시피 동일) + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 # 스케줄 단위(검증런과 동일) — per-epoch 파라미터 절대 iter값 보존 + saveckp_freq: 121 # resume 체크포인트 = 121×1250 = 151,250 iters ≈ 0.1 epoch + num_workers: 10 + prefetch_factor: 4 + skip_checkpointer: false # resume 가능 +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 + warmup_teacher_temp_epochs: 328 # 0.27 epoch (검증런 30/110=27% 비율 그대로) = 410k iters +optim: + epochs: 1213 # × 1250 = 1,516,250 iters ≈ 1 epoch(582.0M/384) + early_stop: 1213 + weight_decay_end: 0.2 + base_lr: 3.0e-04 # sqrt_wrt_1024 스케일 → 실효 lr 1.84e-4 (검증런 동일) + warmup_epochs: 109 # 0.09 epoch (검증런 10/110=9% 비율) = 136,250 iters warmup + freeze_last_layer_epochs: 1 # 1250 iters last-layer freeze (검증런 동일, warm-start 안정화) + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 151250 # 0.1 epoch마다 teacher_checkpoint 저장(probe용) → ~10개 + bach_root: "" + breakhis_root: "" + pcam_root: "" diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_final_1ep_bs64.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_final_1ep_bs64.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c67f9d057a28ac0ddf5b4ae3b5fd122c99ae4907 --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_final_1ep_bs64.yaml @@ -0,0 +1,59 @@ +# ★ OpenPath 최종학습 후보 — full+CPTAC(582.0M) ViT-g/14, 48 GPU, bs=64/GPU(global 3072), 1 EPOCH. +# 목적: 대용량 batch(3072)가 (1) throughput↑로 epoch 단축, (2) HEST 성능 유지하는지 100k서 검증. +# 1 epoch = 582.0M / 3072 = 189,453 iters (bs=8 1.516M의 1/8 스텝). schedule은 1ep 지평. +# ★ early_stop=80(=100,000 iters)에서 멈춰 판정 → 성능 유지되면 early_stop 늘려 resume·완주. +# 체크포인트 0.1 epoch(=18,750 iters)마다(saveckp_freq 15 + eval_period 18750). +# per-epoch 파라미터는 1250-iter 단위 유지 → 검증레시피(0.3873) 비율을 1ep로 stretch. LR=sqrt스케일 자동상향. +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/tiles/shards/w*/*.tar,/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data_cptac/tiles/shards/w*/*.tar" + streaming_from_hf: false + batch_size_per_gpu: 64 # × 48 GPU = global 3072 + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + saveckp_freq: 15 # resume ckpt = 15×1250 = 18,750 iters ≈ 0.1 epoch + num_workers: 10 + prefetch_factor: 4 + skip_checkpointer: false +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 + warmup_teacher_temp_epochs: 41 # 0.27 epoch (검증 27% 비율) = 51,250 iters +optim: + epochs: 152 # × 1250 = 190,000 iters ≈ 1 epoch(189,453) — schedule 지평 + early_stop: 80 # ★ 100,000 iters서 정지(bs=64 검증). 통과시 152로 늘려 resume + weight_decay_end: 0.2 + base_lr: 3.0e-04 # sqrt_wrt_1024 → 실효 lr 5.20e-4 (global 3072) + warmup_epochs: 14 # 0.09 epoch (검증 9% 비율) = 17,500 iters warmup + freeze_last_layer_epochs: 1 # 1250 iters last-layer freeze (warm-start 안정화) + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 18750 # 0.1 epoch마다 teacher_checkpoint(probe용) + bach_root: "" + breakhis_root: "" + pcam_root: "" diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_full.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_full.yaml new file mode 100644 index 0000000000000000000000000000000000000000..659e729a253668c69f9ebae62aacb4d87d25e6aa --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_full.yaml @@ -0,0 +1,55 @@ +# 풀코퍼스 ViT-g/14 — 전 슬라이드(GTEx 정상 포함 ~68k) + 전 배율(20x/10x/5x). +# 목적: 큐레이션(암@20x)과 동일 레시피·스케줄(137.5k 코사인)로 데이터만 풀코퍼스 → 100k서 probe. +# 비교기준 = 큐레이션 100k=0.3765. 데이터 다양성(멀티스케일+정상)이 HEST 유지/향상하는지 검증. +# 큐레이션과의 유일 차이 = sample_list_path에서 :split·:mag 필터 제거(전 타일 사용). +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + # openpath: TAR 로더(interleave=24). split·mag 필터 없음 → 전 슬라이드·전 배율(565.9M 타일). + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/tiles/shards/w*/*.tar" + streaming_from_hf: false + batch_size_per_gpu: 8 # × 48 GPU = global 384 (큐레이션 동일) + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + num_workers: 10 + prefetch_factor: 4 + skip_checkpointer: false # resume 가능 +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 +optim: + epochs: 110 # 137.5k 스케줄(큐레이션 동일) — 100k서 probe해 LR시점 일치 + early_stop: 110 + weight_decay_end: 0.2 + base_lr: 3.0e-04 + warmup_epochs: 10 + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 2500 + bach_root: "" + breakhis_root: "" + pcam_root: "" diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_full_cptac.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_full_cptac.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8cb09efa42cb82efddcf063f2ba4d5fe37ca0741 --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_full_cptac.yaml @@ -0,0 +1,55 @@ +# 풀코퍼스 + CPTAC ViT-g/14 — full(전 슬라이드·전 배율, 565.9M 타일) + CPTAC(15.79M 타일, 6암종). +# 목적: 본모델(full final HEST 0.3873)에 CPTAC 추가가 HEST를 더 올리는지 검증. +# full 대비 유일 차이 = sample_list_path에 data_cptac 샤드 glob을 콤마로 추가(union). +# 레시피·스케줄은 full과 100% 동일(137.5k 코사인, ViT-g warm-start) → 데이터만의 효과를 분리. +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + # openpath TAR 로더(interleave=24). 콤마구분 다중 glob = full + cptac union. split·mag 필터 없음. + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/tiles/shards/w*/*.tar,/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data_cptac/tiles/shards/w*/*.tar" + streaming_from_hf: false + batch_size_per_gpu: 8 # × 48 GPU = global 384 (full 동일) + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + num_workers: 10 + prefetch_factor: 4 + skip_checkpointer: false # resume 가능 +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 +optim: + epochs: 110 # 137.5k 스케줄(full 동일) — 100k서 probe해 LR시점 일치 + early_stop: 110 + weight_decay_end: 0.2 + base_lr: 3.0e-04 + warmup_epochs: 10 + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 2500 + bach_root: "" + breakhis_root: "" + pcam_root: "" diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_run2.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_run2.yaml new file mode 100644 index 0000000000000000000000000000000000000000..23ca556fdcb292f4a6625c7cddf91078b52c36dc --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_run2.yaml @@ -0,0 +1,84 @@ +# ★★ OpenPath run 2 — full+CPTAC(582M) ViT-g/14, ★40 GPU(TJ-2~6, 5노드), bs=64+bf16, 1 EPOCH. +# TJ-1은 학습 제외(에이전트+실시간 eval watcher 전용). global batch = 64×40 = 2560. +# run1(0.3792 peak@161500 후 하락, 전체최고는 28500=0.3816) 대비 = "OpenMidnight식 LR 레짐"만 교체(코퍼스·bs 동일). +# ① base_lr 3e-4→2e-4 (실효 → 2e-4×sqrt(2560/1024)=3.16e-4, OpenMidnight base값). +# ② ★ anneal 제거: epochs 8000(스케줄 지평만 확대=10M iter) + early_stop 182(=227,500 iter≈1 epoch서 실제 정지). +# → LR이 227.5k/10M=2.3%만 밟아 peak의 ~99.7% 유지(near-constant). wd·teacher-momentum도 near-initial(OM 레짐). +# ③ warmup 5% (warmup_epochs 9.1 = 11,375 iter). +# ④ eval_period 5700 → ~40 teacher_checkpoint(0.025ep마다). TJ-1 watcher가 실시간 HEST 곡선. +# ★ 1 epoch = 582.0M / 2560 = 227,343 iter. 검증필요: 3.16e-4 flat+1ep under-training 여부 → 실시간 곡선으로 조기판단, 상승지속시 early_stop 상향. +compute_precision: + grad_scaler: false + teacher: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + student: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/tiles/shards/w*/*.tar,/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data_cptac/tiles/shards/w*/*.tar" + streaming_from_hf: false + batch_size_per_gpu: 64 # × 40 GPU(TJ-2~6) = global 2560 + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + saveckp_freq: 8 # resume ckpt = 8×1250 = 10,000 iters + num_workers: 10 + prefetch_factor: 4 + skip_checkpointer: false +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 + warmup_teacher_temp_epochs: 41 # 0.27 epoch = 51,250 iters (epochs와 독립, run1과 동일) +optim: + epochs: 8000 # ★ 스케줄 지평만 확대(=10,000,000 iter). LR/wd/momentum near-constant. + early_stop: 184 # ★ 정지 = 184×1250 = 230,000 iter ≈ 1.01 epoch. eval_period 5750의 배수(40×5750)=정지점서 최종ckpt 저장 + weight_decay_end: 0.2 # 8000ep 지평이라 227.5k선 wd≈0.040(near-initial, 미도달) + base_lr: 2.0e-04 # ★ sqrt_wrt_1024 → 실효 3.16e-4 @batch2560 (OpenMidnight base) + warmup_epochs: 9 # ★ 11,250 iter ≈ 4.9% (정수 필수: np.linspace(...,warmup_iters)가 int만 허용. 9.1이면 crash) + freeze_last_layer_epochs: 1 # 1250 iters + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 5750 # ★ teacher_checkpoint 40개(5750×1..40=230,000, 정지점 포함). TJ-1 watcher가 실시간 probe. + bach_root: "" + breakhis_root: "" + pcam_root: "" diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_run3_gram.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_run3_gram.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e43f3eaf604fdd9348bd35e51771875e24fcab79 --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_run3_gram.yaml @@ -0,0 +1,92 @@ +# ★★ OpenPath run 2 — full+CPTAC(582M) ViT-g/14, ★40 GPU(TJ-2~6, 5노드), bs=64+bf16, 1 EPOCH. +# TJ-1은 학습 제외(에이전트+실시간 eval watcher 전용). global batch = 64×40 = 2560. +# run1(0.3792 peak@161500 후 하락, 전체최고는 28500=0.3816) 대비 = "OpenMidnight식 LR 레짐"만 교체(코퍼스·bs 동일). +# ① base_lr 3e-4→2e-4 (실효 → 2e-4×sqrt(2560/1024)=3.16e-4, OpenMidnight base값). +# ② ★ anneal 제거: epochs 8000(스케줄 지평만 확대=10M iter) + early_stop 182(=227,500 iter≈1 epoch서 실제 정지). +# → LR이 227.5k/10M=2.3%만 밟아 peak의 ~99.7% 유지(near-constant). wd·teacher-momentum도 near-initial(OM 레짐). +# ③ warmup 5% (warmup_epochs 9.1 = 11,375 iter). +# ④ eval_period 5700 → ~40 teacher_checkpoint(0.025ep마다). TJ-1 watcher가 실시간 HEST 곡선. +# ★ 1 epoch = 582.0M / 2560 = 227,343 iter. 검증필요: 3.16e-4 flat+1ep under-training 여부 → 실시간 곡선으로 조기판단, 상승지속시 early_stop 상향. +compute_precision: + grad_scaler: false + teacher: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + student: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/tiles/shards/w*/*.tar,/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data_cptac/tiles/shards/w*/*.tar" + streaming_from_hf: false + batch_size_per_gpu: 64 # × 40 GPU(TJ-2~6) = global 2560 + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + saveckp_freq: 8 # resume ckpt = 8×1250 = 10,000 iters + num_workers: 10 + prefetch_factor: 4 + skip_checkpointer: false +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 + warmup_teacher_temp_epochs: 41 # 0.27 epoch = 51,250 iters (epochs와 독립, run1과 동일) +optim: + epochs: 8000 # ★ 스케줄 지평만 확대(=10,000,000 iter). LR/wd/momentum near-constant. + early_stop: 184 # ★ 정지 = 184×1250 = 230,000 iter ≈ 1.01 epoch. eval_period 5750의 배수(40×5750)=정지점서 최종ckpt 저장 + weight_decay_end: 0.2 # 8000ep 지평이라 227.5k선 wd≈0.040(near-initial, 미도달) + base_lr: 2.0e-04 # ★ sqrt_wrt_1024 → 실효 3.16e-4 @batch2560 (OpenMidnight base) + warmup_epochs: 9 # ★ 11,250 iter ≈ 4.9% (정수 필수: np.linspace(...,warmup_iters)가 int만 허용. 9.1이면 crash) + freeze_last_layer_epochs: 1 # 1250 iters + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 5750 # ★ teacher_checkpoint 40개(5750×1..40=230,000, 정지점 포함). TJ-1 watcher가 실시간 probe. + bach_root: "" + breakhis_root: "" + pcam_root: "" +gram: + use_loss: true # ★ gram anchoring 켜기 + normalized: true + remove_neg: true + loss_weight: 1.0 + it_first_update: 34000 # ~0.15 epoch: 우리 peak 부근서 gram 활성 → 이후 하락 방지 + ramp_iters: 5000 # 34k~39k 선형 ramp + ckpt: /NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/runs/om_vitg14_final/eval/training_28500/teacher_checkpoint.pth diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_run3_smoke.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_run3_smoke.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ffc260b4a7c829946e8c49e5ff6faef71b34919b --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_run3_smoke.yaml @@ -0,0 +1,92 @@ +# ★★ OpenPath run 2 — full+CPTAC(582M) ViT-g/14, ★40 GPU(TJ-2~6, 5노드), bs=64+bf16, 1 EPOCH. +# TJ-1은 학습 제외(에이전트+실시간 eval watcher 전용). global batch = 64×40 = 2560. +# run1(0.3792 peak@161500 후 하락, 전체최고는 28500=0.3816) 대비 = "OpenMidnight식 LR 레짐"만 교체(코퍼스·bs 동일). +# ① base_lr 3e-4→2e-4 (실효 → 2e-4×sqrt(2560/1024)=3.16e-4, OpenMidnight base값). +# ② ★ anneal 제거: epochs 8000(스케줄 지평만 확대=10M iter) + early_stop 182(=227,500 iter≈1 epoch서 실제 정지). +# → LR이 227.5k/10M=2.3%만 밟아 peak의 ~99.7% 유지(near-constant). wd·teacher-momentum도 near-initial(OM 레짐). +# ③ warmup 5% (warmup_epochs 9.1 = 11,375 iter). +# ④ eval_period 5700 → ~40 teacher_checkpoint(0.025ep마다). TJ-1 watcher가 실시간 HEST 곡선. +# ★ 1 epoch = 582.0M / 2560 = 227,343 iter. 검증필요: 3.16e-4 flat+1ep under-training 여부 → 실시간 곡선으로 조기판단, 상승지속시 early_stop 상향. +compute_precision: + grad_scaler: false + teacher: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + student: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/tiles/shards/w*/*.tar,/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data_cptac/tiles/shards/w*/*.tar" + streaming_from_hf: false + batch_size_per_gpu: 64 # × 40 GPU(TJ-2~6) = global 2560 + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + saveckp_freq: 8 # resume ckpt = 8×1250 = 10,000 iters + num_workers: 10 + prefetch_factor: 4 + skip_checkpointer: false +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 + warmup_teacher_temp_epochs: 41 # 0.27 epoch = 51,250 iters (epochs와 독립, run1과 동일) +optim: + epochs: 8000 # ★ 스케줄 지평만 확대(=10,000,000 iter). LR/wd/momentum near-constant. + early_stop: 184 # ★ 정지 = 184×1250 = 230,000 iter ≈ 1.01 epoch. eval_period 5750의 배수(40×5750)=정지점서 최종ckpt 저장 + weight_decay_end: 0.2 # 8000ep 지평이라 227.5k선 wd≈0.040(near-initial, 미도달) + base_lr: 2.0e-04 # ★ sqrt_wrt_1024 → 실효 3.16e-4 @batch2560 (OpenMidnight base) + warmup_epochs: 9 # ★ 11,250 iter ≈ 4.9% (정수 필수: np.linspace(...,warmup_iters)가 int만 허용. 9.1이면 crash) + freeze_last_layer_epochs: 1 # 1250 iters + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 5750 # ★ teacher_checkpoint 40개(5750×1..40=230,000, 정지점 포함). TJ-1 watcher가 실시간 probe. + bach_root: "" + breakhis_root: "" + pcam_root: "" +gram: + use_loss: true # ★ gram anchoring 켜기 + normalized: true + remove_neg: true + loss_weight: 1.0 + it_first_update: 5 + ramp_iters: 3 + ckpt: /NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/runs/om_vitg14_final/eval/training_28500/teacher_checkpoint.pth diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_run4_gram.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_run4_gram.yaml new file mode 100644 index 0000000000000000000000000000000000000000..20407e19c8ec565fa4f2d758c5c9975fd67e5579 --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_run4_gram.yaml @@ -0,0 +1,92 @@ +# ★★ OpenPath run 2 — full+CPTAC(582M) ViT-g/14, ★40 GPU(TJ-2~6, 5노드), bs=64+bf16, 1 EPOCH. +# TJ-1은 학습 제외(에이전트+실시간 eval watcher 전용). global batch = 64×40 = 2560. +# run1(0.3792 peak@161500 후 하락, 전체최고는 28500=0.3816) 대비 = "OpenMidnight식 LR 레짐"만 교체(코퍼스·bs 동일). +# ① base_lr 3e-4→2e-4 (실효 → 2e-4×sqrt(2560/1024)=3.16e-4, OpenMidnight base값). +# ② ★ anneal 제거: epochs 8000(스케줄 지평만 확대=10M iter) + early_stop 182(=227,500 iter≈1 epoch서 실제 정지). +# → LR이 227.5k/10M=2.3%만 밟아 peak의 ~99.7% 유지(near-constant). wd·teacher-momentum도 near-initial(OM 레짐). +# ③ warmup 5% (warmup_epochs 9.1 = 11,375 iter). +# ④ eval_period 5700 → ~40 teacher_checkpoint(0.025ep마다). TJ-1 watcher가 실시간 HEST 곡선. +# ★ 1 epoch = 582.0M / 2560 = 227,343 iter. 검증필요: 3.16e-4 flat+1ep under-training 여부 → 실시간 곡선으로 조기판단, 상승지속시 early_stop 상향. +compute_precision: + grad_scaler: false + teacher: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + student: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/tiles/shards/w*/*.tar,/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data_cptac/tiles/shards/w*/*.tar" + streaming_from_hf: false + batch_size_per_gpu: 64 # × 40 GPU(TJ-2~6) = global 2560 + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + saveckp_freq: 8 # resume ckpt = 8×1250 = 10,000 iters + num_workers: 10 + prefetch_factor: 4 + skip_checkpointer: false +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 + warmup_teacher_temp_epochs: 41 # 0.27 epoch = 51,250 iters (epochs와 독립, run1과 동일) +optim: + epochs: 8000 # ★ 스케줄 지평만 확대(=10,000,000 iter). LR/wd/momentum near-constant. + early_stop: 184 # ★ 정지 = 184×1250 = 230,000 iter ≈ 1.01 epoch. eval_period 5750의 배수(40×5750)=정지점서 최종ckpt 저장 + weight_decay_end: 0.2 # 8000ep 지평이라 227.5k선 wd≈0.040(near-initial, 미도달) + base_lr: 2.0e-04 # ★ sqrt_wrt_1024 → 실효 3.16e-4 @batch2560 (OpenMidnight base) + warmup_epochs: 9 # ★ 11,250 iter ≈ 4.9% (정수 필수: np.linspace(...,warmup_iters)가 int만 허용. 9.1이면 crash) + freeze_last_layer_epochs: 1 # 1250 iters + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 5750 # ★ teacher_checkpoint 40개(5750×1..40=230,000, 정지점 포함). TJ-1 watcher가 실시간 probe. + bach_root: "" + breakhis_root: "" + pcam_root: "" +gram: + use_loss: true + normalized: true + remove_neg: true + loss_weight: 20.0 # ★ run3(1.0)의 20배 — 앵커서 ~3.4%, drift시 ~10%+로 물게. 과제약이면 실시간곡선서 감지→하향 + it_first_update: 23000 # ★ peak(23k)에서 gram 활성(run3는 34k 지각 활성해 peak·dip 놓침) + ramp_iters: 3000 # 23k~26k ramp + ckpt: /NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/runs/om_vitg14_run3/eval/training_23000/teacher_checkpoint.pth diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_run5_native.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_run5_native.yaml new file mode 100644 index 0000000000000000000000000000000000000000..830f463e50834d1d0049d6dc35e5de8b8dd1ce3a --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_run5_native.yaml @@ -0,0 +1,84 @@ +# ★★ OpenPath run5 — ★native 40× 재추출 코퍼스(33,991 shard, 암85%) + flat-LR 40GPU + early-stop(gram 없음). 데이터 품질 레버. +# TJ-1은 학습 제외(에이전트+실시간 eval watcher 전용). global batch = 64×40 = 2560. +# run1(0.3792 peak@161500 후 하락, 전체최고는 28500=0.3816) 대비 = "OpenMidnight식 LR 레짐"만 교체(코퍼스·bs 동일). +# ① base_lr 3e-4→2e-4 (실효 → 2e-4×sqrt(2560/1024)=3.16e-4, OpenMidnight base값). +# ② ★ anneal 제거: epochs 8000(스케줄 지평만 확대=10M iter) + early_stop 182(=227,500 iter≈1 epoch서 실제 정지). +# → LR이 227.5k/10M=2.3%만 밟아 peak의 ~99.7% 유지(near-constant). wd·teacher-momentum도 near-initial(OM 레짐). +# ③ warmup 5% (warmup_epochs 9.1 = 11,375 iter). +# ④ eval_period 5700 → ~40 teacher_checkpoint(0.025ep마다). TJ-1 watcher가 실시간 HEST 곡선. +# ★ 1 epoch = 582.0M / 2560 = 227,343 iter. 검증필요: 3.16e-4 flat+1ep under-training 여부 → 실시간 곡선으로 조기판단, 상승지속시 early_stop 상향. +compute_precision: + grad_scaler: false + teacher: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + student: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data_native/*/tiles/shards/w*/*.tar" + streaming_from_hf: false + batch_size_per_gpu: 64 # × 40 GPU(TJ-2~6) = global 2560 + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + saveckp_freq: 8 # resume ckpt = 8×1250 = 10,000 iters + num_workers: 10 + prefetch_factor: 4 + skip_checkpointer: false +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 + warmup_teacher_temp_epochs: 41 # 0.27 epoch = 51,250 iters (epochs와 독립, run1과 동일) +optim: + epochs: 8000 # ★ 스케줄 지평만 확대(=10,000,000 iter). LR/wd/momentum near-constant. + early_stop: 276 # ★ native 1 full epoch: 276×1250=345,000 iter(=1.06ep, 5750×60 정렬). run2값 184(230k=0.71ep native) 교정 + weight_decay_end: 0.2 # 8000ep 지평이라 227.5k선 wd≈0.040(near-initial, 미도달) + base_lr: 2.0e-04 # ★ sqrt_wrt_1024 → 실효 3.16e-4 @batch2560 (OpenMidnight base) + warmup_epochs: 9 # ★ 11,250 iter ≈ 4.9% (정수 필수: np.linspace(...,warmup_iters)가 int만 허용. 9.1이면 crash) + freeze_last_layer_epochs: 1 # 1250 iters + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 5750 # ★ teacher_checkpoint 40개(5750×1..40=230,000, 정지점 포함). TJ-1 watcher가 실시간 probe. + bach_root: "" + breakhis_root: "" + pcam_root: "" diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_run6_native_gram.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_run6_native_gram.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7b17e14d04c34efa23fcb824f9983b87dc99a636 --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_run6_native_gram.yaml @@ -0,0 +1,93 @@ +# ★★ OpenPath run6 — native 40× 코퍼스 + gram anchoring(weight 40, 앵커=run5 native peak 0.3834). native 하락 방지 시도. +# TJ-1은 학습 제외(에이전트+실시간 eval watcher 전용). global batch = 64×40 = 2560. +# run1(0.3792 peak@161500 후 하락, 전체최고는 28500=0.3816) 대비 = "OpenMidnight식 LR 레짐"만 교체(코퍼스·bs 동일). +# ① base_lr 3e-4→2e-4 (실효 → 2e-4×sqrt(2560/1024)=3.16e-4, OpenMidnight base값). +# ② ★ anneal 제거: epochs 8000(스케줄 지평만 확대=10M iter) + early_stop 182(=227,500 iter≈1 epoch서 실제 정지). +# → LR이 227.5k/10M=2.3%만 밟아 peak의 ~99.7% 유지(near-constant). wd·teacher-momentum도 near-initial(OM 레짐). +# ③ warmup 5% (warmup_epochs 9.1 = 11,375 iter). +# ④ eval_period 5700 → ~40 teacher_checkpoint(0.025ep마다). TJ-1 watcher가 실시간 HEST 곡선. +# ★ 1 epoch = 582.0M / 2560 = 227,343 iter. 검증필요: 3.16e-4 flat+1ep under-training 여부 → 실시간 곡선으로 조기판단, 상승지속시 early_stop 상향. +compute_precision: + grad_scaler: false + teacher: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + student: + backbone: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: bf16, buffer_dtype: fp32} + dino_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} + ibot_head: + sharding_strategy: SHARD_GRAD_OP + mixed_precision: {param_dtype: bf16, reduce_dtype: fp32, buffer_dtype: fp32} +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data_native/*/tiles/shards/w*/*.tar" + streaming_from_hf: false + batch_size_per_gpu: 64 # × 40 GPU(TJ-2~6) = global 2560 + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + saveckp_freq: 8 # resume ckpt = 8×1250 = 10,000 iters + num_workers: 10 + prefetch_factor: 4 + skip_checkpointer: false +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 + warmup_teacher_temp_epochs: 41 # 0.27 epoch = 51,250 iters (epochs와 독립, run1과 동일) +optim: + epochs: 8000 # ★ 스케줄 지평만 확대(=10,000,000 iter). LR/wd/momentum near-constant. + early_stop: 276 # ★ native 1 full epoch: 276×1250=345,000 iter(=1.06ep, 5750×60 정렬). run2값 184(230k=0.71ep native) 교정 + weight_decay_end: 0.2 # 8000ep 지평이라 227.5k선 wd≈0.040(near-initial, 미도달) + base_lr: 2.0e-04 # ★ sqrt_wrt_1024 → 실효 3.16e-4 @batch2560 (OpenMidnight base) + warmup_epochs: 9 # ★ 11,250 iter ≈ 4.9% (정수 필수: np.linspace(...,warmup_iters)가 int만 허용. 9.1이면 crash) + freeze_last_layer_epochs: 1 # 1250 iters + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 5750 # ★ teacher_checkpoint 40개(5750×1..40=230,000, 정지점 포함). TJ-1 watcher가 실시간 probe. + bach_root: "" + breakhis_root: "" + pcam_root: "" + +gram: + use_loss: true + normalized: true + remove_neg: true + loss_weight: 40.0 # ★ run4(20)의 2배 — native 가파른 하락(0.3834→0.36) 잡으려 강화. 목표 기여 ~5~8%. 과제약이면 실시간곡선서 감지→하향 + it_first_update: 57500 # native peak(~63k) 직전 활성 → ramp 후 peak~하락 구간 커버 + ramp_iters: 3000 # 57.5k~60.5k ramp + ckpt: /NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/runs/om_vitg14_run5/eval/training_63250/teacher_checkpoint.pth diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitg14_testB.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitg14_testB.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2d880e02ac72ff5b9a89820609cbf3222637bde0 --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitg14_testB.yaml @@ -0,0 +1,54 @@ +# Test B (ViT-g/14) — 그들 TCGA-12K parquet + 우리 수정 파이프라인. +# 목적: ViT-L Test B가 100k에서 0.299로 0.39 미달 → 아키텍처(ViT-g) 격차인지 검증. +# OpenMidnight vitg14_reg4 레시피 그대로 + 데이터만 parquet(버퍼50000 수정 로더). +# 48 GPU × batch 8 = global 384 (= OpenMidnight 1-node와 동일 batch/LR, 클린 비교). +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + sample_list_path: "parquet:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/external/tcga12k_parquet/1/*.parquet" + streaming_from_hf: false + batch_size_per_gpu: 8 # × 48 GPU = global 384 (OpenMidnight 동일) + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-g/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + num_workers: 12 + prefetch_factor: 4 + skip_checkpointer: true +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused # ★ Meta vitg14 = swiglu + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 +optim: + epochs: 110 + early_stop: 110 + weight_decay_end: 0.2 + base_lr: 3.0e-04 + warmup_epochs: 10 + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 2500 + bach_root: "" + breakhis_root: "" + pcam_root: "" diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitl14_reg4.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitl14_reg4.yaml new file mode 100644 index 0000000000000000000000000000000000000000..67603a839fcb92905604a5b53ffeee6e8f622d86 --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitl14_reg4.yaml @@ -0,0 +1,58 @@ +# OpenPath × OpenMidnight — ViT-L/14 warm-start 검증 런. +# 목적: "Meta DINOv2 warm-start + OpenMidnight 레시피(LR/reg4/sinkhorn/KDE/HED/early-stop) +# + 우리 full-corpus 데이터"가 v2(scratch) 실패를 뒤집는지 단일 노드에서 깨끗이 격리. +# v2 대비 핵심 변경: scratch→warm-start(use_pretrained), reg 0→4, centering→sinkhorn_knopp, +# KoLeo→KDE, 1.475M완주→137.5k early-stop. base_lr는 단일노드(global 384) 기준 보수적. +# 백본: ViT-L/14 (Meta dinov2_vitl14_reg에서 warm-start → ffn_layer MUST be "mlp"). +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + # openpath: 분기 → dinov2/data/openpath_wds.py (tar shard 스트리밍, full corpus 66k WSI) + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/tiles/shards/w*/*.tar:split=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/splits/pretrain_train.txt" + streaming_from_hf: false + batch_size_per_gpu: 48 # 단일 노드 8 GPU → global 384 (= OpenMidnight 1node와 동일) + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-L/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + num_workers: 16 + prefetch_factor: 6 + skip_checkpointer: false # resume 가능하게(다중 시간 런) +student: + arch: vit_large + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: "mlp" # ★ Meta vitl14 = MLP (swiglu 아님) — warm-start 로드 일치 필수 + block_chunks: 4 + num_register_tokens: 4 # ★ Meta dinov2_vitl14_reg = 4 registers + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 +optim: + epochs: 110 # ×1250 = 137,500 step + early_stop: 110 + weight_decay_end: 0.2 + base_lr: 3.0e-04 # 보수적(warm-start). 실효 LR = 3e-4×sqrt(384/1024)≈1.84e-4 + warmup_epochs: 10 + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 2500 # teacher 체크포인트 자주 저장(step별 probe용) + # in-training eva 평가는 비활성(빈 root → graceful skip). 평가는 외부 검증 probe로 수행. + bach_root: "" + breakhis_root: "" + pcam_root: "" diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitl14_reg4_curated.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitl14_reg4_curated.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0b3589f16138216f2a4ce5361dbd4cdfe8d63dc7 --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitl14_reg4_curated.yaml @@ -0,0 +1,58 @@ +# OpenPath × OpenMidnight — ViT-L/14 warm-start 검증 런. +# 목적: "Meta DINOv2 warm-start + OpenMidnight 레시피(LR/reg4/sinkhorn/KDE/HED/early-stop) +# + 우리 full-corpus 데이터"가 v2(scratch) 실패를 뒤집는지 단일 노드에서 깨끗이 격리. +# v2 대비 핵심 변경: scratch→warm-start(use_pretrained), reg 0→4, centering→sinkhorn_knopp, +# KoLeo→KDE, 1.475M완주→137.5k early-stop. base_lr는 단일노드(global 384) 기준 보수적. +# 백본: ViT-L/14 (Meta dinov2_vitl14_reg에서 warm-start → ffn_layer MUST be "mlp"). +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + # openpath: 분기 → dinov2/data/openpath_wds.py (tar shard 스트리밍, 큐레이션: 암 41659 WSI @ 20x [GTEx 제거+mag20]) + sample_list_path: "openpath:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/tiles/shards/w*/*.tar:split=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/splits/pretrain_train_cancer.txt:mag=20" + streaming_from_hf: false + batch_size_per_gpu: 48 # 단일 노드 8 GPU → global 384 (= OpenMidnight 1node와 동일) + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-L/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + num_workers: 16 + prefetch_factor: 6 + skip_checkpointer: false # resume 가능하게(다중 시간 런) +student: + arch: vit_large + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: "mlp" # ★ Meta vitl14 = MLP (swiglu 아님) — warm-start 로드 일치 필수 + block_chunks: 4 + num_register_tokens: 4 # ★ Meta dinov2_vitl14_reg = 4 registers + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 +optim: + epochs: 110 # ×1250 = 137,500 step + early_stop: 110 + weight_decay_end: 0.2 + base_lr: 3.0e-04 # 보수적(warm-start). 실효 LR = 3e-4×sqrt(384/1024)≈1.84e-4 + warmup_epochs: 10 + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 2500 # teacher 체크포인트 자주 저장(step별 probe용) + # in-training eva 평가는 비활성(빈 root → graceful skip). 평가는 외부 검증 probe로 수행. + bach_root: "" + breakhis_root: "" + pcam_root: "" diff --git a/OpenMidnight/dinov2/configs/train/openpath_vitl14_testB.yaml b/OpenMidnight/dinov2/configs/train/openpath_vitl14_testB.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e5fd8a4f698e873b063b0de339c361d99889c7c8 --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/openpath_vitl14_testB.yaml @@ -0,0 +1,59 @@ +# OpenPath × OpenMidnight — ViT-L/14 warm-start 검증 런. +# 목적: "Meta DINOv2 warm-start + OpenMidnight 레시피(LR/reg4/sinkhorn/KDE/HED/early-stop) +# + 우리 full-corpus 데이터"가 v2(scratch) 실패를 뒤집는지 단일 노드에서 깨끗이 격리. +# v2 대비 핵심 변경: scratch→warm-start(use_pretrained), reg 0→4, centering→sinkhorn_knopp, +# KoLeo→KDE, 1.475M완주→137.5k early-stop. base_lr는 단일노드(global 384) 기준 보수적. +# 백본: ViT-L/14 (Meta dinov2_vitl14_reg에서 warm-start → ffn_layer MUST be "mlp"). +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + # openpath: 분기 → dinov2/data/openpath_wds.py (tar shard 스트리밍, full corpus 66k WSI) + sample_list_path: "parquet:glob=/NHNHOME/WORKSPACE/0526040027_A/OpenPath/data/external/tcga12k_parquet/1/*.parquet" + streaming_from_hf: false + + batch_size_per_gpu: 48 # 단일 노드 8 GPU → global 384 (= OpenMidnight 1node와 동일) + centering: sinkhorn_knopp + use_pretrained: True # ★ Meta DINOv2 ViT-L/14-reg warm-start + OFFICIAL_EPOCH_LENGTH: 1250 + num_workers: 16 + prefetch_factor: 6 + skip_checkpointer: false # resume 가능하게(다중 시간 런) +student: + arch: vit_large + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: "mlp" # ★ Meta vitl14 = MLP (swiglu 아님) — warm-start 로드 일치 필수 + block_chunks: 4 + num_register_tokens: 4 # ★ Meta dinov2_vitl14_reg = 4 registers + interpolate_antialias: true + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 +optim: + epochs: 110 # ×1250 = 137,500 step + early_stop: 110 + weight_decay_end: 0.2 + base_lr: 3.0e-04 # 보수적(warm-start). 실효 LR = 3e-4×sqrt(384/1024)≈1.84e-4 + warmup_epochs: 10 + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 2500 # teacher 체크포인트 자주 저장(step별 probe용) + # in-training eva 평가는 비활성(빈 root → graceful skip). 평가는 외부 검증 probe로 수행. + bach_root: "" + breakhis_root: "" + pcam_root: "" diff --git a/OpenMidnight/dinov2/configs/train/vitg14_reg4.yaml b/OpenMidnight/dinov2/configs/train/vitg14_reg4.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1f2e93224d4c233f0ec7adc95bb3bfab45272538 --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/vitg14_reg4.yaml @@ -0,0 +1,51 @@ +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + sample_list_path: /block/TCGA/sample_dataset_30.txt # gives paths to svs files for data loading if streaming_from_hf=False + streaming_from_hf: false # if True, dataset is streamed from HuggingFace Hub, and sample_list_path is ignored. You should lower num_workers to 4 + streaming_dataset_path: medarc/TCGA-12K-parquet + batch_size_per_gpu: 48 + centering: sinkhorn_knopp + use_pretrained: True + OFFICIAL_EPOCH_LENGTH: 1250 + num_workers: 24 # set to 4 if streaming_from_hf=True + prefetch_factor: 8 + skip_checkpointer: true # set True if you don't need to resume training (this yields training speedup and less space usage) +student: + arch: vit_giant2 + patch_size: 14 + drop_path_rate: 0.4 + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true # positional embeddings are interpolated with antialiasing + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 +optim: + epochs: 110 # epochs and early_stop for 137.5k pretraining steps + early_stop: 110 + weight_decay_end: 0.2 + base_lr: 3.0e-04 # learning rate for vit_giant2 + warmup_epochs: 10 + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 2500 # save checkpoints frequently for evaluation + bach_root: /block/eva-data/bach + breakhis_root: /block/eva-data/breakhis + pcam_root: /block/eva-data/patch_camelyon diff --git a/OpenMidnight/dinov2/configs/train/vits14_reg4.yaml b/OpenMidnight/dinov2/configs/train/vits14_reg4.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fdbd2da5a2d68caa804abf4b88a3af99301b8505 --- /dev/null +++ b/OpenMidnight/dinov2/configs/train/vits14_reg4.yaml @@ -0,0 +1,51 @@ +dino: + head_n_prototypes: 131072 + head_bottleneck_dim: 384 + do_kde: True + kde_loss_weight: .05 + koleo_loss_weight: 0 + do_koleo: False +ibot: + loss_weight: 1.0 + mask_sample_probability: 0.5 + mask_ratio_min_max: + - 0.1 + - 0.45 + separate_head: true + head_n_prototypes: 131072 +train: + sample_list_path: /block/TCGA/sample_dataset_30.txt # gives paths to svs files for data loading if streaming_from_hf=False + streaming_from_hf: false # if True, dataset is streamed from HuggingFace Hub, and sample_list_path is ignored. You should lower num_workers to 4 + streaming_dataset_path: medarc/TCGA-12K-parquet + batch_size_per_gpu: 48 + centering: sinkhorn_knopp + use_pretrained: True + OFFICIAL_EPOCH_LENGTH: 1250 + num_workers: 24 # set to 4 if streaming_from_hf=True + prefetch_factor: 8 + skip_checkpointer: true # set True if you don't need to resume training (this yields training speedup and less space usage) +student: + arch: vit_small + patch_size: 14 + drop_path_rate: 0.1 # drop path rate for vit_small + ffn_layer: swiglufused + block_chunks: 4 + num_register_tokens: 4 + interpolate_antialias: true # positional embeddings are interpolated with antialiasing + interpolate_offset: 0.0 +teacher: + momentum_teacher: 0.994 +optim: + epochs: 110 # epochs and early_stop for 137.5k pretraining steps + early_stop: 110 + weight_decay_end: 0.2 + base_lr: 7.0e-04 # learning rate for vit_small + warmup_epochs: 10 + layerwise_decay: 1.0 +crops: + local_crops_size: 98 +evaluation: + eval_period_iterations: 2500 # save checkpoints frequently for evaluation + bach_root: /block/eva-data/bach + breakhis_root: /block/eva-data/breakhis + pcam_root: /block/eva-data/patch_camelyon \ No newline at end of file diff --git a/OpenMidnight/dinov2/data/__init__.py b/OpenMidnight/dinov2/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2ded47ea63a7b184ff74a040e2c2c514cda273ef --- /dev/null +++ b/OpenMidnight/dinov2/data/__init__.py @@ -0,0 +1,10 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .adapters import DatasetWithEnumeratedTargets +from .loaders import make_data_loader, make_dataset, SamplerType +from .collate import collate_data_and_cast +from .masking import MaskingGenerator +from .augmentations import DataAugmentationDINO diff --git a/OpenMidnight/dinov2/data/adapters.py b/OpenMidnight/dinov2/data/adapters.py new file mode 100644 index 0000000000000000000000000000000000000000..2097bad046fb1052267d5f2bb99c798045f00c92 --- /dev/null +++ b/OpenMidnight/dinov2/data/adapters.py @@ -0,0 +1,28 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from typing import Any, Tuple + +from torch.utils.data import Dataset + + +class DatasetWithEnumeratedTargets(Dataset): + def __init__(self, dataset): + self._dataset = dataset + + def get_image_data(self, index: int) -> bytes: + return self._dataset.get_image_data(index) + + def get_target(self, index: int) -> Tuple[Any, int]: + target = self._dataset.get_target(index) + return (index, target) + + def __getitem__(self, index: int) -> Tuple[Any, Tuple[Any, int]]: + image, target = self._dataset[index] + target = index if target is None else target + return image, (index, target) + + def __len__(self) -> int: + return len(self._dataset) diff --git a/OpenMidnight/dinov2/data/augmentations.py b/OpenMidnight/dinov2/data/augmentations.py new file mode 100644 index 0000000000000000000000000000000000000000..b57e68083a2245cdf141bda4c9dba54361601f17 --- /dev/null +++ b/OpenMidnight/dinov2/data/augmentations.py @@ -0,0 +1,383 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +import cv2 +import numpy as np +import random +import torch +import torchvision +from torchvision import transforms +from skimage import color as skimage_color +from skimage.color import rgb2hed, hed2rgb +from einops import rearrange +from PIL import Image + +from .transforms import ( + GaussianBlur, + make_normalize_transform, +) + +logger = logging.getLogger("dinov2") + + +class RandStainNA(torch.nn.Module): + """ + RandStainNA: Random Stain Normalization and Augmentation. + Bridges stain normalization and augmentation by constraining variable stain styles + in a practicable range using virtual template generation. + + Based on: "RandStainNA: Learning Stain-Agnostic Features from Histology Slides + by Bridging Stain Augmentation and Normalization" (MICCAI 2022) + + Reference: https://github.com/yiqings/RandStainNA + """ + + # Default statistics for LAB color space from CRC dataset + # These can be overridden by providing a yaml_file + DEFAULT_LAB_STATS = { + 'L': {'avg': {'mean': 158.033, 'std': 48.792}, 'std': {'mean': 36.899, 'std': 14.383}}, + 'A': {'avg': {'mean': 151.187, 'std': 10.958}, 'std': {'mean': 8.134, 'std': 2.822}}, + 'B': {'avg': {'mean': 116.812, 'std': 6.643}, 'std': {'mean': 6.129, 'std': 2.013}}, + } + + # Default statistics for HED color space + DEFAULT_HED_STATS = { + 'H': {'avg': {'mean': 0.05, 'std': 0.02}, 'std': {'mean': 0.03, 'std': 0.01}}, + 'E': {'avg': {'mean': 0.02, 'std': 0.01}, 'std': {'mean': 0.02, 'std': 0.008}}, + 'D': {'avg': {'mean': 0.0, 'std': 0.005}, 'std': {'mean': 0.01, 'std': 0.005}}, + } + + def __init__( + self, + color_space='LAB', + std_hyper=-0.3, + distribution='normal', + probability=1.0, + ): + super().__init__() + + assert distribution in ['normal', 'laplace', 'uniform'], \ + f"Unsupported distribution: {distribution}" + assert color_space in ['LAB', 'HSV', 'HED'], \ + f"Unsupported color space: {color_space}" + + self.color_space = color_space + self.std_hyper = std_hyper + self.distribution = distribution + self.probability = probability + + if color_space == 'LAB': + stats = self.DEFAULT_LAB_STATS + self.channels = ['L', 'A', 'B'] + elif color_space == 'HED': + stats = self.DEFAULT_HED_STATS + self.channels = ['H', 'E', 'D'] + else: + stats = self.DEFAULT_LAB_STATS + self.channels = ['H', 'S', 'V'] + + self.channel_avgs_mean = [stats[c]['avg']['mean'] for c in self.channels] + self.channel_avgs_std = [stats[c]['avg']['std'] for c in self.channels] + self.channel_stds_mean = [stats[c]['std']['mean'] for c in self.channels] + self.channel_stds_std = [stats[c]['std']['std'] for c in self.channels] + + def _getavgstd(self, image): + """Get mean and std for each channel.""" + avgs = [] + stds = [] + for idx in range(image.shape[2]): + avgs.append(np.mean(image[:, :, idx])) + stds.append(np.std(image[:, :, idx])) + return np.array(avgs), np.array(stds) + + def _normalize(self, img, img_avgs, img_stds, tar_avgs, tar_stds): + """Normalize image to target statistics.""" + img_stds = np.clip(img_stds, 0.0001, 255) + img = (img - img_avgs) * (tar_stds / img_stds) + tar_avgs + + if self.color_space in ['LAB', 'HSV']: + img = np.clip(img, 0, 255).astype(np.uint8) + + return img + + def _generate_virtual_template(self): + """Generate virtual template statistics based on distribution.""" + tar_avgs = [] + tar_stds = [] + + if self.distribution == 'uniform': + for idx in range(3): + tar_avg = np.random.uniform( + low=self.channel_avgs_mean[idx] - 3 * self.channel_avgs_std[idx], + high=self.channel_avgs_mean[idx] + 3 * self.channel_avgs_std[idx], + ) + tar_std = np.random.uniform( + low=self.channel_stds_mean[idx] - 3 * self.channel_stds_std[idx], + high=self.channel_stds_mean[idx] + 3 * self.channel_stds_std[idx], + ) + tar_avgs.append(tar_avg) + tar_stds.append(tar_std) + else: + if self.distribution == 'normal': + np_distribution = np.random.normal + else: + np_distribution = np.random.laplace + + for idx in range(3): + tar_avg = np_distribution( + loc=self.channel_avgs_mean[idx], + scale=self.channel_avgs_std[idx] * (1 + self.std_hyper), + ) + tar_std = np_distribution( + loc=self.channel_stds_mean[idx], + scale=self.channel_stds_std[idx] * (1 + self.std_hyper), + ) + tar_avgs.append(tar_avg) + tar_stds.append(tar_std) + + return np.array(tar_avgs), np.array(tar_stds) + + def augment(self, img): + """Apply stain augmentation.""" + if isinstance(img, Image.Image): + image = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR) + was_pil = True + else: + image = img + was_pil = False + + # Color space conversion + if self.color_space == 'LAB': + image = cv2.cvtColor(image, cv2.COLOR_BGR2LAB) + elif self.color_space == 'HSV': + image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) + elif self.color_space == 'HED': + image = skimage_color.rgb2hed(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) + + # Generate virtual template and normalize + tar_avgs, tar_stds = self._generate_virtual_template() + img_avgs, img_stds = self._getavgstd(image) + + image = self._normalize( + img=image, + img_avgs=img_avgs, + img_stds=img_stds, + tar_avgs=tar_avgs, + tar_stds=tar_stds, + ) + + # Convert back to BGR/RGB + if self.color_space == 'LAB': + image = cv2.cvtColor(image, cv2.COLOR_LAB2BGR) + elif self.color_space == 'HSV': + image = cv2.cvtColor(image, cv2.COLOR_HSV2BGR) + elif self.color_space == 'HED': + nimg = skimage_color.hed2rgb(image) + imin = nimg.min() + imax = nimg.max() + rsimg = (255 * (nimg - imin) / (imax - imin + 1e-8)).astype('uint8') + image = cv2.cvtColor(rsimg, cv2.COLOR_RGB2BGR) + + # Convert back to RGB for PIL + image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) + + if was_pil: + return Image.fromarray(image) + return image + + def forward(self, img): + if random.random() > self.probability: + return img + return self.augment(img) + + +class hed_mod(torch.nn.Module): + """ + HED color space augmentation for H&E stained histopathology images. + Randomly perturbs Hematoxylin, Eosin, and DAB channels. + """ + + def __init__(self, probability=0.5, perturbation_range=0.05): + super().__init__() + self.probability = probability + self.mini = -perturbation_range + self.maxi = perturbation_range + + def forward(self, img, label=None): + if random.random() > self.probability: + return img + + if img is not None: + img = torchvision.transforms.functional.pil_to_tensor(img) + img = rearrange(img, 'c h w -> h w c') + hed_image = rgb2hed(img) + + hed_image[..., 0] += random.uniform(self.mini, self.maxi) # H + hed_image[..., 1] += random.uniform(self.mini, self.maxi) # E + hed_image[..., 2] += random.uniform(self.mini, self.maxi) # D + + hed_image = np.clip(hed_image, 0, 1) + img = hed2rgb(hed_image) + + img = rearrange(img, 'h w c -> c h w') + img = torch.from_numpy(img) + img = torchvision.transforms.functional.to_pil_image(img) + + if label is not None: + label = rearrange(label, 'c h w -> h w c') + hed_image = rgb2hed(label) + hed_image[..., 0] += random.uniform(self.mini, self.maxi) + hed_image[..., 1] += random.uniform(self.mini, self.maxi) + hed_image[..., 2] += random.uniform(self.mini, self.maxi) + label = rearrange(label, 'h w c -> c h w') + label = torch.from_numpy(label) + return img, label + + return img + + +class RandomRotation90(torch.nn.Module): + """ + Random 90-degree rotation augmentation for histopathology images. + Pathology images are rotation-invariant, so we can apply 0, 90, 180, or 270 degree rotations. + """ + + def __init__(self): + super().__init__() + self.angles = [0, 90, 180, 270] + + def forward(self, img): + angle = random.choice(self.angles) + if angle == 0: + return img + return transforms.functional.rotate(img, angle) + + +class DataAugmentationDINO(object): + """ + Data augmentation pipeline for DINOv2 training on histopathology images. + + Includes pathology-specific augmentations: + - RandStainNA: Stain normalization/augmentation in LAB color space + - HED augmentation: Color space perturbation + - 90-degree rotations: Rotation invariance + - Vertical and horizontal flips + - Gaussian blur + - Color jitter (no grayscale for H&E images) + """ + + def __init__( + self, + global_crops_scale, + local_crops_scale, + local_crops_number, + global_crops_size=224, + local_crops_size=96, + ): + self.global_crops_scale = global_crops_scale + self.local_crops_scale = local_crops_scale + self.local_crops_number = local_crops_number + self.global_crops_size = global_crops_size + self.local_crops_size = local_crops_size + + logger.info("###################################") + logger.info("Using data augmentation parameters:") + logger.info(f"global_crops_scale: {global_crops_scale}") + logger.info(f"local_crops_scale: {local_crops_scale}") + logger.info(f"local_crops_number: {local_crops_number}") + logger.info(f"global_crops_size: {global_crops_size}") + logger.info(f"local_crops_size: {local_crops_size}") + logger.info("###################################") + + # Geometric augmentations with rotation and both flips + self.geometric_augmentation_global = transforms.Compose( + [ + # RandomRotation90(), + transforms.RandomResizedCrop( + global_crops_size, scale=global_crops_scale, interpolation=transforms.InterpolationMode.BICUBIC + ), + transforms.RandomHorizontalFlip(p=0.5), + # transforms.RandomVerticalFlip(p=0.5), + ] + ) + + self.geometric_augmentation_local = transforms.Compose( + [ + # RandomRotation90(), + transforms.RandomResizedCrop( + local_crops_size, scale=local_crops_scale, interpolation=transforms.InterpolationMode.BICUBIC + ), + transforms.RandomHorizontalFlip(p=0.5), + # transforms.RandomVerticalFlip(p=0.5), + ] + ) + + # Normalization (ImageNet stats used by default) + self.normalize = transforms.Compose( + [ + transforms.ToTensor(), + make_normalize_transform(), + ] + ) + + # Pathology-specific stain augmentations + randstainna = RandStainNA( + color_space='LAB', + std_hyper=-0.3, + distribution='normal', + probability=0.5, + ) + + hed_aug = hed_mod(probability=0.5, perturbation_range=0.05) + + self.global_transfo1 = transforms.Compose([ + # randstainna, + hed_aug, + transforms.RandomApply([transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.1, hue=0.05)], p=0.8), + transforms.RandomGrayscale(p=0.2), + GaussianBlur(p=1.0), + self.normalize + ]) + + self.global_transfo2 = transforms.Compose([ + # randstainna, + hed_aug, + transforms.RandomApply([transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.1, hue=0.05)], p=0.8), + transforms.RandomGrayscale(p=0.2), + GaussianBlur(p=0.1), + self.normalize + ]) + + self.local_transfo = transforms.Compose([ + # randstainna, + hed_aug, + transforms.RandomApply([transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.1, hue=0.05)], p=0.8), + transforms.RandomGrayscale(p=0.2), + GaussianBlur(p=0.5), + self.normalize + ]) + + def __call__(self, image): + output = {} + + # Global crops + im1_base = self.geometric_augmentation_global(image) + global_crop_1 = self.global_transfo1(im1_base) + + im2_base = self.geometric_augmentation_global(image) + global_crop_2 = self.global_transfo2(im2_base) + + output["global_crops"] = [global_crop_1, global_crop_2] + output["global_crops_teacher"] = [global_crop_1, global_crop_2] + + # Local crops + local_crops = [ + self.local_transfo(self.geometric_augmentation_local(image)) for _ in range(self.local_crops_number) + ] + output["local_crops"] = local_crops + output["offsets"] = () + + return output diff --git a/OpenMidnight/dinov2/data/collate.py b/OpenMidnight/dinov2/data/collate.py new file mode 100644 index 0000000000000000000000000000000000000000..fbe6864ef108c1d3790a35da653f99c57b9abd9d --- /dev/null +++ b/OpenMidnight/dinov2/data/collate.py @@ -0,0 +1,62 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import random + + +def collate_data_and_cast(samples_list, mask_ratio_tuple, mask_probability, dtype, n_tokens=None, mask_generator=None): + # dtype = torch.half # TODO: Remove + + #So this is our batch basically, just in a list. + + #print(samples_list[-1][-1]) + + images = [] + indexes = [] + for sample in samples_list: + images.append(sample[0]) + indexes.append(sample[1]) + + samples_list = images + + n_global_crops = len(samples_list[0][0]["global_crops"]) + n_local_crops = len(samples_list[0][0]["local_crops"]) + + collated_global_crops = torch.stack([s[0]["global_crops"][i] for i in range(n_global_crops) for s in samples_list]) + + collated_local_crops = torch.stack([s[0]["local_crops"][i] for i in range(n_local_crops) for s in samples_list]) + + B = len(collated_global_crops) + N = n_tokens + n_samples_masked = int(B * mask_probability) + probs = torch.linspace(*mask_ratio_tuple, n_samples_masked + 1) + upperbound = 0 + masks_list = [] + for i in range(0, n_samples_masked): + prob_min = probs[i] + prob_max = probs[i + 1] + masks_list.append(torch.BoolTensor(mask_generator(int(N * random.uniform(prob_min, prob_max))))) + upperbound += int(N * prob_max) + for i in range(n_samples_masked, B): + masks_list.append(torch.BoolTensor(mask_generator(0))) + + random.shuffle(masks_list) + + collated_masks = torch.stack(masks_list).flatten(1) + mask_indices_list = collated_masks.flatten().nonzero().flatten() + + masks_weight = (1 / collated_masks.sum(-1).clamp(min=1.0)).unsqueeze(-1).expand_as(collated_masks)[collated_masks] + + return { + "collated_global_crops": collated_global_crops.to(dtype), + "collated_local_crops": collated_local_crops.to(dtype), + "collated_masks": collated_masks, + "mask_indices_list": mask_indices_list, + "masks_weight": masks_weight, + "upperbound": upperbound, + "n_masked_patches": torch.full((1,), fill_value=mask_indices_list.shape[0], dtype=torch.long), + "indexes": indexes + } diff --git a/OpenMidnight/dinov2/data/datasets/__init__.py b/OpenMidnight/dinov2/data/datasets/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d51468e542905f8c2a8258861fc66f0d23081b10 --- /dev/null +++ b/OpenMidnight/dinov2/data/datasets/__init__.py @@ -0,0 +1,9 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .image_net import ImageNet +from .image_net_22k import ImageNet22k +from .test_data import TestVisionDataset +from .slide_dataset import SlideDataset diff --git a/OpenMidnight/dinov2/data/datasets/decoders.py b/OpenMidnight/dinov2/data/datasets/decoders.py new file mode 100644 index 0000000000000000000000000000000000000000..3769f7750d94f7e0f7bce281ef3ff186970fc9cd --- /dev/null +++ b/OpenMidnight/dinov2/data/datasets/decoders.py @@ -0,0 +1,31 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from io import BytesIO +from typing import Any + +from PIL import Image + + +class Decoder: + def decode(self) -> Any: + raise NotImplementedError + + +class ImageDataDecoder(Decoder): + def __init__(self, image_data: bytes) -> None: + self._image_data = image_data + + def decode(self) -> Image: + f = BytesIO(self._image_data) + return Image.open(f).convert(mode="RGB") + + +class TargetDecoder(Decoder): + def __init__(self, target: Any): + self._target = target + + def decode(self) -> Any: + return self._target diff --git a/OpenMidnight/dinov2/data/datasets/extended.py b/OpenMidnight/dinov2/data/datasets/extended.py new file mode 100644 index 0000000000000000000000000000000000000000..f60b619a3c797823cccfc89e262cdb230f9188f0 --- /dev/null +++ b/OpenMidnight/dinov2/data/datasets/extended.py @@ -0,0 +1,38 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from typing import Any, Tuple + +from torchvision.datasets import VisionDataset + +from .decoders import TargetDecoder, ImageDataDecoder + + +class ExtendedVisionDataset(VisionDataset): + def __init__(self, *args, **kwargs) -> None: + super().__init__(*args, **kwargs) # type: ignore + + def get_image_data(self, index: int) -> bytes: + raise NotImplementedError + + def get_target(self, index: int) -> Any: + raise NotImplementedError + + def __getitem__(self, index: int) -> Tuple[Any, Any]: + try: + image_data = self.get_image_data(index) + image = ImageDataDecoder(image_data).decode() + except Exception as e: + raise RuntimeError(f"can not read image for sample {index}") from e + target = self.get_target(index) + target = TargetDecoder(target).decode() + + if self.transforms is not None: + image, target = self.transforms(image, target) + + return image, target + + def __len__(self) -> int: + raise NotImplementedError diff --git a/OpenMidnight/dinov2/data/datasets/image_net.py b/OpenMidnight/dinov2/data/datasets/image_net.py new file mode 100644 index 0000000000000000000000000000000000000000..8d08446147986c58360163e468896e994197c657 --- /dev/null +++ b/OpenMidnight/dinov2/data/datasets/image_net.py @@ -0,0 +1,290 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import csv +from enum import Enum +import logging +import os +from typing import Callable, List, Optional, Tuple, Union + +import numpy as np + +from .extended import ExtendedVisionDataset + + +logger = logging.getLogger("dinov2") +_Target = int + + +class _Split(Enum): + TRAIN = "train" + VAL = "val" + TEST = "test" # NOTE: torchvision does not support the test split + + @property + def length(self) -> int: + split_lengths = { + _Split.TRAIN: 1_281_167, + _Split.VAL: 50_000, + _Split.TEST: 100_000, + } + return split_lengths[self] + + def get_dirname(self, class_id: Optional[str] = None) -> str: + return self.value if class_id is None else os.path.join(self.value, class_id) + + def get_image_relpath(self, actual_index: int, class_id: Optional[str] = None) -> str: + dirname = self.get_dirname(class_id) + if self == _Split.TRAIN: + basename = f"{class_id}_{actual_index}" + else: # self in (_Split.VAL, _Split.TEST): + basename = f"ILSVRC2012_{self.value}_{actual_index:08d}" + return os.path.join(dirname, basename + ".JPEG") + + def parse_image_relpath(self, image_relpath: str) -> Tuple[str, int]: + assert self != _Split.TEST + dirname, filename = os.path.split(image_relpath) + class_id = os.path.split(dirname)[-1] + basename, _ = os.path.splitext(filename) + actual_index = int(basename.split("_")[-1]) + return class_id, actual_index + + +class ImageNet(ExtendedVisionDataset): + Target = Union[_Target] + Split = Union[_Split] + + def __init__( + self, + *, + split: "ImageNet.Split", + root: str, + extra: str, + transforms: Optional[Callable] = None, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + ) -> None: + super().__init__(root, transforms, transform, target_transform) + self._extra_root = extra + self._split = split + + self._entries = None + self._class_ids = None + self._class_names = None + + @property + def split(self) -> "ImageNet.Split": + return self._split + + def _get_extra_full_path(self, extra_path: str) -> str: + return os.path.join(self._extra_root, extra_path) + + def _load_extra(self, extra_path: str) -> np.ndarray: + extra_full_path = self._get_extra_full_path(extra_path) + return np.load(extra_full_path, mmap_mode="r") + + def _save_extra(self, extra_array: np.ndarray, extra_path: str) -> None: + extra_full_path = self._get_extra_full_path(extra_path) + os.makedirs(self._extra_root, exist_ok=True) + np.save(extra_full_path, extra_array) + + @property + def _entries_path(self) -> str: + return f"entries-{self._split.value.upper()}.npy" + + @property + def _class_ids_path(self) -> str: + return f"class-ids-{self._split.value.upper()}.npy" + + @property + def _class_names_path(self) -> str: + return f"class-names-{self._split.value.upper()}.npy" + + def _get_entries(self) -> np.ndarray: + if self._entries is None: + self._entries = self._load_extra(self._entries_path) + assert self._entries is not None + return self._entries + + def _get_class_ids(self) -> np.ndarray: + if self._split == _Split.TEST: + assert False, "Class IDs are not available in TEST split" + if self._class_ids is None: + self._class_ids = self._load_extra(self._class_ids_path) + assert self._class_ids is not None + return self._class_ids + + def _get_class_names(self) -> np.ndarray: + if self._split == _Split.TEST: + assert False, "Class names are not available in TEST split" + if self._class_names is None: + self._class_names = self._load_extra(self._class_names_path) + assert self._class_names is not None + return self._class_names + + def find_class_id(self, class_index: int) -> str: + class_ids = self._get_class_ids() + return str(class_ids[class_index]) + + def find_class_name(self, class_index: int) -> str: + class_names = self._get_class_names() + return str(class_names[class_index]) + + def get_image_data(self, index: int) -> bytes: + entries = self._get_entries() + actual_index = entries[index]["actual_index"] + + class_id = self.get_class_id(index) + + image_relpath = self.split.get_image_relpath(actual_index, class_id) + image_full_path = os.path.join(self.root, image_relpath) + with open(image_full_path, mode="rb") as f: + image_data = f.read() + return image_data + + def get_target(self, index: int) -> Optional[Target]: + entries = self._get_entries() + class_index = entries[index]["class_index"] + return None if self.split == _Split.TEST else int(class_index) + + def get_targets(self) -> Optional[np.ndarray]: + entries = self._get_entries() + return None if self.split == _Split.TEST else entries["class_index"] + + def get_class_id(self, index: int) -> Optional[str]: + entries = self._get_entries() + class_id = entries[index]["class_id"] + return None if self.split == _Split.TEST else str(class_id) + + def get_class_name(self, index: int) -> Optional[str]: + entries = self._get_entries() + class_name = entries[index]["class_name"] + return None if self.split == _Split.TEST else str(class_name) + + def __len__(self) -> int: + entries = self._get_entries() + assert len(entries) == self.split.length + return len(entries) + + def _load_labels(self, labels_path: str) -> List[Tuple[str, str]]: + labels_full_path = os.path.join(self.root, labels_path) + labels = [] + + try: + with open(labels_full_path, "r") as f: + reader = csv.reader(f) + for row in reader: + class_id, class_name = row + labels.append((class_id, class_name)) + except OSError as e: + raise RuntimeError(f'can not read labels file "{labels_full_path}"') from e + + return labels + + def _dump_entries(self) -> None: + split = self.split + if split == ImageNet.Split.TEST: + dataset = None + sample_count = split.length + max_class_id_length, max_class_name_length = 0, 0 + else: + labels_path = "labels.txt" + logger.info(f'loading labels from "{labels_path}"') + labels = self._load_labels(labels_path) + + # NOTE: Using torchvision ImageFolder for consistency + from torchvision.datasets import ImageFolder + + dataset_root = os.path.join(self.root, split.get_dirname()) + dataset = ImageFolder(dataset_root) + sample_count = len(dataset) + max_class_id_length, max_class_name_length = -1, -1 + for sample in dataset.samples: + _, class_index = sample + class_id, class_name = labels[class_index] + max_class_id_length = max(len(class_id), max_class_id_length) + max_class_name_length = max(len(class_name), max_class_name_length) + + dtype = np.dtype( + [ + ("actual_index", " old_percent: + logger.info(f"creating entries: {percent}%") + old_percent = percent + + actual_index = index + 1 + class_index = np.uint32(-1) + class_id, class_name = "", "" + entries_array[index] = (actual_index, class_index, class_id, class_name) + else: + class_names = {class_id: class_name for class_id, class_name in labels} + + assert dataset + old_percent = -1 + for index in range(sample_count): + percent = 100 * (index + 1) // sample_count + if percent > old_percent: + logger.info(f"creating entries: {percent}%") + old_percent = percent + + image_full_path, class_index = dataset.samples[index] + image_relpath = os.path.relpath(image_full_path, self.root) + class_id, actual_index = split.parse_image_relpath(image_relpath) + class_name = class_names[class_id] + entries_array[index] = (actual_index, class_index, class_id, class_name) + + logger.info(f'saving entries to "{self._entries_path}"') + self._save_extra(entries_array, self._entries_path) + + def _dump_class_ids_and_names(self) -> None: + split = self.split + if split == ImageNet.Split.TEST: + return + + entries_array = self._load_extra(self._entries_path) + + max_class_id_length, max_class_name_length, max_class_index = -1, -1, -1 + for entry in entries_array: + class_index, class_id, class_name = ( + entry["class_index"], + entry["class_id"], + entry["class_name"], + ) + max_class_index = max(int(class_index), max_class_index) + max_class_id_length = max(len(str(class_id)), max_class_id_length) + max_class_name_length = max(len(str(class_name)), max_class_name_length) + + class_count = max_class_index + 1 + class_ids_array = np.empty(class_count, dtype=f"U{max_class_id_length}") + class_names_array = np.empty(class_count, dtype=f"U{max_class_name_length}") + for entry in entries_array: + class_index, class_id, class_name = ( + entry["class_index"], + entry["class_id"], + entry["class_name"], + ) + class_ids_array[class_index] = class_id + class_names_array[class_index] = class_name + + logger.info(f'saving class IDs to "{self._class_ids_path}"') + self._save_extra(class_ids_array, self._class_ids_path) + + logger.info(f'saving class names to "{self._class_names_path}"') + self._save_extra(class_names_array, self._class_names_path) + + def dump_extra(self) -> None: + self._dump_entries() + self._dump_class_ids_and_names() diff --git a/OpenMidnight/dinov2/data/datasets/image_net_22k.py b/OpenMidnight/dinov2/data/datasets/image_net_22k.py new file mode 100644 index 0000000000000000000000000000000000000000..52b36a2c664a7b72e30173b03b4e2aef1cd2fcd9 --- /dev/null +++ b/OpenMidnight/dinov2/data/datasets/image_net_22k.py @@ -0,0 +1,302 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass +from enum import Enum +from functools import lru_cache +from gzip import GzipFile +from io import BytesIO +from mmap import ACCESS_READ, mmap +import os +from typing import Any, Callable, List, Optional, Set, Tuple +import warnings + +import numpy as np + +from .extended import ExtendedVisionDataset + + +_Labels = int + +_DEFAULT_MMAP_CACHE_SIZE = 16 # Warning: This can exhaust file descriptors + + +@dataclass +class _ClassEntry: + block_offset: int + maybe_filename: Optional[str] = None + + +@dataclass +class _Entry: + class_index: int # noqa: E701 + start_offset: int + end_offset: int + filename: str + + +class _Split(Enum): + TRAIN = "train" + VAL = "val" + + @property + def length(self) -> int: + return { + _Split.TRAIN: 11_797_647, + _Split.VAL: 561_050, + }[self] + + def entries_path(self): + return f"imagenet21kp_{self.value}.txt" + + +def _get_tarball_path(class_id: str) -> str: + return f"{class_id}.tar" + + +def _make_mmap_tarball(tarballs_root: str, mmap_cache_size: int): + @lru_cache(maxsize=mmap_cache_size) + def _mmap_tarball(class_id: str) -> mmap: + tarball_path = _get_tarball_path(class_id) + tarball_full_path = os.path.join(tarballs_root, tarball_path) + with open(tarball_full_path) as f: + return mmap(fileno=f.fileno(), length=0, access=ACCESS_READ) + + return _mmap_tarball + + +class ImageNet22k(ExtendedVisionDataset): + _GZIPPED_INDICES: Set[int] = { + 841_545, + 1_304_131, + 2_437_921, + 2_672_079, + 2_795_676, + 2_969_786, + 6_902_965, + 6_903_550, + 6_903_628, + 7_432_557, + 7_432_589, + 7_813_809, + 8_329_633, + 10_296_990, + 10_417_652, + 10_492_265, + 10_598_078, + 10_782_398, + 10_902_612, + 11_203_736, + 11_342_890, + 11_397_596, + 11_589_762, + 11_705_103, + 12_936_875, + 13_289_782, + } + Labels = _Labels + + def __init__( + self, + *, + root: str, + extra: str, + transforms: Optional[Callable] = None, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + mmap_cache_size: int = _DEFAULT_MMAP_CACHE_SIZE, + ) -> None: + super().__init__(root, transforms, transform, target_transform) + self._extra_root = extra + + entries_path = self._get_entries_path(root) + self._entries = self._load_extra(entries_path) + + class_ids_path = self._get_class_ids_path(root) + self._class_ids = self._load_extra(class_ids_path) + + self._gzipped_indices = ImageNet22k._GZIPPED_INDICES + self._mmap_tarball = _make_mmap_tarball(self._tarballs_root, mmap_cache_size) + + def _get_entries_path(self, root: Optional[str] = None) -> str: + return "entries.npy" + + def _get_class_ids_path(self, root: Optional[str] = None) -> str: + return "class-ids.npy" + + def _find_class_ids(self, path: str) -> List[str]: + class_ids = [] + + with os.scandir(path) as entries: + for entry in entries: + root, ext = os.path.splitext(entry.name) + if ext != ".tar": + continue + class_ids.append(root) + + return sorted(class_ids) + + def _load_entries_class_ids(self, root: Optional[str] = None) -> Tuple[List[_Entry], List[str]]: + root = self.get_root(root) + entries: List[_Entry] = [] + class_ids = self._find_class_ids(root) + + for class_index, class_id in enumerate(class_ids): + path = os.path.join(root, "blocks", f"{class_id}.log") + class_entries = [] + + try: + with open(path) as f: + for line in f: + line = line.rstrip() + block, filename = line.split(":") + block_offset = int(block[6:]) + filename = filename[1:] + + maybe_filename = None + if filename != "** Block of NULs **": + maybe_filename = filename + _, ext = os.path.splitext(filename) + # assert ext == ".JPEG" + + class_entry = _ClassEntry(block_offset, maybe_filename) + class_entries.append(class_entry) + except OSError as e: + raise RuntimeError(f'can not read blocks file "{path}"') from e + + assert class_entries[-1].maybe_filename is None + + for class_entry1, class_entry2 in zip(class_entries, class_entries[1:]): + assert class_entry1.block_offset <= class_entry2.block_offset + start_offset = 512 * class_entry1.block_offset + end_offset = 512 * class_entry2.block_offset + assert class_entry1.maybe_filename is not None + filename = class_entry1.maybe_filename + entry = _Entry(class_index, start_offset, end_offset, filename) + # Skip invalid image files (PIL throws UnidentifiedImageError) + if filename == "n06470073_47249.JPEG": + continue + entries.append(entry) + + return entries, class_ids + + def _load_extra(self, extra_path: str) -> np.ndarray: + extra_root = self._extra_root + extra_full_path = os.path.join(extra_root, extra_path) + return np.load(extra_full_path, mmap_mode="r") + + def _save_extra(self, extra_array: np.ndarray, extra_path: str) -> None: + extra_root = self._extra_root + extra_full_path = os.path.join(extra_root, extra_path) + os.makedirs(extra_root, exist_ok=True) + np.save(extra_full_path, extra_array) + + @property + def _tarballs_root(self) -> str: + return self.root + + def find_class_id(self, class_index: int) -> str: + return str(self._class_ids[class_index]) + + def get_image_data(self, index: int) -> bytes: + entry = self._entries[index] + class_id = entry["class_id"] + class_mmap = self._mmap_tarball(class_id) + + start_offset, end_offset = entry["start_offset"], entry["end_offset"] + try: + mapped_data = class_mmap[start_offset:end_offset] + data = mapped_data[512:] # Skip entry header block + + if len(data) >= 2 and tuple(data[:2]) == (0x1F, 0x8B): + assert index in self._gzipped_indices, f"unexpected gzip header for sample {index}" + with GzipFile(fileobj=BytesIO(data)) as g: + data = g.read() + except Exception as e: + raise RuntimeError(f"can not retrieve image data for sample {index} " f'from "{class_id}" tarball') from e + + return data + + def get_target(self, index: int) -> Any: + return int(self._entries[index]["class_index"]) + + def get_targets(self) -> np.ndarray: + return self._entries["class_index"] + + def get_class_id(self, index: int) -> str: + return str(self._entries[index]["class_id"]) + + def get_class_ids(self) -> np.ndarray: + return self._entries["class_id"] + + def __getitem__(self, index: int) -> Tuple[Any, Any]: + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + return super().__getitem__(index) + + def __len__(self) -> int: + return len(self._entries) + + def _dump_entries(self, *args, **kwargs) -> None: + entries, class_ids = self._load_entries_class_ids(*args, **kwargs) + + max_class_id_length, max_filename_length, max_class_index = -1, -1, -1 + for entry in entries: + class_id = class_ids[entry.class_index] + max_class_index = max(entry.class_index, max_class_index) + max_class_id_length = max(len(class_id), max_class_id_length) + max_filename_length = max(len(entry.filename), max_filename_length) + + dtype = np.dtype( + [ + ("class_index", " None: + entries_path = self._get_entries_path(*args, **kwargs) + entries_array = self._load_extra(entries_path) + + max_class_id_length, max_class_index = -1, -1 + for entry in entries_array: + class_index, class_id = entry["class_index"], entry["class_id"] + max_class_index = max(int(class_index), max_class_index) + max_class_id_length = max(len(str(class_id)), max_class_id_length) + + class_ids_array = np.empty(max_class_index + 1, dtype=f"U{max_class_id_length}") + for entry in entries_array: + class_index, class_id = entry["class_index"], entry["class_id"] + class_ids_array[class_index] = class_id + class_ids_path = self._get_class_ids_path(*args, **kwargs) + self._save_extra(class_ids_array, class_ids_path) + + def _dump_extra(self, *args, **kwargs) -> None: + self._dump_entries(*args, *kwargs) + self._dump_class_ids(*args, *kwargs) + + def dump_extra(self, root: Optional[str] = None) -> None: + return self._dump_extra(root) diff --git a/OpenMidnight/dinov2/data/datasets/slide_dataset.py b/OpenMidnight/dinov2/data/datasets/slide_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..935527d73981909d03663c6fa8f789feacbe9032 --- /dev/null +++ b/OpenMidnight/dinov2/data/datasets/slide_dataset.py @@ -0,0 +1,99 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import atexit +from collections import OrderedDict +from typing import Any, Tuple + +from .extended import ExtendedVisionDataset +from pathlib import Path +from openslide import OpenSlide +import numpy as np +import cv2 + +_SLIDE_CACHE: "OrderedDict[str, OpenSlide]" = OrderedDict() +_SLIDE_CACHE_LIMIT = 512 + + +def _close_all_slides(): + for slide in _SLIDE_CACHE.values(): + slide.close() + _SLIDE_CACHE.clear() + + +atexit.register(_close_all_slides) + + +class SlideDataset(ExtendedVisionDataset): + def __init__(self, root, sample_list_path, *args, **kwargs) -> None: + super().__init__(root, *args, **kwargs) + self.sample_list_path = Path(sample_list_path) + if not self.sample_list_path.is_file(): + raise FileNotFoundError(f"Sample list not found at {self.sample_list_path}") + + with self.sample_list_path.open("r") as f: + self.image_files = [line.strip() for line in f if line.strip()] + + print(f"This many resolved paths {len(self.image_files)} from {self.sample_list_path}") + + def get_all(self, index): + parts = self.image_files[index].split(" ") + path = parts[0] + image = _SLIDE_CACHE.get(path) + if image is None: + image = OpenSlide(path) + _SLIDE_CACHE[path] = image + if len(_SLIDE_CACHE) > _SLIDE_CACHE_LIMIT: + _, old = _SLIDE_CACHE.popitem(last=False) + old.close() + else: + _SLIDE_CACHE.move_to_end(path) + return image, path + + def __getitem__(self, index: int) -> Tuple[Any, Any]: + path = self.image_files[index] + parts = path.split(" ") + path, x, y, level = parts + x = int(x) + y = int(y) + level = int(level) + + image = _SLIDE_CACHE.get(path) + if image is None: + image = OpenSlide(path) + _SLIDE_CACHE[path] = image + if len(_SLIDE_CACHE) > _SLIDE_CACHE_LIMIT: + _, old = _SLIDE_CACHE.popitem(last=False) + old.close() + else: + _SLIDE_CACHE.move_to_end(path) + + patch_size = 224 + + patch = image.read_region((x, y), level=level, size=(patch_size, patch_size)) + + res = patch.convert("RGB") + if self.transforms is not None: + return self.transforms(res, None), index + + return res, None, index + + def hsv(self, tile_rgb, patch_size): + tile = np.array(tile_rgb) + tile = cv2.cvtColor(tile, cv2.COLOR_RGB2HSV) + min_ratio = .6 + + lower_bound = np.array([90, 8, 103]) + upper_bound = np.array([180, 255, 255]) + + mask = cv2.inRange(tile, lower_bound, upper_bound) + + ratio = np.count_nonzero(mask) / mask.size + if ratio > min_ratio: + return tile_rgb + else: # ratio failed, reject + return None + + def __len__(self) -> int: + return len(self.image_files) diff --git a/OpenMidnight/dinov2/data/loaders.py b/OpenMidnight/dinov2/data/loaders.py new file mode 100644 index 0000000000000000000000000000000000000000..3f0a3e02c4fafa48472e9ac5d4652db6b0d1e658 --- /dev/null +++ b/OpenMidnight/dinov2/data/loaders.py @@ -0,0 +1,229 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +from enum import Enum +from typing import Any, Callable, List, Optional, TypeVar + +import torch +from torch.utils.data import Sampler + +from .datasets import ImageNet, ImageNet22k, TestVisionDataset, SlideDataset +from .samplers import EpochSampler, InfiniteSampler, ShardedInfiniteSampler + + +logger = logging.getLogger("dinov2") + + +class SamplerType(Enum): + DISTRIBUTED = 0 + EPOCH = 1 + INFINITE = 2 + SHARDED_INFINITE = 3 + SHARDED_INFINITE_NEW = 4 + + +def _make_bool_str(b: bool) -> str: + return "yes" if b else "no" + + +def _make_sample_transform(image_transform: Optional[Callable] = None, target_transform: Optional[Callable] = None): + def transform(sample): + image, target = sample + if image_transform is not None: + image = image_transform(image) + if target_transform is not None: + target = target_transform(target) + return image, target + + return transform + + +def _parse_dataset_str(dataset_str: str): + + tokens = dataset_str.split(":") + + name = tokens[0] + kwargs = {} + + for token in tokens[1:]: + key, value = token.split("=") + assert key in ("root", "extra", "split", "sample_list_path") + kwargs[key] = value + + if name == "ImageNet": + class_ = ImageNet + if "split" in kwargs: + kwargs["split"] = ImageNet.Split[kwargs["split"]] + elif name == "ImageNet22k": + class_ = ImageNet22k + elif name.lower() == "pathology": + class_ = SlideDataset + print("kwargs", kwargs) + else: + raise ValueError(f'Unsupported dataset "{name}"') + + return class_, kwargs + + +def make_dataset( + *, + dataset_str: str, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, +): + """ + Creates a dataset with the specified parameters. + + Args: + dataset_str: A dataset string description (e.g. ImageNet:split=TRAIN). + transform: A transform to apply to images. + target_transform: A transform to apply to targets. + + Returns: + The created dataset. + """ + logger.info(f'using dataset: "{dataset_str}"') + + class_, kwargs = _parse_dataset_str(dataset_str) + dataset = class_(transform=transform, target_transform=target_transform, **kwargs) + + logger.info(f"# of dataset samples: {len(dataset):,d}") + + # Aggregated datasets do not expose (yet) these attributes, so add them. + if not hasattr(dataset, "transform"): + setattr(dataset, "transform", transform) + if not hasattr(dataset, "target_transform"): + setattr(dataset, "target_transform", target_transform) + + return dataset + + +def _make_sampler( + *, + dataset, + type: Optional[SamplerType] = None, + shuffle: bool = False, + seed: int = 0, + size: int = -1, + advance: int = 0, +) -> Optional[Sampler]: + sample_count = len(dataset) + + if type == SamplerType.INFINITE: + logger.info("sampler: infinite") + if size > 0: + raise ValueError("sampler size > 0 is invalid") + return InfiniteSampler( + sample_count=sample_count, + shuffle=shuffle, + seed=seed, + advance=advance, + ) + elif type in (SamplerType.SHARDED_INFINITE, SamplerType.SHARDED_INFINITE_NEW): + logger.info("sampler: sharded infinite") + if size > 0: + raise ValueError("sampler size > 0 is invalid") + # TODO: Remove support for old shuffling + use_new_shuffle_tensor_slice = type == SamplerType.SHARDED_INFINITE_NEW + return ShardedInfiniteSampler( + sample_count=sample_count, + shuffle=shuffle, + seed=seed, + advance=advance, + use_new_shuffle_tensor_slice=use_new_shuffle_tensor_slice, + ) + elif type == SamplerType.EPOCH: + logger.info("sampler: epoch") + if advance > 0: + raise NotImplementedError("sampler advance > 0 is not supported") + size = size if size > 0 else sample_count + logger.info(f"# of samples / epoch: {size:,d}") + return EpochSampler( + size=size, + sample_count=sample_count, + shuffle=shuffle, + seed=seed, + ) + elif type == SamplerType.DISTRIBUTED: + logger.info("sampler: distributed") + if size > 0: + raise ValueError("sampler size > 0 is invalid") + if advance > 0: + raise ValueError("sampler advance > 0 is invalid") + return torch.utils.data.DistributedSampler( + dataset=dataset, + shuffle=shuffle, + seed=seed, + drop_last=False, + ) + + logger.info("sampler: none") + return None + + +T = TypeVar("T") + + +def make_data_loader( + *, + dataset, + batch_size: int, + num_workers: int, + shuffle: bool = True, + seed: int = 0, + sampler_type: Optional[SamplerType] = SamplerType.INFINITE, + sampler_size: int = -1, + sampler_advance: int = 0, + drop_last: bool = True, + persistent_workers: bool = False, + collate_fn: Optional[Callable[[List[T]], Any]] = None, + prefetch_factor: int=2, +): + """ + Creates a data loader with the specified parameters. + + Args: + dataset: A dataset (third party, LaViDa or WebDataset). + batch_size: The size of batches to generate. + num_workers: The number of workers to use. + shuffle: Whether to shuffle samples. + seed: The random seed to use. + sampler_type: Which sampler to use: EPOCH, INFINITE, SHARDED_INFINITE, SHARDED_INFINITE_NEW, DISTRIBUTED or None. + sampler_size: The number of images per epoch (when applicable) or -1 for the entire dataset. + sampler_advance: How many samples to skip (when applicable). + drop_last: Whether the last non-full batch of data should be dropped. + persistent_workers: maintain the workers Dataset instances alive after a dataset has been consumed once. + collate_fn: Function that performs batch collation + """ + + sampler = _make_sampler( + dataset=dataset, + type=sampler_type, + shuffle=shuffle, + seed=seed, + size=sampler_size, + advance=sampler_advance, + ) + + logger.info("using PyTorch data loader") + data_loader = torch.utils.data.DataLoader( + dataset, + sampler=sampler, + batch_size=batch_size, + num_workers=num_workers, + pin_memory=True, + drop_last=drop_last, + persistent_workers=persistent_workers, + collate_fn=collate_fn, + timeout=600, + prefetch_factor=prefetch_factor, + ) + + try: + logger.info(f"# of batches: {len(data_loader):,d}") + except TypeError: # data loader has no length + logger.info("infinite data loader") + return data_loader diff --git a/OpenMidnight/dinov2/data/masking.py b/OpenMidnight/dinov2/data/masking.py new file mode 100644 index 0000000000000000000000000000000000000000..ab12aa7bf138b916b16a9a2ed1a628a2759dbec6 --- /dev/null +++ b/OpenMidnight/dinov2/data/masking.py @@ -0,0 +1,86 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import random +import math +import numpy as np + + +class MaskingGenerator: + def __init__( + self, + input_size, + num_masking_patches=None, + min_num_patches=4, + max_num_patches=None, + min_aspect=0.3, + max_aspect=None, + ): + if not isinstance(input_size, tuple): + input_size = (input_size,) * 2 + self.height, self.width = input_size + + self.num_patches = self.height * self.width + self.num_masking_patches = num_masking_patches + + self.min_num_patches = min_num_patches + self.max_num_patches = num_masking_patches if max_num_patches is None else max_num_patches + + max_aspect = max_aspect or 1 / min_aspect + self.log_aspect_ratio = (math.log(min_aspect), math.log(max_aspect)) + + def __repr__(self): + repr_str = "Generator(%d, %d -> [%d ~ %d], max = %d, %.3f ~ %.3f)" % ( + self.height, + self.width, + self.min_num_patches, + self.max_num_patches, + self.num_masking_patches, + self.log_aspect_ratio[0], + self.log_aspect_ratio[1], + ) + return repr_str + + def get_shape(self): + return self.height, self.width + + def _mask(self, mask, max_mask_patches): + delta = 0 + for _ in range(10): + target_area = random.uniform(self.min_num_patches, max_mask_patches) + aspect_ratio = math.exp(random.uniform(*self.log_aspect_ratio)) + h = int(round(math.sqrt(target_area * aspect_ratio))) + w = int(round(math.sqrt(target_area / aspect_ratio))) + if w < self.width and h < self.height: + top = random.randint(0, self.height - h) + left = random.randint(0, self.width - w) + + num_masked = mask[top : top + h, left : left + w].sum() + # Overlap + if 0 < h * w - num_masked <= max_mask_patches: + for i in range(top, top + h): + for j in range(left, left + w): + if mask[i, j] == 0: + mask[i, j] = 1 + delta += 1 + + if delta > 0: + break + return delta + + def __call__(self, num_masking_patches=0): + mask = np.zeros(shape=self.get_shape(), dtype=bool) + mask_count = 0 + while mask_count < num_masking_patches: + max_mask_patches = num_masking_patches - mask_count + max_mask_patches = min(max_mask_patches, self.max_num_patches) + + delta = self._mask(mask, max_mask_patches) + if delta == 0: + break + else: + mask_count += delta + + return mask diff --git a/OpenMidnight/dinov2/data/openpath_wds.py b/OpenMidnight/dinov2/data/openpath_wds.py new file mode 100644 index 0000000000000000000000000000000000000000..7e39c7b80e7ed846950674a9a46c5d8d3b1d223d --- /dev/null +++ b/OpenMidnight/dinov2/data/openpath_wds.py @@ -0,0 +1,229 @@ +# OpenPath WebDataset loader for OpenMidnight (DINOv2 fork). +# +# OpenMidnight ships two data paths: HF-parquet streaming and on-the-fly SVS +# patching. OpenPath data is ALREADY pre-patched into WebDataset tar shards +# (`data/tiles/shards/w*/*.tar`, each sample = key.jpg + key.json). This module +# adds a third path that streams those shards and yields samples shaped exactly +# like OpenMidnight's collate expects: `((transform(pil), None), meta)`. +# +# It is self-contained (pure tarfile — no `webdataset` dependency) and replicates +# the proven default behavior of our original loader: resampled random shard +# sampling (with replacement) + a sample-level shuffle buffer + split filtering. +# (The InterleavedShards round-robin variant was falsified downstream, so it is +# intentionally not ported.) +# +# dataset_str format (reuses `cfg.train.sample_list_path`): +# openpath:glob=/abs/shards/w*/*.tar:split=/abs/pretrain_train.txt[:mag=20] +import glob as _glob +import io as _io +import json as _json +import os as _os +import random as _random +import tarfile as _tarfile + +import torch +from PIL import Image + + +def parse_openpath_path(dataset_str): + assert dataset_str.startswith("openpath:"), dataset_str + out = {} + for kv in dataset_str[len("openpath:"):].split(":"): + if not kv: + continue + k, _, v = kv.partition("=") + out[k] = v + assert "glob" in out, "openpath dataset_path requires glob=..." + mag = float(out["mag"]) if out.get("mag") else None + return out["glob"], out.get("split") or None, mag + + +def _iter_shard(path): + """Yield {'__key__','jpg','json'} dicts from a tar shard. A sample's members + (key.jpg, key.json) are contiguous in-tar, so group by key.""" + grp, cur = {}, None + try: + with _tarfile.open(path) as tar: + for m in tar: + if not m.isfile(): + continue + key, _, ext = m.name.rpartition(".") + if cur is not None and key != cur: + if "jpg" in grp and "json" in grp: + yield grp + grp = {} + cur = key + grp["__key__"] = key + f = tar.extractfile(m) + if f is not None: + grp[ext] = f.read() + if "jpg" in grp and "json" in grp: + yield grp + except Exception: + return + + +class OpenPathWds(torch.utils.data.IterableDataset): + """Infinite, rank/worker-sharded stream of transformed OpenPath tiles. + + Yields `((transform(pil_rgb), None), key)` to match OpenMidnight's + `collate_data_and_cast` (reads sample[0]=(crops_dict,None), sample[1]=meta).""" + + def __init__(self, shards, transform, keep_ids=None, mag=None, shuffle=2000, base_seed=0, interleave=24): + super().__init__() + self.shards = shards + self.transform = transform + self.keep_ids = keep_ids + self.mag = mag + self.shuffle = shuffle + self.base_seed = base_seed + # ★ 각 shard=4-5 WSI 연속타일. K개 shard 동시 round-robin → ~K×4.5 WSI/배치 다양성. + # 필수 — 단일/소수 WSI 배치는 DINO/iBOT centering·sharpening 통계 붕괴(검증됨). + self.interleave = max(1, interleave) + + def _keep(self, raw_json): + if self.keep_ids is None and self.mag is None: + return True + try: + j = _json.loads(raw_json) + except Exception: + return False + if self.keep_ids is not None and j.get("wsi_id") not in self.keep_ids: + return False + if self.mag is not None and j.get("mag") != self.mag: + return False + return True + + def __iter__(self): + wi = torch.utils.data.get_worker_info() + rank = int(_os.environ.get("RANK", 0)) + world = int(_os.environ.get("WORLD_SIZE", 1)) + wid = wi.id if wi else 0 + nw = wi.num_workers if wi else 1 + # Per-(rank,worker) RNG so every reader draws an independent shard stream + # (resampled-with-replacement, like wds.WebDataset(resampled=True)). + rng = _random.Random(self.base_seed + rank * 1_000_003 + wid * 9176 + 17) + + buf = [] + S = max(self.shuffle, 1) + + def _one_shard_stream(): + # 한 shard를 끝까지 흘리고, 소진되면 새 무작위 shard로 교체(무한). + while True: + shard = rng.choice(self.shards) + for s in _iter_shard(shard): + if self._keep(s.get("json", b"")): + yield s + + def gen(): + # ★ K개 shard 스트림을 동시에 열어 round-robin → 연속샘플이 서로 다른 shard/WSI에서. + K = min(self.interleave, len(self.shards)) + streams = [_one_shard_stream() for _ in range(K)] + while True: + for st in streams: + yield next(st) + + src = gen() + # prime shuffle buffer + for _ in range(S): + buf.append(next(src)) + while True: + i = rng.randrange(len(buf)) + s = buf[i] + buf[i] = next(src) + try: + img = Image.open(_io.BytesIO(s["jpg"])).convert("RGB") + except Exception: + continue + yield (self.transform(img), None), s["__key__"] + + +def _iter_parquet(path): + """parquet 파일에서 {'jpg','__key__'} 샘플을 yield (image_bytes 컬럼=jpg/png 바이트).""" + import pyarrow.parquet as _pq + try: + t = _pq.read_table(path, columns=["image_bytes", "slide_path", "x", "y"]) + cols = t.to_pydict() + ib = cols["image_bytes"]; sp = cols["slide_path"]; xs = cols["x"]; ys = cols["y"] + for i in range(len(ib)): + yield {"jpg": ib[i], "__key__": f"{sp[i]}_{xs[i]}_{ys[i]}"} + except Exception: + return + + +class ParquetTiles(torch.utils.data.IterableDataset): + """parquet 파일 리스트를 resampled-with-replacement로 스트리밍(tar 로더와 동일 패턴).""" + def __init__(self, files, transform, shuffle=1000, base_seed=0): + super().__init__() + self.files = files; self.transform = transform + self.shuffle = shuffle; self.base_seed = base_seed + + def __iter__(self): + wi = torch.utils.data.get_worker_info() + rank = int(_os.environ.get("RANK", 0)); wid = wi.id if wi else 0 + rng = _random.Random(self.base_seed + rank * 1_000_003 + wid * 9176 + 17) + S = max(self.shuffle, 1) + + def gen(): + while True: + for s in _iter_parquet(rng.choice(self.files)): + yield s + src = gen() + buf = [next(src) for _ in range(S)] + while True: + i = rng.randrange(len(buf)); s = buf[i]; buf[i] = next(src) + try: + img = Image.open(_io.BytesIO(s["jpg"])).convert("RGB") + except Exception: + continue + yield (self.transform(img), None), s["__key__"] + + +def make_openpath_parquet_loader(dataset_str, batch_size, num_workers, data_transform, + collate_fn, shuffle=50000, prefetch_factor=4): + # ★ shuffle=50000(OpenMidnight 동일): 각 parquet=1슬라이드라 큰 버퍼로 ~22슬라이드 혼합 + # 필수 — 작은 버퍼는 단일슬라이드 배치 → DINO/iBOT 통계 붕괴. + # dataset_str: "parquet:glob=/abs/**/*.parquet" + glob_pat = dataset_str[len("parquet:"):] + if glob_pat.startswith("glob="): + glob_pat = glob_pat[len("glob="):] + files = sorted(_glob.glob(glob_pat)) + if not files: + raise FileNotFoundError(f"no parquet match {glob_pat}") + print(f"[openpath_parquet] files={len(files)}", flush=True) + ds = ParquetTiles(files, data_transform, shuffle=shuffle) + return torch.utils.data.DataLoader( + ds, batch_size=batch_size, num_workers=num_workers, drop_last=True, + pin_memory=True, persistent_workers=num_workers > 0, collate_fn=collate_fn, + prefetch_factor=prefetch_factor if num_workers > 0 else None, + ) + + +def make_openpath_loader(dataset_str, batch_size, num_workers, data_transform, + collate_fn, shuffle=1000, prefetch_factor=4): + shard_glob, split_path, mag = parse_openpath_path(dataset_str) + # glob may be a single pattern or several comma-separated ones (e.g. to + # union the base corpus with an extra source like CPTAC living under a + # different data root). dedup in case patterns overlap. + shards = sorted({s for pat in shard_glob.split(",") if pat + for s in _glob.glob(pat)}) + if not shards: + raise FileNotFoundError(f"no shards match {shard_glob}") + keep_ids = None + if split_path: + with open(split_path) as f: + keep_ids = set(f.read().split()) + print(f"[openpath_wds] shards={len(shards)} split={'Y' if keep_ids else 'N'} mag={mag}", + flush=True) + + ds = OpenPathWds(shards, data_transform, keep_ids=keep_ids, mag=mag, shuffle=shuffle) + return torch.utils.data.DataLoader( + ds, + batch_size=batch_size, + num_workers=num_workers, + drop_last=True, + pin_memory=True, + persistent_workers=num_workers > 0, + collate_fn=collate_fn, + prefetch_factor=prefetch_factor if num_workers > 0 else None, + ) diff --git a/OpenMidnight/dinov2/data/samplers.py b/OpenMidnight/dinov2/data/samplers.py new file mode 100644 index 0000000000000000000000000000000000000000..6562197d94652bb9a75a5fc722fcb2c65ca161be --- /dev/null +++ b/OpenMidnight/dinov2/data/samplers.py @@ -0,0 +1,229 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import itertools +from typing import Any, Optional +import warnings + +import numpy as np +import torch +from torch.utils.data.sampler import Sampler + +import dinov2.distributed as distributed + + +class EpochSampler(Sampler): + def __init__( + self, + *, + size: int, + sample_count: int, + shuffle: bool = False, + seed: int = 0, + start: Optional[int] = None, + step: Optional[int] = None, + ): + self._size = size + self._sample_count = sample_count + self._shuffle = shuffle + self._seed = seed + self._start = distributed.get_global_rank() if start is None else start + self._step = distributed.get_global_size() if step is None else step + self._epoch = 0 + + def __iter__(self): + count = (self._size + self._sample_count - 1) // self._sample_count + tiled_indices = np.tile(np.arange(self._sample_count), count) + if self._shuffle: + seed = self._seed * self._epoch if self._seed != 0 else self._epoch + rng = np.random.default_rng(seed) + iterable = rng.choice(tiled_indices, self._size, replace=False) + else: + iterable = tiled_indices[: self._size] + + yield from itertools.islice(iterable, self._start, None, self._step) + + def __len__(self): + return (self._size - self._start + self._step - 1) // self._step + + def set_epoch(self, epoch): + self._epoch = epoch + + +def _get_numpy_dtype(size: int) -> Any: + return np.int32 if size <= 2**31 else np.int64 + + +def _get_torch_dtype(size: int) -> Any: + return torch.int32 if size <= 2**31 else torch.int64 + + +def _generate_randperm_indices(*, size: int, generator: torch.Generator): + """Generate the indices of a random permutation.""" + dtype = _get_torch_dtype(size) + # This is actually matching PyTorch's CPU implementation, see: https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/TensorFactories.cpp#L900-L921 + perm = torch.arange(size, dtype=dtype) + for i in range(size): + j = torch.randint(i, size, size=(1,), generator=generator).item() + + # Always swap even if no-op + value = perm[j].item() + perm[j] = perm[i].item() + perm[i] = value + yield value + + +class InfiniteSampler(Sampler): + def __init__( + self, + *, + sample_count: int, + shuffle: bool = False, + seed: int = 0, + start: Optional[int] = None, + step: Optional[int] = None, + advance: int = 0, + ): + self._sample_count = sample_count + self._seed = seed + self._shuffle = shuffle + self._start = distributed.get_global_rank() if start is None else start + self._step = distributed.get_global_size() if step is None else step + self._advance = advance + + def __iter__(self): + if self._shuffle: + iterator = self._shuffled_iterator() + else: + iterator = self._iterator() + + yield from itertools.islice(iterator, self._advance, None) + + def _iterator(self): + assert not self._shuffle + + while True: + iterable = range(self._sample_count) + yield from itertools.islice(iterable, self._start, None, self._step) + + def _shuffled_iterator(self): + assert self._shuffle + + # Instantiate a generator here (rather than in the ctor) to keep the class + # picklable (requirement of mp.spawn) + generator = torch.Generator().manual_seed(self._seed) + + while True: + iterable = _generate_randperm_indices(size=self._sample_count, generator=generator) + yield from itertools.islice(iterable, self._start, None, self._step) + + +# The following function is somewhat equivalent to _new_shuffle_tensor_slice below, +# but avoids a full in-place random permutation generation. +def _shuffle_tensor_slice( + *, tensor: torch.Tensor, start: int = 0, step: int = 1, generator: torch.Generator +) -> np.ndarray: + stop = len(tensor) + count = stop // step + drop_count = stop - step * count + if drop_count: + warnings.warn(f"# of dropped samples: {drop_count}") + + dtype = _get_numpy_dtype(stop) + result = np.empty(count, dtype=dtype) + + for i in range(count): + j = torch.randint(0, i + 1, size=(1,), generator=generator).item() if i > 0 else 0 + + result[i] = result[j] + result[j] = tensor[start + i * step].item() + + return result + + +def _new_shuffle_tensor_slice( + *, tensor: torch.Tensor, start: int = 0, step: int = 1, generator: torch.Generator +) -> np.ndarray: + stop = len(tensor) + count = stop // step + dtype = torch.int64 # Needed for using randperm result as indices + count = stop // step + drop_count = stop - step * count + if drop_count: + warnings.warn(f"# of dropped samples: {drop_count}") + indices = torch.randperm(count, dtype=dtype, generator=generator) + return tensor[start::step][indices].numpy() + + +def _make_seed(seed: int, start: int, iter_count: int) -> int: + # NOTE: Tried a few variants (including iter_count << 32), this one worked best. + return seed + start + (iter_count << 24) + + +class ShardedInfiniteSampler(Sampler): + def __init__( + self, + *, + sample_count: int, + shuffle: bool = False, + seed: int = 0, + start: Optional[int] = None, + step: Optional[int] = None, + advance: int = 0, + use_new_shuffle_tensor_slice: bool = False, + ): + self._sample_count = sample_count + self._seed = seed + self._shuffle = shuffle + self._start = distributed.get_global_rank() if start is None else start + self._step = distributed.get_global_size() if step is None else step + self._advance = advance + self._iter_count = 0 + self._shuffle_tensor_slice_fn = ( + _new_shuffle_tensor_slice if use_new_shuffle_tensor_slice else _shuffle_tensor_slice + ) + + def __iter__(self): + iter_count = self._advance // self._sample_count + if iter_count > 0: + self._advance -= iter_count * self._sample_count + self._iter_count += iter_count + + if self._shuffle: + iterator = self._shuffled_iterator() + else: + iterator = self._iterator() + + yield from itertools.islice(iterator, self._advance, None) + + def _iterator(self): + assert not self._shuffle + + while True: + iterable = range(self._sample_count) + yield from itertools.islice(iterable, self._start, None, self._step) + + def _shuffled_iterator(self): + assert self._shuffle + + # Instantiate a generator here (rather than in the ctor) to be keep the class + # picklable (requirement of mp.spawn) + generator = torch.Generator() + + # Always shuffle everything first + generator.manual_seed(self._seed) + dtype = _get_torch_dtype(self._sample_count) + perm = torch.randperm(self._sample_count, dtype=dtype, generator=generator) + + while True: + # Re-seed on each iteration to allow skipping whole permutations + seed = _make_seed(self._seed, self._start, self._iter_count) + generator.manual_seed(seed) + + iterable = self._shuffle_tensor_slice_fn( + tensor=perm, start=self._start, step=self._step, generator=generator + ) + yield from iterable + self._iter_count += 1 diff --git a/OpenMidnight/dinov2/data/transforms.py b/OpenMidnight/dinov2/data/transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..eb5f252b50c54d58f160528c9f2b00fad47103c7 --- /dev/null +++ b/OpenMidnight/dinov2/data/transforms.py @@ -0,0 +1,91 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from typing import Sequence + +import torch +from torchvision import transforms + + +class GaussianBlur(transforms.RandomApply): + """ + Apply Gaussian Blur to the PIL image. + """ + + def __init__(self, *, p: float = 0.5, radius_min: float = 0.1, radius_max: float = 2.0): + # NOTE: torchvision is applying 1 - probability to return the original image + keep_p = 1 - p + transform = transforms.GaussianBlur(kernel_size=9, sigma=(radius_min, radius_max)) + super().__init__(transforms=[transform], p=keep_p) + + +class MaybeToTensor(transforms.ToTensor): + """ + Convert a ``PIL Image`` or ``numpy.ndarray`` to tensor, or keep as is if already a tensor. + """ + + def __call__(self, pic): + """ + Args: + pic (PIL Image, numpy.ndarray or torch.tensor): Image to be converted to tensor. + Returns: + Tensor: Converted image. + """ + if isinstance(pic, torch.Tensor): + return pic + return super().__call__(pic) + + +# Use timm's names +IMAGENET_DEFAULT_MEAN = (0.485, 0.456, 0.406) +IMAGENET_DEFAULT_STD = (0.229, 0.224, 0.225) + + +def make_normalize_transform( + mean: Sequence[float] = IMAGENET_DEFAULT_MEAN, + std: Sequence[float] = IMAGENET_DEFAULT_STD, +) -> transforms.Normalize: + return transforms.Normalize(mean=mean, std=std) + + +# This roughly matches torchvision's preset for classification training: +# https://github.com/pytorch/vision/blob/main/references/classification/presets.py#L6-L44 +def make_classification_train_transform( + *, + crop_size: int = 224, + interpolation=transforms.InterpolationMode.BICUBIC, + hflip_prob: float = 0.5, + mean: Sequence[float] = IMAGENET_DEFAULT_MEAN, + std: Sequence[float] = IMAGENET_DEFAULT_STD, +): + transforms_list = [transforms.RandomResizedCrop(crop_size, interpolation=interpolation)] + if hflip_prob > 0.0: + transforms_list.append(transforms.RandomHorizontalFlip(hflip_prob)) + transforms_list.extend( + [ + MaybeToTensor(), + make_normalize_transform(mean=mean, std=std), + ] + ) + return transforms.Compose(transforms_list) + + +# This matches (roughly) torchvision's preset for classification evaluation: +# https://github.com/pytorch/vision/blob/main/references/classification/presets.py#L47-L69 +def make_classification_eval_transform( + *, + resize_size: int = 256, + interpolation=transforms.InterpolationMode.BICUBIC, + crop_size: int = 224, + mean: Sequence[float] = IMAGENET_DEFAULT_MEAN, + std: Sequence[float] = IMAGENET_DEFAULT_STD, +) -> transforms.Compose: + transforms_list = [ + transforms.Resize(resize_size, interpolation=interpolation), + transforms.CenterCrop(crop_size), + MaybeToTensor(), + make_normalize_transform(mean=mean, std=std), + ] + return transforms.Compose(transforms_list) diff --git a/OpenMidnight/dinov2/distributed/__init__.py b/OpenMidnight/dinov2/distributed/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..41224f9ecb6f5d4baa82c2a36a2799ce3d582006 --- /dev/null +++ b/OpenMidnight/dinov2/distributed/__init__.py @@ -0,0 +1,276 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import os +import random +import re +import socket +from typing import Dict, List + +import torch +import torch.distributed as dist + +_LOCAL_RANK = -1 +_LOCAL_WORLD_SIZE = -1 + + +def is_enabled() -> bool: + """ + Returns: + True if distributed training is enabled + """ + return dist.is_available() and dist.is_initialized() + + +def get_global_size() -> int: + """ + Returns: + The number of processes in the process group + """ + return dist.get_world_size() if is_enabled() else 1 + + +def get_global_rank() -> int: + """ + Returns: + The rank of the current process within the global process group. + """ + return dist.get_rank() if is_enabled() else 0 + + +def get_local_rank() -> int: + """ + Returns: + The rank of the current process within the local (per-machine) process group. + """ + if not is_enabled(): + return 0 + assert 0 <= _LOCAL_RANK < _LOCAL_WORLD_SIZE + return _LOCAL_RANK + + +def get_local_size() -> int: + """ + Returns: + The size of the per-machine process group, + i.e. the number of processes per machine. + """ + if not is_enabled(): + return 1 + assert 0 <= _LOCAL_RANK < _LOCAL_WORLD_SIZE + return _LOCAL_WORLD_SIZE + + +def is_main_process() -> bool: + """ + Returns: + True if the current process is the main one. + """ + return get_global_rank() == 0 + + +def _restrict_print_to_main_process() -> None: + """ + This function disables printing when not in the main process + """ + import builtins as __builtin__ + + builtin_print = __builtin__.print + + def print(*args, **kwargs): + force = kwargs.pop("force", False) + if is_main_process() or force: + builtin_print(*args, **kwargs) + + __builtin__.print = print + + +def _get_master_port(seed: int = 0) -> int: + MIN_MASTER_PORT, MAX_MASTER_PORT = (20_000, 60_000) + + master_port_str = os.environ.get("MASTER_PORT") + if master_port_str is None: + rng = random.Random(seed) + return rng.randint(MIN_MASTER_PORT, MAX_MASTER_PORT) + + return int(master_port_str) + + +def _get_available_port() -> int: + with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: + # A "" host address means INADDR_ANY i.e. binding to all interfaces. + # Note this is not compatible with IPv6. + s.bind(("", 0)) + port = s.getsockname()[1] + return port + + +_TORCH_DISTRIBUTED_ENV_VARS = ( + "MASTER_ADDR", + "MASTER_PORT", + "RANK", + "WORLD_SIZE", + "LOCAL_RANK", + "LOCAL_WORLD_SIZE", +) + + +def _collect_env_vars() -> Dict[str, str]: + return {env_var: os.environ[env_var] for env_var in _TORCH_DISTRIBUTED_ENV_VARS if env_var in os.environ} + + +def _is_slurm_job_process() -> bool: + return "SLURM_JOB_ID" in os.environ + + +def _parse_slurm_node_list(s: str) -> List[str]: + nodes = [] + # Extract "hostname", "hostname[1-2,3,4-5]," substrings + p = re.compile(r"(([^\[]+)(?:\[([^\]]+)\])?),?") + for m in p.finditer(s): + prefix, suffixes = s[m.start(2) : m.end(2)], s[m.start(3) : m.end(3)] + for suffix in suffixes.split(","): + span = suffix.split("-") + if len(span) == 1: + nodes.append(prefix + suffix) + else: + width = len(span[0]) + start, end = int(span[0]), int(span[1]) + 1 + nodes.extend([prefix + f"{i:0{width}}" for i in range(start, end)]) + return nodes + + +def _check_env_variable(key: str, new_value: str): + # Only check for difference with preset environment variables + if key in os.environ and os.environ[key] != new_value: + raise RuntimeError(f"Cannot export environment variables as {key} is already set") + + +class _TorchDistributedEnvironment: + def __init__(self): + self.master_addr = "127.0.0.1" + self.master_port = 0 + self.rank = -1 + self.world_size = -1 + self.local_rank = -1 + self.local_world_size = -1 + + env_vars = _collect_env_vars() + if not env_vars: + # Environment is not set + pass + elif len(env_vars) == len(_TORCH_DISTRIBUTED_ENV_VARS): + # Environment is fully set + return self._set_from_preset_env() + else: + # Environment is partially set + collected_env_vars = ", ".join(env_vars.keys()) + raise RuntimeError(f"Partially set environment: {collected_env_vars}") + + if _is_slurm_job_process(): + return self._set_from_slurm_env() + + if torch.cuda.device_count() > 0: + return self._set_from_local() + + raise RuntimeError("Can't initialize PyTorch distributed environment") + + # Slurm job created with sbatch, submitit, etc... + def _set_from_slurm_env(self): + # logger.info("Initialization from Slurm environment") + job_id = int(os.environ["SLURM_JOB_ID"]) + node_count = int(os.environ["SLURM_JOB_NUM_NODES"]) + nodes = _parse_slurm_node_list(os.environ["SLURM_JOB_NODELIST"]) + assert len(nodes) == node_count + + self.master_addr = nodes[0] + self.master_port = _get_master_port(seed=job_id) + self.rank = int(os.environ["SLURM_PROCID"]) + self.world_size = int(os.environ["SLURM_NTASKS"]) + assert self.rank < self.world_size + self.local_rank = int(os.environ["SLURM_LOCALID"]) + self.local_world_size = self.world_size // node_count + assert self.local_rank < self.local_world_size + + # Single node job with preset environment (i.e. torchrun) + def _set_from_preset_env(self): + # logger.info("Initialization from preset environment") + self.master_addr = os.environ["MASTER_ADDR"] + self.master_port = os.environ["MASTER_PORT"] + self.rank = int(os.environ["RANK"]) + self.world_size = int(os.environ["WORLD_SIZE"]) + assert self.rank < self.world_size + self.local_rank = int(os.environ["LOCAL_RANK"]) + self.local_world_size = int(os.environ["LOCAL_WORLD_SIZE"]) + assert self.local_rank < self.local_world_size + + # Single node and GPU job (i.e. local script run) + def _set_from_local(self): + # logger.info("Initialization from local") + self.master_addr = "127.0.0.1" + self.master_port = _get_available_port() + self.rank = 0 + self.world_size = 1 + self.local_rank = 0 + self.local_world_size = 1 + + def export(self, *, overwrite: bool) -> "_TorchDistributedEnvironment": + # See the "Environment variable initialization" section from + # https://pytorch.org/docs/stable/distributed.html for the complete list of + # environment variables required for the env:// initialization method. + env_vars = { + "MASTER_ADDR": self.master_addr, + "MASTER_PORT": str(self.master_port), + "RANK": str(self.rank), + "WORLD_SIZE": str(self.world_size), + "LOCAL_RANK": str(self.local_rank), + "LOCAL_WORLD_SIZE": str(self.local_world_size), + } + if not overwrite: + for k, v in env_vars.items(): + _check_env_variable(k, v) + + os.environ.update(env_vars) + return self + + +def enable(*, set_cuda_current_device: bool = True, overwrite: bool = False, allow_nccl_timeout: bool = False): + """Enable distributed mode + + Args: + set_cuda_current_device: If True, call torch.cuda.set_device() to set the + current PyTorch CUDA device to the one matching the local rank. + overwrite: If True, overwrites already set variables. Else fails. + """ + + global _LOCAL_RANK, _LOCAL_WORLD_SIZE + if _LOCAL_RANK >= 0 or _LOCAL_WORLD_SIZE >= 0: + raise RuntimeError("Distributed mode has already been enabled") + torch_env = _TorchDistributedEnvironment() + torch_env.export(overwrite=overwrite) + + if set_cuda_current_device: + torch.cuda.set_device(torch_env.local_rank) + + if allow_nccl_timeout: + # This allows to use torch distributed timeout in a NCCL backend + key, value = "NCCL_ASYNC_ERROR_HANDLING", "1" + if not overwrite: + _check_env_variable(key, value) + os.environ[key] = value + + dist.init_process_group(backend="nccl") + + # Explicitly wire the local CUDA device into the first rendezvous so NCCL + # doesn't guess and emit "device unknown" warnings on multi-GPU startup. + if torch.cuda.is_available(): + dist.barrier(device_ids=[torch_env.local_rank]) + else: + dist.barrier() + + # Finalize setup + _LOCAL_RANK = torch_env.local_rank + _LOCAL_WORLD_SIZE = torch_env.local_world_size + _restrict_print_to_main_process() diff --git a/OpenMidnight/dinov2/eval/__init__.py b/OpenMidnight/dinov2/eval/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b88da6bf80be92af00b72dfdb0a806fa64a7a2d9 --- /dev/null +++ b/OpenMidnight/dinov2/eval/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/OpenMidnight/dinov2/eval/depth/__init__.py b/OpenMidnight/dinov2/eval/depth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b88da6bf80be92af00b72dfdb0a806fa64a7a2d9 --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/OpenMidnight/dinov2/eval/depth/models/__init__.py b/OpenMidnight/dinov2/eval/depth/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9a5825181dc2189424b5c58d245b36919cbc5b2e --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/__init__.py @@ -0,0 +1,10 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .backbones import * # noqa: F403 +from .builder import BACKBONES, DEPTHER, HEADS, LOSSES, build_backbone, build_depther, build_head, build_loss +from .decode_heads import * # noqa: F403 +from .depther import * # noqa: F403 +from .losses import * # noqa: F403 diff --git a/OpenMidnight/dinov2/eval/depth/models/backbones/__init__.py b/OpenMidnight/dinov2/eval/depth/models/backbones/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..520d75bc6e064b9d64487293604ac1bda6e2b6f7 --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/backbones/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .vision_transformer import DinoVisionTransformer diff --git a/OpenMidnight/dinov2/eval/depth/models/backbones/vision_transformer.py b/OpenMidnight/dinov2/eval/depth/models/backbones/vision_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..69bda46fd69eb7dabb8f5b60e6fa459fdc21aeab --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/backbones/vision_transformer.py @@ -0,0 +1,16 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from mmcv.runner import BaseModule + +from ..builder import BACKBONES + + +@BACKBONES.register_module() +class DinoVisionTransformer(BaseModule): + """Vision Transformer.""" + + def __init__(self, *args, **kwargs): + super().__init__() diff --git a/OpenMidnight/dinov2/eval/depth/models/builder.py b/OpenMidnight/dinov2/eval/depth/models/builder.py new file mode 100644 index 0000000000000000000000000000000000000000..c152643435308afcff60b07cd68ea979fe1d90cb --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/builder.py @@ -0,0 +1,49 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import warnings + +from mmcv.cnn import MODELS as MMCV_MODELS +from mmcv.cnn.bricks.registry import ATTENTION as MMCV_ATTENTION +from mmcv.utils import Registry + +MODELS = Registry("models", parent=MMCV_MODELS) +ATTENTION = Registry("attention", parent=MMCV_ATTENTION) + + +BACKBONES = MODELS +NECKS = MODELS +HEADS = MODELS +LOSSES = MODELS +DEPTHER = MODELS + + +def build_backbone(cfg): + """Build backbone.""" + return BACKBONES.build(cfg) + + +def build_neck(cfg): + """Build neck.""" + return NECKS.build(cfg) + + +def build_head(cfg): + """Build head.""" + return HEADS.build(cfg) + + +def build_loss(cfg): + """Build loss.""" + return LOSSES.build(cfg) + + +def build_depther(cfg, train_cfg=None, test_cfg=None): + """Build depther.""" + if train_cfg is not None or test_cfg is not None: + warnings.warn("train_cfg and test_cfg is deprecated, " "please specify them in model", UserWarning) + assert cfg.get("train_cfg") is None or train_cfg is None, "train_cfg specified in both outer field and model field " + assert cfg.get("test_cfg") is None or test_cfg is None, "test_cfg specified in both outer field and model field " + return DEPTHER.build(cfg, default_args=dict(train_cfg=train_cfg, test_cfg=test_cfg)) diff --git a/OpenMidnight/dinov2/eval/depth/models/decode_heads/__init__.py b/OpenMidnight/dinov2/eval/depth/models/decode_heads/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bd0f0754a5b01d7622c1f26bf3f60daea19da4e8 --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/decode_heads/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .dpt_head import DPTHead +from .linear_head import BNHead diff --git a/OpenMidnight/dinov2/eval/depth/models/decode_heads/decode_head.py b/OpenMidnight/dinov2/eval/depth/models/decode_heads/decode_head.py new file mode 100644 index 0000000000000000000000000000000000000000..f8c867a3ec687090b280d90bb86aee435320acda --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/decode_heads/decode_head.py @@ -0,0 +1,225 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import copy +from abc import ABCMeta, abstractmethod + +import mmcv +import numpy as np +import torch +import torch.nn as nn +from mmcv.runner import BaseModule, auto_fp16, force_fp32 + +from ...ops import resize +from ..builder import build_loss + + +class DepthBaseDecodeHead(BaseModule, metaclass=ABCMeta): + """Base class for BaseDecodeHead. + + Args: + in_channels (List): Input channels. + channels (int): Channels after modules, before conv_depth. + conv_cfg (dict|None): Config of conv layers. Default: None. + act_cfg (dict): Config of activation layers. + Default: dict(type='ReLU') + loss_decode (dict): Config of decode loss. + Default: dict(type='SigLoss'). + sampler (dict|None): The config of depth map sampler. + Default: None. + align_corners (bool): align_corners argument of F.interpolate. + Default: False. + min_depth (int): Min depth in dataset setting. + Default: 1e-3. + max_depth (int): Max depth in dataset setting. + Default: None. + norm_cfg (dict|None): Config of norm layers. + Default: None. + classify (bool): Whether predict depth in a cls.-reg. manner. + Default: False. + n_bins (int): The number of bins used in cls. step. + Default: 256. + bins_strategy (str): The discrete strategy used in cls. step. + Default: 'UD'. + norm_strategy (str): The norm strategy on cls. probability + distribution. Default: 'linear' + scale_up (str): Whether predict depth in a scale-up manner. + Default: False. + """ + + def __init__( + self, + in_channels, + channels=96, + conv_cfg=None, + act_cfg=dict(type="ReLU"), + loss_decode=dict(type="SigLoss", valid_mask=True, loss_weight=10), + sampler=None, + align_corners=False, + min_depth=1e-3, + max_depth=None, + norm_cfg=None, + classify=False, + n_bins=256, + bins_strategy="UD", + norm_strategy="linear", + scale_up=False, + ): + super(DepthBaseDecodeHead, self).__init__() + + self.in_channels = in_channels + self.channels = channels + self.conv_cfg = conv_cfg + self.act_cfg = act_cfg + if isinstance(loss_decode, dict): + self.loss_decode = build_loss(loss_decode) + elif isinstance(loss_decode, (list, tuple)): + self.loss_decode = nn.ModuleList() + for loss in loss_decode: + self.loss_decode.append(build_loss(loss)) + self.align_corners = align_corners + self.min_depth = min_depth + self.max_depth = max_depth + self.norm_cfg = norm_cfg + self.classify = classify + self.n_bins = n_bins + self.scale_up = scale_up + + if self.classify: + assert bins_strategy in ["UD", "SID"], "Support bins_strategy: UD, SID" + assert norm_strategy in ["linear", "softmax", "sigmoid"], "Support norm_strategy: linear, softmax, sigmoid" + + self.bins_strategy = bins_strategy + self.norm_strategy = norm_strategy + self.softmax = nn.Softmax(dim=1) + self.conv_depth = nn.Conv2d(channels, n_bins, kernel_size=3, padding=1, stride=1) + else: + self.conv_depth = nn.Conv2d(channels, 1, kernel_size=3, padding=1, stride=1) + + self.fp16_enabled = False + self.relu = nn.ReLU() + self.sigmoid = nn.Sigmoid() + + def extra_repr(self): + """Extra repr.""" + s = f"align_corners={self.align_corners}" + return s + + @auto_fp16() + @abstractmethod + def forward(self, inputs, img_metas): + """Placeholder of forward function.""" + pass + + def forward_train(self, img, inputs, img_metas, depth_gt, train_cfg): + """Forward function for training. + Args: + inputs (list[Tensor]): List of multi-level img features. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + depth_gt (Tensor): GT depth + train_cfg (dict): The training config. + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + depth_pred = self.forward(inputs, img_metas) + losses = self.losses(depth_pred, depth_gt) + + log_imgs = self.log_images(img[0], depth_pred[0], depth_gt[0], img_metas[0]) + losses.update(**log_imgs) + + return losses + + def forward_test(self, inputs, img_metas, test_cfg): + """Forward function for testing. + Args: + inputs (list[Tensor]): List of multi-level img features. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + test_cfg (dict): The testing config. + + Returns: + Tensor: Output depth map. + """ + return self.forward(inputs, img_metas) + + def depth_pred(self, feat): + """Prediction each pixel.""" + if self.classify: + logit = self.conv_depth(feat) + + if self.bins_strategy == "UD": + bins = torch.linspace(self.min_depth, self.max_depth, self.n_bins, device=feat.device) + elif self.bins_strategy == "SID": + bins = torch.logspace(self.min_depth, self.max_depth, self.n_bins, device=feat.device) + + # following Adabins, default linear + if self.norm_strategy == "linear": + logit = torch.relu(logit) + eps = 0.1 + logit = logit + eps + logit = logit / logit.sum(dim=1, keepdim=True) + elif self.norm_strategy == "softmax": + logit = torch.softmax(logit, dim=1) + elif self.norm_strategy == "sigmoid": + logit = torch.sigmoid(logit) + logit = logit / logit.sum(dim=1, keepdim=True) + + output = torch.einsum("ikmn,k->imn", [logit, bins]).unsqueeze(dim=1) + + else: + if self.scale_up: + output = self.sigmoid(self.conv_depth(feat)) * self.max_depth + else: + output = self.relu(self.conv_depth(feat)) + self.min_depth + return output + + @force_fp32(apply_to=("depth_pred",)) + def losses(self, depth_pred, depth_gt): + """Compute depth loss.""" + loss = dict() + depth_pred = resize( + input=depth_pred, size=depth_gt.shape[2:], mode="bilinear", align_corners=self.align_corners, warning=False + ) + if not isinstance(self.loss_decode, nn.ModuleList): + losses_decode = [self.loss_decode] + else: + losses_decode = self.loss_decode + for loss_decode in losses_decode: + if loss_decode.loss_name not in loss: + loss[loss_decode.loss_name] = loss_decode(depth_pred, depth_gt) + else: + loss[loss_decode.loss_name] += loss_decode(depth_pred, depth_gt) + return loss + + def log_images(self, img_path, depth_pred, depth_gt, img_meta): + show_img = copy.deepcopy(img_path.detach().cpu().permute(1, 2, 0)) + show_img = show_img.numpy().astype(np.float32) + show_img = mmcv.imdenormalize( + show_img, + img_meta["img_norm_cfg"]["mean"], + img_meta["img_norm_cfg"]["std"], + img_meta["img_norm_cfg"]["to_rgb"], + ) + show_img = np.clip(show_img, 0, 255) + show_img = show_img.astype(np.uint8) + show_img = show_img[:, :, ::-1] + show_img = show_img.transpose(0, 2, 1) + show_img = show_img.transpose(1, 0, 2) + + depth_pred = depth_pred / torch.max(depth_pred) + depth_gt = depth_gt / torch.max(depth_gt) + + depth_pred_color = copy.deepcopy(depth_pred.detach().cpu()) + depth_gt_color = copy.deepcopy(depth_gt.detach().cpu()) + + return {"img_rgb": show_img, "img_depth_pred": depth_pred_color, "img_depth_gt": depth_gt_color} diff --git a/OpenMidnight/dinov2/eval/depth/models/decode_heads/dpt_head.py b/OpenMidnight/dinov2/eval/depth/models/decode_heads/dpt_head.py new file mode 100644 index 0000000000000000000000000000000000000000..c6c6d9470d78e1d944cc505f97865f026a9458d3 --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/decode_heads/dpt_head.py @@ -0,0 +1,270 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn as nn +from mmcv.cnn import ConvModule, Linear, build_activation_layer +from mmcv.runner import BaseModule + +from ...ops import resize +from ..builder import HEADS +from .decode_head import DepthBaseDecodeHead + + +class Interpolate(nn.Module): + def __init__(self, scale_factor, mode, align_corners=False): + super(Interpolate, self).__init__() + self.interp = nn.functional.interpolate + self.scale_factor = scale_factor + self.mode = mode + self.align_corners = align_corners + + def forward(self, x): + x = self.interp(x, scale_factor=self.scale_factor, mode=self.mode, align_corners=self.align_corners) + return x + + +class HeadDepth(nn.Module): + def __init__(self, features): + super(HeadDepth, self).__init__() + self.head = nn.Sequential( + nn.Conv2d(features, features // 2, kernel_size=3, stride=1, padding=1), + Interpolate(scale_factor=2, mode="bilinear", align_corners=True), + nn.Conv2d(features // 2, 32, kernel_size=3, stride=1, padding=1), + nn.ReLU(), + nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0), + ) + + def forward(self, x): + x = self.head(x) + return x + + +class ReassembleBlocks(BaseModule): + """ViTPostProcessBlock, process cls_token in ViT backbone output and + rearrange the feature vector to feature map. + Args: + in_channels (int): ViT feature channels. Default: 768. + out_channels (List): output channels of each stage. + Default: [96, 192, 384, 768]. + readout_type (str): Type of readout operation. Default: 'ignore'. + patch_size (int): The patch size. Default: 16. + init_cfg (dict, optional): Initialization config dict. Default: None. + """ + + def __init__( + self, in_channels=768, out_channels=[96, 192, 384, 768], readout_type="ignore", patch_size=16, init_cfg=None + ): + super(ReassembleBlocks, self).__init__(init_cfg) + + assert readout_type in ["ignore", "add", "project"] + self.readout_type = readout_type + self.patch_size = patch_size + + self.projects = nn.ModuleList( + [ + ConvModule( + in_channels=in_channels, + out_channels=out_channel, + kernel_size=1, + act_cfg=None, + ) + for out_channel in out_channels + ] + ) + + self.resize_layers = nn.ModuleList( + [ + nn.ConvTranspose2d( + in_channels=out_channels[0], out_channels=out_channels[0], kernel_size=4, stride=4, padding=0 + ), + nn.ConvTranspose2d( + in_channels=out_channels[1], out_channels=out_channels[1], kernel_size=2, stride=2, padding=0 + ), + nn.Identity(), + nn.Conv2d( + in_channels=out_channels[3], out_channels=out_channels[3], kernel_size=3, stride=2, padding=1 + ), + ] + ) + if self.readout_type == "project": + self.readout_projects = nn.ModuleList() + for _ in range(len(self.projects)): + self.readout_projects.append( + nn.Sequential(Linear(2 * in_channels, in_channels), build_activation_layer(dict(type="GELU"))) + ) + + def forward(self, inputs): + assert isinstance(inputs, list) + out = [] + for i, x in enumerate(inputs): + assert len(x) == 2 + x, cls_token = x[0], x[1] + feature_shape = x.shape + if self.readout_type == "project": + x = x.flatten(2).permute((0, 2, 1)) + readout = cls_token.unsqueeze(1).expand_as(x) + x = self.readout_projects[i](torch.cat((x, readout), -1)) + x = x.permute(0, 2, 1).reshape(feature_shape) + elif self.readout_type == "add": + x = x.flatten(2) + cls_token.unsqueeze(-1) + x = x.reshape(feature_shape) + else: + pass + x = self.projects[i](x) + x = self.resize_layers[i](x) + out.append(x) + return out + + +class PreActResidualConvUnit(BaseModule): + """ResidualConvUnit, pre-activate residual unit. + Args: + in_channels (int): number of channels in the input feature map. + act_cfg (dict): dictionary to construct and config activation layer. + norm_cfg (dict): dictionary to construct and config norm layer. + stride (int): stride of the first block. Default: 1 + dilation (int): dilation rate for convs layers. Default: 1. + init_cfg (dict, optional): Initialization config dict. Default: None. + """ + + def __init__(self, in_channels, act_cfg, norm_cfg, stride=1, dilation=1, init_cfg=None): + super(PreActResidualConvUnit, self).__init__(init_cfg) + + self.conv1 = ConvModule( + in_channels, + in_channels, + 3, + stride=stride, + padding=dilation, + dilation=dilation, + norm_cfg=norm_cfg, + act_cfg=act_cfg, + bias=False, + order=("act", "conv", "norm"), + ) + + self.conv2 = ConvModule( + in_channels, + in_channels, + 3, + padding=1, + norm_cfg=norm_cfg, + act_cfg=act_cfg, + bias=False, + order=("act", "conv", "norm"), + ) + + def forward(self, inputs): + inputs_ = inputs.clone() + x = self.conv1(inputs) + x = self.conv2(x) + return x + inputs_ + + +class FeatureFusionBlock(BaseModule): + """FeatureFusionBlock, merge feature map from different stages. + Args: + in_channels (int): Input channels. + act_cfg (dict): The activation config for ResidualConvUnit. + norm_cfg (dict): Config dict for normalization layer. + expand (bool): Whether expand the channels in post process block. + Default: False. + align_corners (bool): align_corner setting for bilinear upsample. + Default: True. + init_cfg (dict, optional): Initialization config dict. Default: None. + """ + + def __init__(self, in_channels, act_cfg, norm_cfg, expand=False, align_corners=True, init_cfg=None): + super(FeatureFusionBlock, self).__init__(init_cfg) + + self.in_channels = in_channels + self.expand = expand + self.align_corners = align_corners + + self.out_channels = in_channels + if self.expand: + self.out_channels = in_channels // 2 + + self.project = ConvModule(self.in_channels, self.out_channels, kernel_size=1, act_cfg=None, bias=True) + + self.res_conv_unit1 = PreActResidualConvUnit(in_channels=self.in_channels, act_cfg=act_cfg, norm_cfg=norm_cfg) + self.res_conv_unit2 = PreActResidualConvUnit(in_channels=self.in_channels, act_cfg=act_cfg, norm_cfg=norm_cfg) + + def forward(self, *inputs): + x = inputs[0] + if len(inputs) == 2: + if x.shape != inputs[1].shape: + res = resize(inputs[1], size=(x.shape[2], x.shape[3]), mode="bilinear", align_corners=False) + else: + res = inputs[1] + x = x + self.res_conv_unit1(res) + x = self.res_conv_unit2(x) + x = resize(x, scale_factor=2, mode="bilinear", align_corners=self.align_corners) + x = self.project(x) + return x + + +@HEADS.register_module() +class DPTHead(DepthBaseDecodeHead): + """Vision Transformers for Dense Prediction. + This head is implemented of `DPT `_. + Args: + embed_dims (int): The embed dimension of the ViT backbone. + Default: 768. + post_process_channels (List): Out channels of post process conv + layers. Default: [96, 192, 384, 768]. + readout_type (str): Type of readout operation. Default: 'ignore'. + patch_size (int): The patch size. Default: 16. + expand_channels (bool): Whether expand the channels in post process + block. Default: False. + """ + + def __init__( + self, + embed_dims=768, + post_process_channels=[96, 192, 384, 768], + readout_type="ignore", + patch_size=16, + expand_channels=False, + **kwargs + ): + super(DPTHead, self).__init__(**kwargs) + + self.in_channels = self.in_channels + self.expand_channels = expand_channels + self.reassemble_blocks = ReassembleBlocks(embed_dims, post_process_channels, readout_type, patch_size) + + self.post_process_channels = [ + channel * math.pow(2, i) if expand_channels else channel for i, channel in enumerate(post_process_channels) + ] + self.convs = nn.ModuleList() + for channel in self.post_process_channels: + self.convs.append(ConvModule(channel, self.channels, kernel_size=3, padding=1, act_cfg=None, bias=False)) + self.fusion_blocks = nn.ModuleList() + for _ in range(len(self.convs)): + self.fusion_blocks.append(FeatureFusionBlock(self.channels, self.act_cfg, self.norm_cfg)) + self.fusion_blocks[0].res_conv_unit1 = None + self.project = ConvModule(self.channels, self.channels, kernel_size=3, padding=1, norm_cfg=self.norm_cfg) + self.num_fusion_blocks = len(self.fusion_blocks) + self.num_reassemble_blocks = len(self.reassemble_blocks.resize_layers) + self.num_post_process_channels = len(self.post_process_channels) + assert self.num_fusion_blocks == self.num_reassemble_blocks + assert self.num_reassemble_blocks == self.num_post_process_channels + self.conv_depth = HeadDepth(self.channels) + + def forward(self, inputs, img_metas): + assert len(inputs) == self.num_reassemble_blocks + x = [inp for inp in inputs] + x = self.reassemble_blocks(x) + x = [self.convs[i](feature) for i, feature in enumerate(x)] + out = self.fusion_blocks[0](x[-1]) + for i in range(1, len(self.fusion_blocks)): + out = self.fusion_blocks[i](out, x[-(i + 1)]) + out = self.project(out) + out = self.depth_pred(out) + return out diff --git a/OpenMidnight/dinov2/eval/depth/models/decode_heads/linear_head.py b/OpenMidnight/dinov2/eval/depth/models/decode_heads/linear_head.py new file mode 100644 index 0000000000000000000000000000000000000000..3da1436f6a3f0bcc389d74ed86d44d455d2f7a87 --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/decode_heads/linear_head.py @@ -0,0 +1,89 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn + +from ...ops import resize +from ..builder import HEADS +from .decode_head import DepthBaseDecodeHead + + +@HEADS.register_module() +class BNHead(DepthBaseDecodeHead): + """Just a batchnorm.""" + + def __init__(self, input_transform="resize_concat", in_index=(0, 1, 2, 3), upsample=1, **kwargs): + super().__init__(**kwargs) + self.input_transform = input_transform + self.in_index = in_index + self.upsample = upsample + # self.bn = nn.SyncBatchNorm(self.in_channels) + if self.classify: + self.conv_depth = nn.Conv2d(self.channels, self.n_bins, kernel_size=1, padding=0, stride=1) + else: + self.conv_depth = nn.Conv2d(self.channels, 1, kernel_size=1, padding=0, stride=1) + + def _transform_inputs(self, inputs): + """Transform inputs for decoder. + Args: + inputs (list[Tensor]): List of multi-level img features. + Returns: + Tensor: The transformed inputs + """ + + if "concat" in self.input_transform: + inputs = [inputs[i] for i in self.in_index] + if "resize" in self.input_transform: + inputs = [ + resize( + input=x, + size=[s * self.upsample for s in inputs[0].shape[2:]], + mode="bilinear", + align_corners=self.align_corners, + ) + for x in inputs + ] + inputs = torch.cat(inputs, dim=1) + elif self.input_transform == "multiple_select": + inputs = [inputs[i] for i in self.in_index] + else: + inputs = inputs[self.in_index] + + return inputs + + def _forward_feature(self, inputs, img_metas=None, **kwargs): + """Forward function for feature maps before classifying each pixel with + ``self.cls_seg`` fc. + Args: + inputs (list[Tensor]): List of multi-level img features. + Returns: + feats (Tensor): A tensor of shape (batch_size, self.channels, + H, W) which is feature map for last layer of decoder head. + """ + # accept lists (for cls token) + inputs = list(inputs) + for i, x in enumerate(inputs): + if len(x) == 2: + x, cls_token = x[0], x[1] + if len(x.shape) == 2: + x = x[:, :, None, None] + cls_token = cls_token[:, :, None, None].expand_as(x) + inputs[i] = torch.cat((x, cls_token), 1) + else: + x = x[0] + if len(x.shape) == 2: + x = x[:, :, None, None] + inputs[i] = x + x = self._transform_inputs(inputs) + # feats = self.bn(x) + return x + + def forward(self, inputs, img_metas=None, **kwargs): + """Forward function.""" + output = self._forward_feature(inputs, img_metas=img_metas, **kwargs) + output = self.depth_pred(output) + + return output diff --git a/OpenMidnight/dinov2/eval/depth/models/depther/__init__.py b/OpenMidnight/dinov2/eval/depth/models/depther/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..be99743bf6c773d05f2b74524116e368c0cfcba0 --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/depther/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .base import BaseDepther +from .encoder_decoder import DepthEncoderDecoder diff --git a/OpenMidnight/dinov2/eval/depth/models/depther/base.py b/OpenMidnight/dinov2/eval/depth/models/depther/base.py new file mode 100644 index 0000000000000000000000000000000000000000..e133a825a888167f90d95d67803609d6cac7ff55 --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/depther/base.py @@ -0,0 +1,194 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from abc import ABCMeta, abstractmethod +from collections import OrderedDict + +import torch +import torch.distributed as dist +from mmcv.runner import BaseModule, auto_fp16 + + +class BaseDepther(BaseModule, metaclass=ABCMeta): + """Base class for depther.""" + + def __init__(self, init_cfg=None): + super(BaseDepther, self).__init__(init_cfg) + self.fp16_enabled = False + + @property + def with_neck(self): + """bool: whether the depther has neck""" + return hasattr(self, "neck") and self.neck is not None + + @property + def with_auxiliary_head(self): + """bool: whether the depther has auxiliary head""" + return hasattr(self, "auxiliary_head") and self.auxiliary_head is not None + + @property + def with_decode_head(self): + """bool: whether the depther has decode head""" + return hasattr(self, "decode_head") and self.decode_head is not None + + @abstractmethod + def extract_feat(self, imgs): + """Placeholder for extract features from images.""" + pass + + @abstractmethod + def encode_decode(self, img, img_metas): + """Placeholder for encode images with backbone and decode into a + semantic depth map of the same size as input.""" + pass + + @abstractmethod + def forward_train(self, imgs, img_metas, **kwargs): + """Placeholder for Forward function for training.""" + pass + + @abstractmethod + def simple_test(self, img, img_meta, **kwargs): + """Placeholder for single image test.""" + pass + + @abstractmethod + def aug_test(self, imgs, img_metas, **kwargs): + """Placeholder for augmentation test.""" + pass + + def forward_test(self, imgs, img_metas, **kwargs): + """ + Args: + imgs (List[Tensor]): the outer list indicates test-time + augmentations and inner Tensor should have a shape NxCxHxW, + which contains all images in the batch. + img_metas (List[List[dict]]): the outer list indicates test-time + augs (multiscale, flip, etc.) and the inner list indicates + images in a batch. + """ + for var, name in [(imgs, "imgs"), (img_metas, "img_metas")]: + if not isinstance(var, list): + raise TypeError(f"{name} must be a list, but got " f"{type(var)}") + num_augs = len(imgs) + if num_augs != len(img_metas): + raise ValueError(f"num of augmentations ({len(imgs)}) != " f"num of image meta ({len(img_metas)})") + # all images in the same aug batch all of the same ori_shape and pad + # shape + for img_meta in img_metas: + ori_shapes = [_["ori_shape"] for _ in img_meta] + assert all(shape == ori_shapes[0] for shape in ori_shapes) + img_shapes = [_["img_shape"] for _ in img_meta] + assert all(shape == img_shapes[0] for shape in img_shapes) + pad_shapes = [_["pad_shape"] for _ in img_meta] + assert all(shape == pad_shapes[0] for shape in pad_shapes) + + if num_augs == 1: + return self.simple_test(imgs[0], img_metas[0], **kwargs) + else: + return self.aug_test(imgs, img_metas, **kwargs) + + @auto_fp16(apply_to=("img",)) + def forward(self, img, img_metas, return_loss=True, **kwargs): + """Calls either :func:`forward_train` or :func:`forward_test` depending + on whether ``return_loss`` is ``True``. + + Note this setting will change the expected inputs. When + ``return_loss=True``, img and img_meta are single-nested (i.e. Tensor + and List[dict]), and when ``resturn_loss=False``, img and img_meta + should be double nested (i.e. List[Tensor], List[List[dict]]), with + the outer list indicating test time augmentations. + """ + if return_loss: + return self.forward_train(img, img_metas, **kwargs) + else: + return self.forward_test(img, img_metas, **kwargs) + + def train_step(self, data_batch, optimizer, **kwargs): + """The iteration step during training. + + This method defines an iteration step during training, except for the + back propagation and optimizer updating, which are done in an optimizer + hook. Note that in some complicated cases or models, the whole process + including back propagation and optimizer updating is also defined in + this method, such as GAN. + + Args: + data (dict): The output of dataloader. + optimizer (:obj:`torch.optim.Optimizer` | dict): The optimizer of + runner is passed to ``train_step()``. This argument is unused + and reserved. + + Returns: + dict: It should contain at least 3 keys: ``loss``, ``log_vars``, + ``num_samples``. + ``loss`` is a tensor for back propagation, which can be a + weighted sum of multiple losses. + ``log_vars`` contains all the variables to be sent to the + logger. + ``num_samples`` indicates the batch size (when the model is + DDP, it means the batch size on each GPU), which is used for + averaging the logs. + """ + losses = self(**data_batch) + + # split losses and images + real_losses = {} + log_imgs = {} + for k, v in losses.items(): + if "img" in k: + log_imgs[k] = v + else: + real_losses[k] = v + + loss, log_vars = self._parse_losses(real_losses) + + outputs = dict(loss=loss, log_vars=log_vars, num_samples=len(data_batch["img_metas"]), log_imgs=log_imgs) + + return outputs + + def val_step(self, data_batch, **kwargs): + """The iteration step during validation. + + This method shares the same signature as :func:`train_step`, but used + during val epochs. Note that the evaluation after training epochs is + not implemented with this method, but an evaluation hook. + """ + output = self(**data_batch, **kwargs) + return output + + @staticmethod + def _parse_losses(losses): + """Parse the raw outputs (losses) of the network. + + Args: + losses (dict): Raw output of the network, which usually contain + losses and other necessary information. + + Returns: + tuple[Tensor, dict]: (loss, log_vars), loss is the loss tensor + which may be a weighted sum of all losses, log_vars contains + all the variables to be sent to the logger. + """ + log_vars = OrderedDict() + for loss_name, loss_value in losses.items(): + if isinstance(loss_value, torch.Tensor): + log_vars[loss_name] = loss_value.mean() + elif isinstance(loss_value, list): + log_vars[loss_name] = sum(_loss.mean() for _loss in loss_value) + else: + raise TypeError(f"{loss_name} is not a tensor or list of tensors") + + loss = sum(_value for _key, _value in log_vars.items() if "loss" in _key) + + log_vars["loss"] = loss + for loss_name, loss_value in log_vars.items(): + # reduce loss when distributed training + if dist.is_available() and dist.is_initialized(): + loss_value = loss_value.data.clone() + dist.all_reduce(loss_value.div_(dist.get_world_size())) + log_vars[loss_name] = loss_value.item() + + return loss, log_vars diff --git a/OpenMidnight/dinov2/eval/depth/models/depther/encoder_decoder.py b/OpenMidnight/dinov2/eval/depth/models/depther/encoder_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..6b0ec2dd314fdf8ccf4414d81afb95326b7dc0c9 --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/depther/encoder_decoder.py @@ -0,0 +1,236 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn.functional as F + +from ...models import builder +from ...models.builder import DEPTHER +from ...ops import resize +from .base import BaseDepther + + +def add_prefix(inputs, prefix): + """Add prefix for dict. + + Args: + inputs (dict): The input dict with str keys. + prefix (str): The prefix to add. + + Returns: + + dict: The dict with keys updated with ``prefix``. + """ + + outputs = dict() + for name, value in inputs.items(): + outputs[f"{prefix}.{name}"] = value + + return outputs + + +@DEPTHER.register_module() +class DepthEncoderDecoder(BaseDepther): + """Encoder Decoder depther. + + EncoderDecoder typically consists of backbone, (neck) and decode_head. + """ + + def __init__(self, backbone, decode_head, neck=None, train_cfg=None, test_cfg=None, pretrained=None, init_cfg=None): + super(DepthEncoderDecoder, self).__init__(init_cfg) + if pretrained is not None: + assert backbone.get("pretrained") is None, "both backbone and depther set pretrained weight" + backbone.pretrained = pretrained + self.backbone = builder.build_backbone(backbone) + self._init_decode_head(decode_head) + + if neck is not None: + self.neck = builder.build_neck(neck) + + self.train_cfg = train_cfg + self.test_cfg = test_cfg + + assert self.with_decode_head + + def _init_decode_head(self, decode_head): + """Initialize ``decode_head``""" + self.decode_head = builder.build_head(decode_head) + self.align_corners = self.decode_head.align_corners + + def extract_feat(self, img): + """Extract features from images.""" + x = self.backbone(img) + if self.with_neck: + x = self.neck(x) + return x + + def encode_decode(self, img, img_metas, rescale=True, size=None): + """Encode images with backbone and decode into a depth estimation + map of the same size as input.""" + x = self.extract_feat(img) + out = self._decode_head_forward_test(x, img_metas) + # crop the pred depth to the certain range. + out = torch.clamp(out, min=self.decode_head.min_depth, max=self.decode_head.max_depth) + if rescale: + if size is None: + if img_metas is not None: + size = img_metas[0]["ori_shape"][:2] + else: + size = img.shape[2:] + out = resize(input=out, size=size, mode="bilinear", align_corners=self.align_corners) + return out + + def _decode_head_forward_train(self, img, x, img_metas, depth_gt, **kwargs): + """Run forward function and calculate loss for decode head in + training.""" + losses = dict() + loss_decode = self.decode_head.forward_train(img, x, img_metas, depth_gt, self.train_cfg, **kwargs) + losses.update(add_prefix(loss_decode, "decode")) + return losses + + def _decode_head_forward_test(self, x, img_metas): + """Run forward function and calculate loss for decode head in + inference.""" + depth_pred = self.decode_head.forward_test(x, img_metas, self.test_cfg) + return depth_pred + + def forward_dummy(self, img): + """Dummy forward function.""" + depth = self.encode_decode(img, None) + + return depth + + def forward_train(self, img, img_metas, depth_gt, **kwargs): + """Forward function for training. + + Args: + img (Tensor): Input images. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + depth_gt (Tensor): Depth gt + used if the architecture supports depth estimation task. + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + + x = self.extract_feat(img) + + losses = dict() + + # the last of x saves the info from neck + loss_decode = self._decode_head_forward_train(img, x, img_metas, depth_gt, **kwargs) + + losses.update(loss_decode) + + return losses + + def whole_inference(self, img, img_meta, rescale, size=None): + """Inference with full image.""" + depth_pred = self.encode_decode(img, img_meta, rescale, size=size) + + return depth_pred + + def slide_inference(self, img, img_meta, rescale): + """Inference by sliding-window with overlap. + + If h_crop > h_img or w_crop > w_img, the small patch will be used to + decode without padding. + """ + + h_stride, w_stride = self.test_cfg.stride + h_crop, w_crop = self.test_cfg.crop_size + batch_size, _, h_img, w_img = img.size() + h_grids = max(h_img - h_crop + h_stride - 1, 0) // h_stride + 1 + w_grids = max(w_img - w_crop + w_stride - 1, 0) // w_stride + 1 + preds = img.new_zeros((batch_size, 1, h_img, w_img)) + count_mat = img.new_zeros((batch_size, 1, h_img, w_img)) + for h_idx in range(h_grids): + for w_idx in range(w_grids): + y1 = h_idx * h_stride + x1 = w_idx * w_stride + y2 = min(y1 + h_crop, h_img) + x2 = min(x1 + w_crop, w_img) + y1 = max(y2 - h_crop, 0) + x1 = max(x2 - w_crop, 0) + crop_img = img[:, :, y1:y2, x1:x2] + depth_pred = self.encode_decode(crop_img, img_meta, rescale) + preds += F.pad(depth_pred, (int(x1), int(preds.shape[3] - x2), int(y1), int(preds.shape[2] - y2))) + + count_mat[:, :, y1:y2, x1:x2] += 1 + assert (count_mat == 0).sum() == 0 + if torch.onnx.is_in_onnx_export(): + # cast count_mat to constant while exporting to ONNX + count_mat = torch.from_numpy(count_mat.cpu().detach().numpy()).to(device=img.device) + preds = preds / count_mat + return preds + + def inference(self, img, img_meta, rescale, size=None): + """Inference with slide/whole style. + + Args: + img (Tensor): The input image of shape (N, 3, H, W). + img_meta (dict): Image info dict where each dict has: 'img_shape', + 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + rescale (bool): Whether rescale back to original shape. + + Returns: + Tensor: The output depth map. + """ + + assert self.test_cfg.mode in ["slide", "whole"] + ori_shape = img_meta[0]["ori_shape"] + assert all(_["ori_shape"] == ori_shape for _ in img_meta) + if self.test_cfg.mode == "slide": + depth_pred = self.slide_inference(img, img_meta, rescale) + else: + depth_pred = self.whole_inference(img, img_meta, rescale, size=size) + output = depth_pred + flip = img_meta[0]["flip"] + if flip: + flip_direction = img_meta[0]["flip_direction"] + assert flip_direction in ["horizontal", "vertical"] + if flip_direction == "horizontal": + output = output.flip(dims=(3,)) + elif flip_direction == "vertical": + output = output.flip(dims=(2,)) + + return output + + def simple_test(self, img, img_meta, rescale=True): + """Simple test with single image.""" + depth_pred = self.inference(img, img_meta, rescale) + if torch.onnx.is_in_onnx_export(): + # our inference backend only support 4D output + depth_pred = depth_pred.unsqueeze(0) + return depth_pred + depth_pred = depth_pred.cpu().numpy() + # unravel batch dim + depth_pred = list(depth_pred) + return depth_pred + + def aug_test(self, imgs, img_metas, rescale=True): + """Test with augmentations. + + Only rescale=True is supported. + """ + # aug_test rescale all imgs back to ori_shape for now + assert rescale + # to save memory, we get augmented depth logit inplace + depth_pred = self.inference(imgs[0], img_metas[0], rescale) + for i in range(1, len(imgs)): + cur_depth_pred = self.inference(imgs[i], img_metas[i], rescale, size=depth_pred.shape[-2:]) + depth_pred += cur_depth_pred + depth_pred /= len(imgs) + depth_pred = depth_pred.cpu().numpy() + # unravel batch dim + depth_pred = list(depth_pred) + return depth_pred diff --git a/OpenMidnight/dinov2/eval/depth/models/losses/__init__.py b/OpenMidnight/dinov2/eval/depth/models/losses/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2f86242e342776da2e0acc61150d15a8d58ff1e0 --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/losses/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .gradientloss import GradientLoss +from .sigloss import SigLoss diff --git a/OpenMidnight/dinov2/eval/depth/models/losses/gradientloss.py b/OpenMidnight/dinov2/eval/depth/models/losses/gradientloss.py new file mode 100644 index 0000000000000000000000000000000000000000..1599878a6b70cdff4f8467e1e875f0d13ea89eca --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/losses/gradientloss.py @@ -0,0 +1,69 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn + +from ...models.builder import LOSSES + + +@LOSSES.register_module() +class GradientLoss(nn.Module): + """GradientLoss. + + Adapted from https://www.cs.cornell.edu/projects/megadepth/ + + Args: + valid_mask (bool): Whether filter invalid gt (gt > 0). Default: True. + loss_weight (float): Weight of the loss. Default: 1.0. + max_depth (int): When filtering invalid gt, set a max threshold. Default: None. + """ + + def __init__(self, valid_mask=True, loss_weight=1.0, max_depth=None, loss_name="loss_grad"): + super(GradientLoss, self).__init__() + self.valid_mask = valid_mask + self.loss_weight = loss_weight + self.max_depth = max_depth + self.loss_name = loss_name + + self.eps = 0.001 # avoid grad explode + + def gradientloss(self, input, target): + input_downscaled = [input] + [input[:: 2 * i, :: 2 * i] for i in range(1, 4)] + target_downscaled = [target] + [target[:: 2 * i, :: 2 * i] for i in range(1, 4)] + + gradient_loss = 0 + for input, target in zip(input_downscaled, target_downscaled): + if self.valid_mask: + mask = target > 0 + if self.max_depth is not None: + mask = torch.logical_and(target > 0, target <= self.max_depth) + N = torch.sum(mask) + else: + mask = torch.ones_like(target) + N = input.numel() + input_log = torch.log(input + self.eps) + target_log = torch.log(target + self.eps) + log_d_diff = input_log - target_log + + log_d_diff = torch.mul(log_d_diff, mask) + + v_gradient = torch.abs(log_d_diff[0:-2, :] - log_d_diff[2:, :]) + v_mask = torch.mul(mask[0:-2, :], mask[2:, :]) + v_gradient = torch.mul(v_gradient, v_mask) + + h_gradient = torch.abs(log_d_diff[:, 0:-2] - log_d_diff[:, 2:]) + h_mask = torch.mul(mask[:, 0:-2], mask[:, 2:]) + h_gradient = torch.mul(h_gradient, h_mask) + + gradient_loss += (torch.sum(h_gradient) + torch.sum(v_gradient)) / N + + return gradient_loss + + def forward(self, depth_pred, depth_gt): + """Forward function.""" + + gradient_loss = self.loss_weight * self.gradientloss(depth_pred, depth_gt) + return gradient_loss diff --git a/OpenMidnight/dinov2/eval/depth/models/losses/sigloss.py b/OpenMidnight/dinov2/eval/depth/models/losses/sigloss.py new file mode 100644 index 0000000000000000000000000000000000000000..e12fad3e6151e4b975dd055193fdaec0206d4a14 --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/models/losses/sigloss.py @@ -0,0 +1,65 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn + +from ...models.builder import LOSSES + + +@LOSSES.register_module() +class SigLoss(nn.Module): + """SigLoss. + + This follows `AdaBins `_. + + Args: + valid_mask (bool): Whether filter invalid gt (gt > 0). Default: True. + loss_weight (float): Weight of the loss. Default: 1.0. + max_depth (int): When filtering invalid gt, set a max threshold. Default: None. + warm_up (bool): A simple warm up stage to help convergence. Default: False. + warm_iter (int): The number of warm up stage. Default: 100. + """ + + def __init__( + self, valid_mask=True, loss_weight=1.0, max_depth=None, warm_up=False, warm_iter=100, loss_name="sigloss" + ): + super(SigLoss, self).__init__() + self.valid_mask = valid_mask + self.loss_weight = loss_weight + self.max_depth = max_depth + self.loss_name = loss_name + + self.eps = 0.001 # avoid grad explode + + # HACK: a hack implementation for warmup sigloss + self.warm_up = warm_up + self.warm_iter = warm_iter + self.warm_up_counter = 0 + + def sigloss(self, input, target): + if self.valid_mask: + valid_mask = target > 0 + if self.max_depth is not None: + valid_mask = torch.logical_and(target > 0, target <= self.max_depth) + input = input[valid_mask] + target = target[valid_mask] + + if self.warm_up: + if self.warm_up_counter < self.warm_iter: + g = torch.log(input + self.eps) - torch.log(target + self.eps) + g = 0.15 * torch.pow(torch.mean(g), 2) + self.warm_up_counter += 1 + return torch.sqrt(g) + + g = torch.log(input + self.eps) - torch.log(target + self.eps) + Dg = torch.var(g) + 0.15 * torch.pow(torch.mean(g), 2) + return torch.sqrt(Dg) + + def forward(self, depth_pred, depth_gt): + """Forward function.""" + + loss_depth = self.loss_weight * self.sigloss(depth_pred, depth_gt) + return loss_depth diff --git a/OpenMidnight/dinov2/eval/depth/ops/__init__.py b/OpenMidnight/dinov2/eval/depth/ops/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..78181c29581a281b5f42cf12078636aaeb43b5a5 --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/ops/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .wrappers import resize diff --git a/OpenMidnight/dinov2/eval/depth/ops/wrappers.py b/OpenMidnight/dinov2/eval/depth/ops/wrappers.py new file mode 100644 index 0000000000000000000000000000000000000000..15880ee0cb7652d4b41c489b927bf6a156b40e5e --- /dev/null +++ b/OpenMidnight/dinov2/eval/depth/ops/wrappers.py @@ -0,0 +1,28 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import warnings + +import torch.nn.functional as F + + +def resize(input, size=None, scale_factor=None, mode="nearest", align_corners=None, warning=False): + if warning: + if size is not None and align_corners: + input_h, input_w = tuple(int(x) for x in input.shape[2:]) + output_h, output_w = tuple(int(x) for x in size) + if output_h > input_h or output_w > output_h: + if ( + (output_h > 1 and output_w > 1 and input_h > 1 and input_w > 1) + and (output_h - 1) % (input_h - 1) + and (output_w - 1) % (input_w - 1) + ): + warnings.warn( + f"When align_corners={align_corners}, " + "the output would more aligned if " + f"input size {(input_h, input_w)} is `x+1` and " + f"out size {(output_h, output_w)} is `nx+1`" + ) + return F.interpolate(input, size, scale_factor, mode, align_corners) diff --git a/OpenMidnight/dinov2/eval/knn.py b/OpenMidnight/dinov2/eval/knn.py new file mode 100644 index 0000000000000000000000000000000000000000..f3a4845da1313a6db6b8345bb9a98230fcd24acf --- /dev/null +++ b/OpenMidnight/dinov2/eval/knn.py @@ -0,0 +1,404 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import argparse +from functools import partial +import json +import logging +import os +import sys +from typing import List, Optional + +import torch +from torch.nn.functional import one_hot, softmax + +import dinov2.distributed as distributed +from dinov2.data import SamplerType, make_data_loader, make_dataset +from dinov2.data.transforms import make_classification_eval_transform +from dinov2.eval.metrics import AccuracyAveraging, build_topk_accuracy_metric +from dinov2.eval.setup import get_args_parser as get_setup_args_parser +from dinov2.eval.setup import setup_and_build_model +from dinov2.eval.utils import ModelWithNormalize, evaluate, extract_features + + +logger = logging.getLogger("dinov2") + + +def get_args_parser( + description: Optional[str] = None, + parents: Optional[List[argparse.ArgumentParser]] = None, + add_help: bool = True, +): + parents = parents or [] + setup_args_parser = get_setup_args_parser(parents=parents, add_help=False) + parents = [setup_args_parser] + parser = argparse.ArgumentParser( + description=description, + parents=parents, + add_help=add_help, + ) + parser.add_argument( + "--train-dataset", + dest="train_dataset_str", + type=str, + help="Training dataset", + ) + parser.add_argument( + "--val-dataset", + dest="val_dataset_str", + type=str, + help="Validation dataset", + ) + parser.add_argument( + "--nb_knn", + nargs="+", + type=int, + help="Number of NN to use. 20 is usually working the best.", + ) + parser.add_argument( + "--temperature", + type=float, + help="Temperature used in the voting coefficient", + ) + parser.add_argument( + "--gather-on-cpu", + action="store_true", + help="Whether to gather the train features on cpu, slower" + "but useful to avoid OOM for large datasets (e.g. ImageNet22k).", + ) + parser.add_argument( + "--batch-size", + type=int, + help="Batch size.", + ) + parser.add_argument( + "--n-per-class-list", + nargs="+", + type=int, + help="Number to take per class", + ) + parser.add_argument( + "--n-tries", + type=int, + help="Number of tries", + ) + parser.set_defaults( + train_dataset_str="ImageNet:split=TRAIN", + val_dataset_str="ImageNet:split=VAL", + nb_knn=[10, 20, 100, 200], + temperature=0.07, + batch_size=256, + n_per_class_list=[-1], + n_tries=1, + ) + return parser + + +class KnnModule(torch.nn.Module): + """ + Gets knn of test features from all processes on a chunk of the train features + + Each rank gets a chunk of the train features as well as a chunk of the test features. + In `compute_neighbors`, for each rank one after the other, its chunk of test features + is sent to all devices, partial knns are computed with each chunk of train features + then collated back on the original device. + """ + + def __init__(self, train_features, train_labels, nb_knn, T, device, num_classes=1000): + super().__init__() + + self.global_rank = distributed.get_global_rank() + self.global_size = distributed.get_global_size() + + self.device = device + self.train_features_rank_T = train_features.chunk(self.global_size)[self.global_rank].T.to(self.device) + self.candidates = train_labels.chunk(self.global_size)[self.global_rank].view(1, -1).to(self.device) + + self.nb_knn = nb_knn + self.max_k = max(self.nb_knn) + self.T = T + self.num_classes = num_classes + + def _get_knn_sims_and_labels(self, similarity, train_labels): + topk_sims, indices = similarity.topk(self.max_k, largest=True, sorted=True) + neighbors_labels = torch.gather(train_labels, 1, indices) + return topk_sims, neighbors_labels + + def _similarity_for_rank(self, features_rank, source_rank): + # Send the features from `source_rank` to all ranks + broadcast_shape = torch.tensor(features_rank.shape).to(self.device) + torch.distributed.broadcast(broadcast_shape, source_rank) + + broadcasted = features_rank + if self.global_rank != source_rank: + broadcasted = torch.zeros(*broadcast_shape, dtype=features_rank.dtype, device=self.device) + torch.distributed.broadcast(broadcasted, source_rank) + + # Compute the neighbors for `source_rank` among `train_features_rank_T` + similarity_rank = torch.mm(broadcasted, self.train_features_rank_T) + candidate_labels = self.candidates.expand(len(similarity_rank), -1) + return self._get_knn_sims_and_labels(similarity_rank, candidate_labels) + + def _gather_all_knn_for_rank(self, topk_sims, neighbors_labels, target_rank): + # Gather all neighbors for `target_rank` + topk_sims_rank = retrieved_rank = None + if self.global_rank == target_rank: + topk_sims_rank = [torch.zeros_like(topk_sims) for _ in range(self.global_size)] + retrieved_rank = [torch.zeros_like(neighbors_labels) for _ in range(self.global_size)] + + torch.distributed.gather(topk_sims, topk_sims_rank, dst=target_rank) + torch.distributed.gather(neighbors_labels, retrieved_rank, dst=target_rank) + + if self.global_rank == target_rank: + # Perform a second top-k on the k * global_size retrieved neighbors + topk_sims_rank = torch.cat(topk_sims_rank, dim=1) + retrieved_rank = torch.cat(retrieved_rank, dim=1) + results = self._get_knn_sims_and_labels(topk_sims_rank, retrieved_rank) + return results + return None + + def compute_neighbors(self, features_rank): + for rank in range(self.global_size): + topk_sims, neighbors_labels = self._similarity_for_rank(features_rank, rank) + results = self._gather_all_knn_for_rank(topk_sims, neighbors_labels, rank) + if results is not None: + topk_sims_rank, neighbors_labels_rank = results + return topk_sims_rank, neighbors_labels_rank + + def forward(self, features_rank): + """ + Compute the results on all values of `self.nb_knn` neighbors from the full `self.max_k` + """ + assert all(k <= self.max_k for k in self.nb_knn) + + topk_sims, neighbors_labels = self.compute_neighbors(features_rank) + batch_size = neighbors_labels.shape[0] + topk_sims_transform = softmax(topk_sims / self.T, 1) + matmul = torch.mul( + one_hot(neighbors_labels, num_classes=self.num_classes), + topk_sims_transform.view(batch_size, -1, 1), + ) + probas_for_k = {k: torch.sum(matmul[:, :k, :], 1) for k in self.nb_knn} + return probas_for_k + + +class DictKeysModule(torch.nn.Module): + def __init__(self, keys): + super().__init__() + self.keys = keys + + def forward(self, features_dict, targets): + for k in self.keys: + features_dict = features_dict[k] + return {"preds": features_dict, "target": targets} + + +def create_module_dict(*, module, n_per_class_list, n_tries, nb_knn, train_features, train_labels): + modules = {} + mapping = create_class_indices_mapping(train_labels) + for npc in n_per_class_list: + if npc < 0: # Only one try needed when using the full data + full_module = module( + train_features=train_features, + train_labels=train_labels, + nb_knn=nb_knn, + ) + modules["full"] = ModuleDictWithForward({"1": full_module}) + continue + all_tries = {} + for t in range(n_tries): + final_indices = filter_train(mapping, npc, seed=t) + k_list = list(set(nb_knn + [npc])) + k_list = sorted([el for el in k_list if el <= npc]) + all_tries[str(t)] = module( + train_features=train_features[final_indices], + train_labels=train_labels[final_indices], + nb_knn=k_list, + ) + modules[f"{npc} per class"] = ModuleDictWithForward(all_tries) + + return ModuleDictWithForward(modules) + + +def filter_train(mapping, n_per_class, seed): + torch.manual_seed(seed) + final_indices = [] + for k in mapping.keys(): + index = torch.randperm(len(mapping[k]))[:n_per_class] + final_indices.append(mapping[k][index]) + return torch.cat(final_indices).squeeze() + + +def create_class_indices_mapping(labels): + unique_labels, inverse = torch.unique(labels, return_inverse=True) + mapping = {unique_labels[i]: (inverse == i).nonzero() for i in range(len(unique_labels))} + return mapping + + +class ModuleDictWithForward(torch.nn.ModuleDict): + def forward(self, *args, **kwargs): + return {k: module(*args, **kwargs) for k, module in self._modules.items()} + + +def eval_knn( + model, + train_dataset, + val_dataset, + accuracy_averaging, + nb_knn, + temperature, + batch_size, + num_workers, + gather_on_cpu, + n_per_class_list=[-1], + n_tries=1, +): + model = ModelWithNormalize(model) + + logger.info("Extracting features for train set...") + train_features, train_labels = extract_features( + model, train_dataset, batch_size, num_workers, gather_on_cpu=gather_on_cpu + ) + logger.info(f"Train features created, shape {train_features.shape}.") + + val_dataloader = make_data_loader( + dataset=val_dataset, + batch_size=batch_size, + num_workers=num_workers, + sampler_type=SamplerType.DISTRIBUTED, + drop_last=False, + shuffle=False, + persistent_workers=True, + ) + num_classes = train_labels.max() + 1 + metric_collection = build_topk_accuracy_metric(accuracy_averaging, num_classes=num_classes) + + device = torch.cuda.current_device() + partial_module = partial(KnnModule, T=temperature, device=device, num_classes=num_classes) + knn_module_dict = create_module_dict( + module=partial_module, + n_per_class_list=n_per_class_list, + n_tries=n_tries, + nb_knn=nb_knn, + train_features=train_features, + train_labels=train_labels, + ) + postprocessors, metrics = {}, {} + for n_per_class, knn_module in knn_module_dict.items(): + for t, knn_try in knn_module.items(): + postprocessors = { + **postprocessors, + **{(n_per_class, t, k): DictKeysModule([n_per_class, t, k]) for k in knn_try.nb_knn}, + } + metrics = {**metrics, **{(n_per_class, t, k): metric_collection.clone() for k in knn_try.nb_knn}} + model_with_knn = torch.nn.Sequential(model, knn_module_dict) + + # ============ evaluation ... ============ + logger.info("Start the k-NN classification.") + _, results_dict = evaluate(model_with_knn, val_dataloader, postprocessors, metrics, device) + + # Averaging the results over the n tries for each value of n_per_class + for n_per_class, knn_module in knn_module_dict.items(): + first_try = list(knn_module.keys())[0] + k_list = knn_module[first_try].nb_knn + for k in k_list: + keys = results_dict[(n_per_class, first_try, k)].keys() # keys are e.g. `top-1` and `top-5` + results_dict[(n_per_class, k)] = { + key: torch.mean(torch.stack([results_dict[(n_per_class, t, k)][key] for t in knn_module.keys()])) + for key in keys + } + for t in knn_module.keys(): + del results_dict[(n_per_class, t, k)] + + return results_dict + + +def eval_knn_with_model( + model, + output_dir, + train_dataset_str="ImageNet:split=TRAIN", + val_dataset_str="ImageNet:split=VAL", + nb_knn=(10, 20, 100, 200), + temperature=0.07, + autocast_dtype=torch.float, + accuracy_averaging=AccuracyAveraging.MEAN_ACCURACY, + transform=None, + gather_on_cpu=False, + batch_size=256, + num_workers=5, + n_per_class_list=[-1], + n_tries=1, +): + transform = transform or make_classification_eval_transform() + + train_dataset = make_dataset( + dataset_str=train_dataset_str, + transform=transform, + ) + val_dataset = make_dataset( + dataset_str=val_dataset_str, + transform=transform, + ) + + with torch.cuda.amp.autocast(dtype=autocast_dtype): + results_dict_knn = eval_knn( + model=model, + train_dataset=train_dataset, + val_dataset=val_dataset, + accuracy_averaging=accuracy_averaging, + nb_knn=nb_knn, + temperature=temperature, + batch_size=batch_size, + num_workers=num_workers, + gather_on_cpu=gather_on_cpu, + n_per_class_list=n_per_class_list, + n_tries=n_tries, + ) + + results_dict = {} + if distributed.is_main_process(): + for knn_ in results_dict_knn.keys(): + top1 = results_dict_knn[knn_]["top-1"].item() * 100.0 + top5 = results_dict_knn[knn_]["top-5"].item() * 100.0 + results_dict[f"{knn_} Top 1"] = top1 + results_dict[f"{knn_} Top 5"] = top5 + logger.info(f"{knn_} classifier result: Top1: {top1:.2f} Top5: {top5:.2f}") + + metrics_file_path = os.path.join(output_dir, "results_eval_knn.json") + with open(metrics_file_path, "a") as f: + for k, v in results_dict.items(): + f.write(json.dumps({k: v}) + "\n") + + if distributed.is_enabled(): + torch.distributed.barrier() + return results_dict + + +def main(args): + model, autocast_dtype = setup_and_build_model(args) + eval_knn_with_model( + model=model, + output_dir=args.output_dir, + train_dataset_str=args.train_dataset_str, + val_dataset_str=args.val_dataset_str, + nb_knn=args.nb_knn, + temperature=args.temperature, + autocast_dtype=autocast_dtype, + accuracy_averaging=AccuracyAveraging.MEAN_ACCURACY, + transform=None, + gather_on_cpu=args.gather_on_cpu, + batch_size=args.batch_size, + num_workers=5, + n_per_class_list=args.n_per_class_list, + n_tries=args.n_tries, + ) + return 0 + + +if __name__ == "__main__": + description = "DINOv2 k-NN evaluation" + args_parser = get_args_parser(description=description) + args = args_parser.parse_args() + sys.exit(main(args)) diff --git a/OpenMidnight/dinov2/eval/linear.py b/OpenMidnight/dinov2/eval/linear.py new file mode 100644 index 0000000000000000000000000000000000000000..1bd4c5de5a041be8a188f007257d1e91b6d6921e --- /dev/null +++ b/OpenMidnight/dinov2/eval/linear.py @@ -0,0 +1,625 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import argparse +from functools import partial +import json +import logging +import os +import sys +from typing import List, Optional + +import numpy as np +import torch +import torch.nn as nn +from torch.nn.parallel import DistributedDataParallel +from fvcore.common.checkpoint import Checkpointer, PeriodicCheckpointer + +from dinov2.data import SamplerType, make_data_loader, make_dataset +from dinov2.data.transforms import make_classification_eval_transform, make_classification_train_transform +import dinov2.distributed as distributed +from dinov2.eval.metrics import MetricType, build_metric +from dinov2.eval.setup import get_args_parser as get_setup_args_parser +from dinov2.eval.setup import setup_and_build_model +from dinov2.eval.utils import ModelWithIntermediateLayers, evaluate +from dinov2.logging import MetricLogger + + +logger = logging.getLogger("dinov2") + + +def get_args_parser( + description: Optional[str] = None, + parents: Optional[List[argparse.ArgumentParser]] = None, + add_help: bool = True, +): + parents = parents or [] + setup_args_parser = get_setup_args_parser(parents=parents, add_help=False) + parents = [setup_args_parser] + parser = argparse.ArgumentParser( + description=description, + parents=parents, + add_help=add_help, + ) + parser.add_argument( + "--train-dataset", + dest="train_dataset_str", + type=str, + help="Training dataset", + ) + parser.add_argument( + "--val-dataset", + dest="val_dataset_str", + type=str, + help="Validation dataset", + ) + parser.add_argument( + "--test-datasets", + dest="test_dataset_strs", + type=str, + nargs="+", + help="Test datasets, none to reuse the validation dataset", + ) + parser.add_argument( + "--epochs", + type=int, + help="Number of training epochs", + ) + parser.add_argument( + "--batch-size", + type=int, + help="Batch Size (per GPU)", + ) + parser.add_argument( + "--num-workers", + type=int, + help="Number de Workers", + ) + parser.add_argument( + "--epoch-length", + type=int, + help="Length of an epoch in number of iterations", + ) + parser.add_argument( + "--save-checkpoint-frequency", + type=int, + help="Number of epochs between two named checkpoint saves.", + ) + parser.add_argument( + "--eval-period-iterations", + type=int, + help="Number of iterations between two evaluations.", + ) + parser.add_argument( + "--learning-rates", + nargs="+", + type=float, + help="Learning rates to grid search.", + ) + parser.add_argument( + "--no-resume", + action="store_true", + help="Whether to not resume from existing checkpoints", + ) + parser.add_argument( + "--val-metric-type", + type=MetricType, + choices=list(MetricType), + help="Validation metric", + ) + parser.add_argument( + "--test-metric-types", + type=MetricType, + choices=list(MetricType), + nargs="+", + help="Evaluation metric", + ) + parser.add_argument( + "--classifier-fpath", + type=str, + help="Path to a file containing pretrained linear classifiers", + ) + parser.add_argument( + "--val-class-mapping-fpath", + type=str, + help="Path to a file containing a mapping to adjust classifier outputs", + ) + parser.add_argument( + "--test-class-mapping-fpaths", + nargs="+", + type=str, + help="Path to a file containing a mapping to adjust classifier outputs", + ) + parser.set_defaults( + train_dataset_str="ImageNet:split=TRAIN", + val_dataset_str="ImageNet:split=VAL", + test_dataset_strs=None, + epochs=10, + batch_size=128, + num_workers=8, + epoch_length=1250, + save_checkpoint_frequency=20, + eval_period_iterations=1250, + learning_rates=[1e-5, 2e-5, 5e-5, 1e-4, 2e-4, 5e-4, 1e-3, 2e-3, 5e-3, 1e-2, 2e-2, 5e-2, 0.1], + val_metric_type=MetricType.MEAN_ACCURACY, + test_metric_types=None, + classifier_fpath=None, + val_class_mapping_fpath=None, + test_class_mapping_fpaths=[None], + ) + return parser + + +def has_ddp_wrapper(m: nn.Module) -> bool: + return isinstance(m, DistributedDataParallel) + + +def remove_ddp_wrapper(m: nn.Module) -> nn.Module: + return m.module if has_ddp_wrapper(m) else m + + +def _pad_and_collate(batch): + maxlen = max(len(targets) for image, targets in batch) + padded_batch = [ + (image, np.pad(targets, (0, maxlen - len(targets)), constant_values=-1)) for image, targets in batch + ] + return torch.utils.data.default_collate(padded_batch) + + +def create_linear_input(x_tokens_list, use_n_blocks, use_avgpool): + intermediate_output = x_tokens_list[-use_n_blocks:] + output = torch.cat([class_token for _, class_token in intermediate_output], dim=-1) + if use_avgpool: + output = torch.cat( + ( + output, + torch.mean(intermediate_output[-1][0], dim=1), # patch tokens + ), + dim=-1, + ) + output = output.reshape(output.shape[0], -1) + return output.float() + + +class LinearClassifier(nn.Module): + """Linear layer to train on top of frozen features""" + + def __init__(self, out_dim, use_n_blocks, use_avgpool, num_classes=1000): + super().__init__() + self.out_dim = out_dim + self.use_n_blocks = use_n_blocks + self.use_avgpool = use_avgpool + self.num_classes = num_classes + self.linear = nn.Linear(out_dim, num_classes) + self.linear.weight.data.normal_(mean=0.0, std=0.01) + self.linear.bias.data.zero_() + + def forward(self, x_tokens_list): + output = create_linear_input(x_tokens_list, self.use_n_blocks, self.use_avgpool) + return self.linear(output) + + +class AllClassifiers(nn.Module): + def __init__(self, classifiers_dict): + super().__init__() + self.classifiers_dict = nn.ModuleDict() + self.classifiers_dict.update(classifiers_dict) + + def forward(self, inputs): + return {k: v.forward(inputs) for k, v in self.classifiers_dict.items()} + + def __len__(self): + return len(self.classifiers_dict) + + +class LinearPostprocessor(nn.Module): + def __init__(self, linear_classifier, class_mapping=None): + super().__init__() + self.linear_classifier = linear_classifier + self.register_buffer("class_mapping", None if class_mapping is None else torch.LongTensor(class_mapping)) + + def forward(self, samples, targets): + preds = self.linear_classifier(samples) + return { + "preds": preds[:, self.class_mapping] if self.class_mapping is not None else preds, + "target": targets, + } + + +def scale_lr(learning_rates, batch_size): + return learning_rates * (batch_size * distributed.get_global_size()) / 256.0 + + +def setup_linear_classifiers(sample_output, n_last_blocks_list, learning_rates, batch_size, num_classes=1000): + linear_classifiers_dict = nn.ModuleDict() + optim_param_groups = [] + for n in n_last_blocks_list: + for avgpool in [False, True]: + for _lr in learning_rates: + lr = scale_lr(_lr, batch_size) + out_dim = create_linear_input(sample_output, use_n_blocks=n, use_avgpool=avgpool).shape[1] + linear_classifier = LinearClassifier( + out_dim, use_n_blocks=n, use_avgpool=avgpool, num_classes=num_classes + ) + linear_classifier = linear_classifier.cuda() + linear_classifiers_dict[ + f"classifier_{n}_blocks_avgpool_{avgpool}_lr_{lr:.5f}".replace(".", "_") + ] = linear_classifier + optim_param_groups.append({"params": linear_classifier.parameters(), "lr": lr}) + + linear_classifiers = AllClassifiers(linear_classifiers_dict) + if distributed.is_enabled(): + linear_classifiers = nn.parallel.DistributedDataParallel(linear_classifiers) + + return linear_classifiers, optim_param_groups + + +@torch.no_grad() +def evaluate_linear_classifiers( + feature_model, + linear_classifiers, + data_loader, + metric_type, + metrics_file_path, + training_num_classes, + iteration, + prefixstring="", + class_mapping=None, + best_classifier_on_val=None, +): + logger.info("running validation !") + + num_classes = len(class_mapping) if class_mapping is not None else training_num_classes + metric = build_metric(metric_type, num_classes=num_classes) + postprocessors = {k: LinearPostprocessor(v, class_mapping) for k, v in linear_classifiers.classifiers_dict.items()} + metrics = {k: metric.clone() for k in linear_classifiers.classifiers_dict} + + _, results_dict_temp = evaluate( + feature_model, + data_loader, + postprocessors, + metrics, + torch.cuda.current_device(), + ) + + logger.info("") + results_dict = {} + max_accuracy = 0 + best_classifier = "" + for i, (classifier_string, metric) in enumerate(results_dict_temp.items()): + logger.info(f"{prefixstring} -- Classifier: {classifier_string} * {metric}") + if ( + best_classifier_on_val is None and metric["top-1"].item() > max_accuracy + ) or classifier_string == best_classifier_on_val: + max_accuracy = metric["top-1"].item() + best_classifier = classifier_string + + results_dict["best_classifier"] = {"name": best_classifier, "accuracy": max_accuracy} + + logger.info(f"best classifier: {results_dict['best_classifier']}") + + if distributed.is_main_process(): + with open(metrics_file_path, "a") as f: + f.write(f"iter: {iteration}\n") + for k, v in results_dict.items(): + f.write(json.dumps({k: v}) + "\n") + f.write("\n") + + return results_dict + + +def eval_linear( + *, + feature_model, + linear_classifiers, + train_data_loader, + val_data_loader, + metrics_file_path, + optimizer, + scheduler, + output_dir, + max_iter, + checkpoint_period, # In number of iter, creates a new file every period + running_checkpoint_period, # Period to update main checkpoint file + eval_period, + metric_type, + training_num_classes, + resume=True, + classifier_fpath=None, + val_class_mapping=None, +): + checkpointer = Checkpointer(linear_classifiers, output_dir, optimizer=optimizer, scheduler=scheduler) + start_iter = checkpointer.resume_or_load(classifier_fpath or "", resume=resume).get("iteration", -1) + 1 + + periodic_checkpointer = PeriodicCheckpointer(checkpointer, checkpoint_period, max_iter=max_iter) + iteration = start_iter + logger.info("Starting training from iteration {}".format(start_iter)) + metric_logger = MetricLogger(delimiter=" ") + header = "Training" + + for data, labels in metric_logger.log_every( + train_data_loader, + 10, + header, + max_iter, + start_iter, + ): + data = data.cuda(non_blocking=True) + labels = labels.cuda(non_blocking=True) + + features = feature_model(data) + outputs = linear_classifiers(features) + + losses = {f"loss_{k}": nn.CrossEntropyLoss()(v, labels) for k, v in outputs.items()} + loss = sum(losses.values()) + + # compute the gradients + optimizer.zero_grad() + loss.backward() + + # step + optimizer.step() + scheduler.step() + + # log + if iteration % 10 == 0: + torch.cuda.synchronize() + metric_logger.update(loss=loss.item()) + metric_logger.update(lr=optimizer.param_groups[0]["lr"]) + print("lr", optimizer.param_groups[0]["lr"]) + + if iteration - start_iter > 5: + if iteration % running_checkpoint_period == 0: + torch.cuda.synchronize() + if distributed.is_main_process(): + logger.info("Checkpointing running_checkpoint") + periodic_checkpointer.save("running_checkpoint_linear_eval", iteration=iteration) + torch.cuda.synchronize() + periodic_checkpointer.step(iteration) + + if eval_period > 0 and (iteration + 1) % eval_period == 0 and iteration != max_iter - 1: + _ = evaluate_linear_classifiers( + feature_model=feature_model, + linear_classifiers=remove_ddp_wrapper(linear_classifiers), + data_loader=val_data_loader, + metrics_file_path=metrics_file_path, + prefixstring=f"ITER: {iteration}", + metric_type=metric_type, + training_num_classes=training_num_classes, + iteration=iteration, + class_mapping=val_class_mapping, + ) + torch.cuda.synchronize() + + iteration = iteration + 1 + + val_results_dict = evaluate_linear_classifiers( + feature_model=feature_model, + linear_classifiers=remove_ddp_wrapper(linear_classifiers), + data_loader=val_data_loader, + metrics_file_path=metrics_file_path, + metric_type=metric_type, + training_num_classes=training_num_classes, + iteration=iteration, + class_mapping=val_class_mapping, + ) + return val_results_dict, feature_model, linear_classifiers, iteration + + +def make_eval_data_loader(test_dataset_str, batch_size, num_workers, metric_type): + test_dataset = make_dataset( + dataset_str=test_dataset_str, + transform=make_classification_eval_transform(), + ) + test_data_loader = make_data_loader( + dataset=test_dataset, + batch_size=batch_size, + num_workers=num_workers, + sampler_type=SamplerType.DISTRIBUTED, + drop_last=False, + shuffle=False, + persistent_workers=False, + collate_fn=_pad_and_collate if metric_type == MetricType.IMAGENET_REAL_ACCURACY else None, + ) + return test_data_loader + + +def test_on_datasets( + feature_model, + linear_classifiers, + test_dataset_strs, + batch_size, + num_workers, + test_metric_types, + metrics_file_path, + training_num_classes, + iteration, + best_classifier_on_val, + prefixstring="", + test_class_mappings=[None], +): + results_dict = {} + for test_dataset_str, class_mapping, metric_type in zip(test_dataset_strs, test_class_mappings, test_metric_types): + logger.info(f"Testing on {test_dataset_str}") + test_data_loader = make_eval_data_loader(test_dataset_str, batch_size, num_workers, metric_type) + dataset_results_dict = evaluate_linear_classifiers( + feature_model, + remove_ddp_wrapper(linear_classifiers), + test_data_loader, + metric_type, + metrics_file_path, + training_num_classes, + iteration, + prefixstring="", + class_mapping=class_mapping, + best_classifier_on_val=best_classifier_on_val, + ) + results_dict[f"{test_dataset_str}_accuracy"] = 100.0 * dataset_results_dict["best_classifier"]["accuracy"] + return results_dict + + +def run_eval_linear( + model, + output_dir, + train_dataset_str, + val_dataset_str, + batch_size, + epochs, + epoch_length, + num_workers, + save_checkpoint_frequency, + eval_period_iterations, + learning_rates, + autocast_dtype, + test_dataset_strs=None, + resume=True, + classifier_fpath=None, + val_class_mapping_fpath=None, + test_class_mapping_fpaths=[None], + val_metric_type=MetricType.MEAN_ACCURACY, + test_metric_types=None, +): + seed = 0 + + if test_dataset_strs is None: + test_dataset_strs = [val_dataset_str] + if test_metric_types is None: + test_metric_types = [val_metric_type] * len(test_dataset_strs) + else: + assert len(test_metric_types) == len(test_dataset_strs) + assert len(test_dataset_strs) == len(test_class_mapping_fpaths) + + train_transform = make_classification_train_transform() + train_dataset = make_dataset( + dataset_str=train_dataset_str, + transform=train_transform, + ) + training_num_classes = len(torch.unique(torch.Tensor(train_dataset.get_targets().astype(int)))) + sampler_type = SamplerType.SHARDED_INFINITE + # sampler_type = SamplerType.INFINITE + + n_last_blocks_list = [1, 4] + n_last_blocks = max(n_last_blocks_list) + autocast_ctx = partial(torch.cuda.amp.autocast, enabled=True, dtype=autocast_dtype) + feature_model = ModelWithIntermediateLayers(model, n_last_blocks, autocast_ctx) + sample_output = feature_model(train_dataset[0][0].unsqueeze(0).cuda()) + + linear_classifiers, optim_param_groups = setup_linear_classifiers( + sample_output, + n_last_blocks_list, + learning_rates, + batch_size, + training_num_classes, + ) + + optimizer = torch.optim.SGD(optim_param_groups, momentum=0.9, weight_decay=0) + max_iter = epochs * epoch_length + scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, max_iter, eta_min=0) + checkpointer = Checkpointer(linear_classifiers, output_dir, optimizer=optimizer, scheduler=scheduler) + start_iter = checkpointer.resume_or_load(classifier_fpath or "", resume=resume).get("iteration", -1) + 1 + train_data_loader = make_data_loader( + dataset=train_dataset, + batch_size=batch_size, + num_workers=num_workers, + shuffle=True, + seed=seed, + sampler_type=sampler_type, + sampler_advance=start_iter, + drop_last=True, + persistent_workers=True, + ) + val_data_loader = make_eval_data_loader(val_dataset_str, batch_size, num_workers, val_metric_type) + + checkpoint_period = save_checkpoint_frequency * epoch_length + + if val_class_mapping_fpath is not None: + logger.info(f"Using class mapping from {val_class_mapping_fpath}") + val_class_mapping = np.load(val_class_mapping_fpath) + else: + val_class_mapping = None + + test_class_mappings = [] + for class_mapping_fpath in test_class_mapping_fpaths: + if class_mapping_fpath is not None and class_mapping_fpath != "None": + logger.info(f"Using class mapping from {class_mapping_fpath}") + class_mapping = np.load(class_mapping_fpath) + else: + class_mapping = None + test_class_mappings.append(class_mapping) + + metrics_file_path = os.path.join(output_dir, "results_eval_linear.json") + val_results_dict, feature_model, linear_classifiers, iteration = eval_linear( + feature_model=feature_model, + linear_classifiers=linear_classifiers, + train_data_loader=train_data_loader, + val_data_loader=val_data_loader, + metrics_file_path=metrics_file_path, + optimizer=optimizer, + scheduler=scheduler, + output_dir=output_dir, + max_iter=max_iter, + checkpoint_period=checkpoint_period, + running_checkpoint_period=epoch_length, + eval_period=eval_period_iterations, + metric_type=val_metric_type, + training_num_classes=training_num_classes, + resume=resume, + val_class_mapping=val_class_mapping, + classifier_fpath=classifier_fpath, + ) + results_dict = {} + if len(test_dataset_strs) > 1 or test_dataset_strs[0] != val_dataset_str: + results_dict = test_on_datasets( + feature_model, + linear_classifiers, + test_dataset_strs, + batch_size, + 0, # num_workers, + test_metric_types, + metrics_file_path, + training_num_classes, + iteration, + val_results_dict["best_classifier"]["name"], + prefixstring="", + test_class_mappings=test_class_mappings, + ) + results_dict["best_classifier"] = val_results_dict["best_classifier"]["name"] + results_dict[f"{val_dataset_str}_accuracy"] = 100.0 * val_results_dict["best_classifier"]["accuracy"] + logger.info("Test Results Dict " + str(results_dict)) + + return results_dict + + +def main(args): + model, autocast_dtype = setup_and_build_model(args) + run_eval_linear( + model=model, + output_dir=args.output_dir, + train_dataset_str=args.train_dataset_str, + val_dataset_str=args.val_dataset_str, + test_dataset_strs=args.test_dataset_strs, + batch_size=args.batch_size, + epochs=args.epochs, + epoch_length=args.epoch_length, + num_workers=args.num_workers, + save_checkpoint_frequency=args.save_checkpoint_frequency, + eval_period_iterations=args.eval_period_iterations, + learning_rates=args.learning_rates, + autocast_dtype=autocast_dtype, + resume=not args.no_resume, + classifier_fpath=args.classifier_fpath, + val_metric_type=args.val_metric_type, + test_metric_types=args.test_metric_types, + val_class_mapping_fpath=args.val_class_mapping_fpath, + test_class_mapping_fpaths=args.test_class_mapping_fpaths, + ) + return 0 + + +if __name__ == "__main__": + description = "DINOv2 linear evaluation" + args_parser = get_args_parser(description=description) + args = args_parser.parse_args() + sys.exit(main(args)) diff --git a/OpenMidnight/dinov2/eval/log_regression.py b/OpenMidnight/dinov2/eval/log_regression.py new file mode 100644 index 0000000000000000000000000000000000000000..5f36ec134e0ce25697428a0b3f21cdc2f0145645 --- /dev/null +++ b/OpenMidnight/dinov2/eval/log_regression.py @@ -0,0 +1,444 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import argparse +import gc +import logging +import sys +import time +from typing import List, Optional + +from cuml.linear_model import LogisticRegression +import torch +import torch.backends.cudnn as cudnn +import torch.distributed +from torch import nn +from torch.utils.data import TensorDataset +from torchmetrics import MetricTracker + +from dinov2.data import make_dataset +from dinov2.data.transforms import make_classification_eval_transform +from dinov2.distributed import get_global_rank, get_global_size +from dinov2.eval.metrics import MetricType, build_metric +from dinov2.eval.setup import get_args_parser as get_setup_args_parser +from dinov2.eval.setup import setup_and_build_model +from dinov2.eval.utils import evaluate, extract_features +from dinov2.utils.dtype import as_torch_dtype + + +logger = logging.getLogger("dinov2") + +DEFAULT_MAX_ITER = 1_000 +C_POWER_RANGE = torch.linspace(-6, 5, 45) +_CPU_DEVICE = torch.device("cpu") + + +def get_args_parser( + description: Optional[str] = None, + parents: Optional[List[argparse.ArgumentParser]] = None, + add_help: bool = True, +): + parents = parents or [] + setup_args_parser = get_setup_args_parser(parents=parents, add_help=False) + parents = [setup_args_parser] + parser = argparse.ArgumentParser( + description=description, + parents=parents, + add_help=add_help, + ) + parser.add_argument( + "--train-dataset", + dest="train_dataset_str", + type=str, + help="Training dataset", + ) + parser.add_argument( + "--val-dataset", + dest="val_dataset_str", + type=str, + help="Validation dataset", + ) + parser.add_argument( + "--finetune-dataset-str", + dest="finetune_dataset_str", + type=str, + help="Fine-tuning dataset", + ) + parser.add_argument( + "--finetune-on-val", + action="store_true", + help="If there is no finetune dataset, whether to choose the " + "hyperparameters on the val set instead of 10%% of the train dataset", + ) + parser.add_argument( + "--metric-type", + type=MetricType, + choices=list(MetricType), + help="Metric type", + ) + parser.add_argument( + "--train-features-device", + type=str, + help="Device to gather train features (cpu, cuda, cuda:0, etc.), default: %(default)s", + ) + parser.add_argument( + "--train-dtype", + type=str, + help="Data type to convert the train features to (default: %(default)s)", + ) + parser.add_argument( + "--max-train-iters", + type=int, + help="Maximum number of train iterations (default: %(default)s)", + ) + parser.set_defaults( + train_dataset_str="ImageNet:split=TRAIN", + val_dataset_str="ImageNet:split=VAL", + finetune_dataset_str=None, + metric_type=MetricType.MEAN_ACCURACY, + train_features_device="cpu", + train_dtype="float64", + max_train_iters=DEFAULT_MAX_ITER, + finetune_on_val=False, + ) + return parser + + +class LogRegModule(nn.Module): + def __init__( + self, + C, + max_iter=DEFAULT_MAX_ITER, + dtype=torch.float64, + device=_CPU_DEVICE, + ): + super().__init__() + self.dtype = dtype + self.device = device + self.estimator = LogisticRegression( + penalty="l2", + C=C, + max_iter=max_iter, + output_type="numpy", + tol=1e-12, + linesearch_max_iter=50, + ) + + def forward(self, samples, targets): + samples_device = samples.device + samples = samples.to(dtype=self.dtype, device=self.device) + if self.device == _CPU_DEVICE: + samples = samples.numpy() + probas = self.estimator.predict_proba(samples) + return {"preds": torch.from_numpy(probas).to(samples_device), "target": targets} + + def fit(self, train_features, train_labels): + train_features = train_features.to(dtype=self.dtype, device=self.device) + train_labels = train_labels.to(dtype=self.dtype, device=self.device) + if self.device == _CPU_DEVICE: + # both cuML and sklearn only work with numpy arrays on CPU + train_features = train_features.numpy() + train_labels = train_labels.numpy() + self.estimator.fit(train_features, train_labels) + + +def evaluate_model(*, logreg_model, logreg_metric, test_data_loader, device): + postprocessors = {"metrics": logreg_model} + metrics = {"metrics": logreg_metric} + return evaluate(nn.Identity(), test_data_loader, postprocessors, metrics, device) + + +def train_for_C(*, C, max_iter, train_features, train_labels, dtype=torch.float64, device=_CPU_DEVICE): + logreg_model = LogRegModule(C, max_iter=max_iter, dtype=dtype, device=device) + logreg_model.fit(train_features, train_labels) + return logreg_model + + +def train_and_evaluate( + *, + C, + max_iter, + train_features, + train_labels, + logreg_metric, + test_data_loader, + train_dtype=torch.float64, + train_features_device, + eval_device, +): + logreg_model = train_for_C( + C=C, + max_iter=max_iter, + train_features=train_features, + train_labels=train_labels, + dtype=train_dtype, + device=train_features_device, + ) + return evaluate_model( + logreg_model=logreg_model, + logreg_metric=logreg_metric, + test_data_loader=test_data_loader, + device=eval_device, + ) + + +def sweep_C_values( + *, + train_features, + train_labels, + test_data_loader, + metric_type, + num_classes, + train_dtype=torch.float64, + train_features_device=_CPU_DEVICE, + max_train_iters=DEFAULT_MAX_ITER, +): + if metric_type == MetricType.PER_CLASS_ACCURACY: + # If we want to output per-class accuracy, we select the hyperparameters with mean per class + metric_type = MetricType.MEAN_PER_CLASS_ACCURACY + logreg_metric = build_metric(metric_type, num_classes=num_classes) + metric_tracker = MetricTracker(logreg_metric, maximize=True) + ALL_C = 10**C_POWER_RANGE + logreg_models = {} + + train_features = train_features.to(dtype=train_dtype, device=train_features_device) + train_labels = train_labels.to(device=train_features_device) + + for i in range(get_global_rank(), len(ALL_C), get_global_size()): + C = ALL_C[i].item() + logger.info( + f"Training for C = {C:.5f}, dtype={train_dtype}, " + f"features: {train_features.shape}, {train_features.dtype}, " + f"labels: {train_labels.shape}, {train_labels.dtype}" + ) + logreg_models[C] = train_for_C( + C=C, + max_iter=max_train_iters, + train_features=train_features, + train_labels=train_labels, + dtype=train_dtype, + device=train_features_device, + ) + + gather_list = [None for _ in range(get_global_size())] + torch.distributed.all_gather_object(gather_list, logreg_models) + + logreg_models_gathered = {} + for logreg_dict in gather_list: + logreg_models_gathered.update(logreg_dict) + + for i in range(len(ALL_C)): + metric_tracker.increment() + C = ALL_C[i].item() + evals = evaluate_model( + logreg_model=logreg_models_gathered[C], + logreg_metric=metric_tracker, + test_data_loader=test_data_loader, + device=torch.cuda.current_device(), + ) + logger.info(f"Trained for C = {C:.5f}, accuracies = {evals}") + + best_stats, which_epoch = metric_tracker.best_metric(return_step=True) + best_stats_100 = {k: 100.0 * v for k, v in best_stats.items()} + if which_epoch["top-1"] == i: + best_C = C + logger.info(f"Sweep best {best_stats_100}, best C = {best_C:.6f}") + + return best_stats, best_C + + +def eval_log_regression( + *, + model, + train_dataset, + val_dataset, + finetune_dataset, + metric_type, + batch_size, + num_workers, + finetune_on_val=False, + train_dtype=torch.float64, + train_features_device=_CPU_DEVICE, + max_train_iters=DEFAULT_MAX_ITER, +): + """ + Implements the "standard" process for log regression evaluation: + The value of C is chosen by training on train_dataset and evaluating on + finetune_dataset. Then, the final model is trained on a concatenation of + train_dataset and finetune_dataset, and is evaluated on val_dataset. + If there is no finetune_dataset, the value of C is the one that yields + the best results on a random 10% subset of the train dataset + """ + + start = time.time() + + train_features, train_labels = extract_features( + model, train_dataset, batch_size, num_workers, gather_on_cpu=(train_features_device == _CPU_DEVICE) + ) + val_features, val_labels = extract_features( + model, val_dataset, batch_size, num_workers, gather_on_cpu=(train_features_device == _CPU_DEVICE) + ) + val_data_loader = torch.utils.data.DataLoader( + TensorDataset(val_features, val_labels), + batch_size=batch_size, + drop_last=False, + num_workers=0, + persistent_workers=False, + ) + + if finetune_dataset is None and finetune_on_val: + logger.info("Choosing hyperparameters on the val dataset") + finetune_features, finetune_labels = val_features, val_labels + elif finetune_dataset is None and not finetune_on_val: + logger.info("Choosing hyperparameters on 10% of the train dataset") + torch.manual_seed(0) + indices = torch.randperm(len(train_features), device=train_features.device) + finetune_index = indices[: len(train_features) // 10] + train_index = indices[len(train_features) // 10 :] + finetune_features, finetune_labels = train_features[finetune_index], train_labels[finetune_index] + train_features, train_labels = train_features[train_index], train_labels[train_index] + else: + logger.info("Choosing hyperparameters on the finetune dataset") + finetune_features, finetune_labels = extract_features( + model, finetune_dataset, batch_size, num_workers, gather_on_cpu=(train_features_device == _CPU_DEVICE) + ) + # release the model - free GPU memory + del model + gc.collect() + torch.cuda.empty_cache() + finetune_data_loader = torch.utils.data.DataLoader( + TensorDataset(finetune_features, finetune_labels), + batch_size=batch_size, + drop_last=False, + ) + + if len(train_labels.shape) > 1: + num_classes = train_labels.shape[1] + else: + num_classes = train_labels.max() + 1 + + logger.info("Using cuML for logistic regression") + + best_stats, best_C = sweep_C_values( + train_features=train_features, + train_labels=train_labels, + test_data_loader=finetune_data_loader, + metric_type=metric_type, + num_classes=num_classes, + train_dtype=train_dtype, + train_features_device=train_features_device, + max_train_iters=max_train_iters, + ) + + if not finetune_on_val: + logger.info("Best parameter found, concatenating features") + train_features = torch.cat((train_features, finetune_features)) + train_labels = torch.cat((train_labels, finetune_labels)) + + logger.info("Training final model") + logreg_metric = build_metric(metric_type, num_classes=num_classes) + evals = train_and_evaluate( + C=best_C, + max_iter=max_train_iters, + train_features=train_features, + train_labels=train_labels, + logreg_metric=logreg_metric.clone(), + test_data_loader=val_data_loader, + eval_device=torch.cuda.current_device(), + train_dtype=train_dtype, + train_features_device=train_features_device, + ) + + best_stats = evals[1]["metrics"] + + best_stats["best_C"] = best_C + + logger.info(f"Log regression evaluation done in {int(time.time() - start)}s") + return best_stats + + +def eval_log_regression_with_model( + model, + train_dataset_str="ImageNet:split=TRAIN", + val_dataset_str="ImageNet:split=VAL", + finetune_dataset_str=None, + autocast_dtype=torch.float, + finetune_on_val=False, + metric_type=MetricType.MEAN_ACCURACY, + train_dtype=torch.float64, + train_features_device=_CPU_DEVICE, + max_train_iters=DEFAULT_MAX_ITER, +): + cudnn.benchmark = True + + transform = make_classification_eval_transform(resize_size=224) + target_transform = None + + train_dataset = make_dataset(dataset_str=train_dataset_str, transform=transform, target_transform=target_transform) + val_dataset = make_dataset(dataset_str=val_dataset_str, transform=transform, target_transform=target_transform) + if finetune_dataset_str is not None: + finetune_dataset = make_dataset( + dataset_str=finetune_dataset_str, transform=transform, target_transform=target_transform + ) + else: + finetune_dataset = None + + with torch.cuda.amp.autocast(dtype=autocast_dtype): + results_dict_logreg = eval_log_regression( + model=model, + train_dataset=train_dataset, + val_dataset=val_dataset, + finetune_dataset=finetune_dataset, + metric_type=metric_type, + batch_size=256, + num_workers=0, # 5, + finetune_on_val=finetune_on_val, + train_dtype=train_dtype, + train_features_device=train_features_device, + max_train_iters=max_train_iters, + ) + + results_dict = { + "top-1": results_dict_logreg["top-1"].cpu().numpy() * 100.0, + "top-5": results_dict_logreg.get("top-5", torch.tensor(0.0)).cpu().numpy() * 100.0, + "best_C": results_dict_logreg["best_C"], + } + logger.info( + "\n".join( + [ + "Training of the supervised logistic regression on frozen features completed.\n" + "Top-1 test accuracy: {acc:.1f}".format(acc=results_dict["top-1"]), + "Top-5 test accuracy: {acc:.1f}".format(acc=results_dict["top-5"]), + "obtained for C = {c:.6f}".format(c=results_dict["best_C"]), + ] + ) + ) + + torch.distributed.barrier() + return results_dict + + +def main(args): + model, autocast_dtype = setup_and_build_model(args) + eval_log_regression_with_model( + model=model, + train_dataset_str=args.train_dataset_str, + val_dataset_str=args.val_dataset_str, + finetune_dataset_str=args.finetune_dataset_str, + autocast_dtype=autocast_dtype, + finetune_on_val=args.finetune_on_val, + metric_type=args.metric_type, + train_dtype=as_torch_dtype(args.train_dtype), + train_features_device=torch.device(args.train_features_device), + max_train_iters=args.max_train_iters, + ) + return 0 + + +if __name__ == "__main__": + description = "DINOv2 logistic regression evaluation" + args_parser = get_args_parser(description=description) + args = args_parser.parse_args() + sys.exit(main(args)) diff --git a/OpenMidnight/dinov2/eval/metrics.py b/OpenMidnight/dinov2/eval/metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..52be81a859dddde82da93c3657c35352d2bb0a48 --- /dev/null +++ b/OpenMidnight/dinov2/eval/metrics.py @@ -0,0 +1,113 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from enum import Enum +import logging +from typing import Any, Dict, Optional + +import torch +from torch import Tensor +from torchmetrics import Metric, MetricCollection +from torchmetrics.classification import MulticlassAccuracy +from torchmetrics.utilities.data import dim_zero_cat, select_topk + + +logger = logging.getLogger("dinov2") + + +class MetricType(Enum): + MEAN_ACCURACY = "mean_accuracy" + MEAN_PER_CLASS_ACCURACY = "mean_per_class_accuracy" + PER_CLASS_ACCURACY = "per_class_accuracy" + IMAGENET_REAL_ACCURACY = "imagenet_real_accuracy" + + @property + def accuracy_averaging(self): + return getattr(AccuracyAveraging, self.name, None) + + def __str__(self): + return self.value + + +class AccuracyAveraging(Enum): + MEAN_ACCURACY = "micro" + MEAN_PER_CLASS_ACCURACY = "macro" + PER_CLASS_ACCURACY = "none" + + def __str__(self): + return self.value + + +def build_metric(metric_type: MetricType, *, num_classes: int, ks: Optional[tuple] = None): + if metric_type.accuracy_averaging is not None: + return build_topk_accuracy_metric( + average_type=metric_type.accuracy_averaging, + num_classes=num_classes, + ks=(1, 5) if ks is None else ks, + ) + elif metric_type == MetricType.IMAGENET_REAL_ACCURACY: + return build_topk_imagenet_real_accuracy_metric( + num_classes=num_classes, + ks=(1, 5) if ks is None else ks, + ) + + raise ValueError(f"Unknown metric type {metric_type}") + + +def build_topk_accuracy_metric(average_type: AccuracyAveraging, num_classes: int, ks: tuple = (1, 5)): + metrics: Dict[str, Metric] = { + f"top-{k}": MulticlassAccuracy(top_k=k, num_classes=int(num_classes), average=average_type.value) for k in ks + } + return MetricCollection(metrics) + + +def build_topk_imagenet_real_accuracy_metric(num_classes: int, ks: tuple = (1, 5)): + metrics: Dict[str, Metric] = {f"top-{k}": ImageNetReaLAccuracy(top_k=k, num_classes=int(num_classes)) for k in ks} + return MetricCollection(metrics) + + +class ImageNetReaLAccuracy(Metric): + is_differentiable: bool = False + higher_is_better: Optional[bool] = None + full_state_update: bool = False + + def __init__( + self, + num_classes: int, + top_k: int = 1, + **kwargs: Any, + ) -> None: + super().__init__(**kwargs) + self.num_classes = num_classes + self.top_k = top_k + self.add_state("tp", [], dist_reduce_fx="cat") + + def update(self, preds: Tensor, target: Tensor) -> None: # type: ignore + # preds [B, D] + # target [B, A] + # preds_oh [B, D] with 0 and 1 + # select top K highest probabilities, use one hot representation + preds_oh = select_topk(preds, self.top_k) + # target_oh [B, D + 1] with 0 and 1 + target_oh = torch.zeros((preds_oh.shape[0], preds_oh.shape[1] + 1), device=target.device, dtype=torch.int32) + target = target.long() + # for undefined targets (-1) use a fake value `num_classes` + target[target == -1] = self.num_classes + # fill targets, use one hot representation + target_oh.scatter_(1, target, 1) + # target_oh [B, D] (remove the fake target at index `num_classes`) + target_oh = target_oh[:, :-1] + # tp [B] with 0 and 1 + tp = (preds_oh * target_oh == 1).sum(dim=1) + # at least one match between prediction and target + tp.clip_(max=1) + # ignore instances where no targets are defined + mask = target_oh.sum(dim=1) > 0 + tp = tp[mask] + self.tp.append(tp) # type: ignore + + def compute(self) -> Tensor: + tp = dim_zero_cat(self.tp) # type: ignore + return tp.float().mean() diff --git a/OpenMidnight/dinov2/eval/segmentation/__init__.py b/OpenMidnight/dinov2/eval/segmentation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b88da6bf80be92af00b72dfdb0a806fa64a7a2d9 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/OpenMidnight/dinov2/eval/segmentation/hooks/__init__.py b/OpenMidnight/dinov2/eval/segmentation/hooks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..738cc2d2069521ea0353acd0cb0a03e3ddf1fa51 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation/hooks/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .optimizer import DistOptimizerHook diff --git a/OpenMidnight/dinov2/eval/segmentation/hooks/optimizer.py b/OpenMidnight/dinov2/eval/segmentation/hooks/optimizer.py new file mode 100644 index 0000000000000000000000000000000000000000..f593f26a84475bbf7ebda9607a4d10914b13a443 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation/hooks/optimizer.py @@ -0,0 +1,40 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +try: + import apex +except ImportError: + print("apex is not installed") + +from mmcv.runner import OptimizerHook, HOOKS + + +@HOOKS.register_module() +class DistOptimizerHook(OptimizerHook): + """Optimizer hook for distributed training.""" + + def __init__(self, update_interval=1, grad_clip=None, coalesce=True, bucket_size_mb=-1, use_fp16=False): + self.grad_clip = grad_clip + self.coalesce = coalesce + self.bucket_size_mb = bucket_size_mb + self.update_interval = update_interval + self.use_fp16 = use_fp16 + + def before_run(self, runner): + runner.optimizer.zero_grad() + + def after_train_iter(self, runner): + runner.outputs["loss"] /= self.update_interval + if self.use_fp16: + # runner.outputs['loss'].backward() + with apex.amp.scale_loss(runner.outputs["loss"], runner.optimizer) as scaled_loss: + scaled_loss.backward() + else: + runner.outputs["loss"].backward() + if self.every_n_iters(runner, self.update_interval): + if self.grad_clip is not None: + self.clip_grads(runner.model.parameters()) + runner.optimizer.step() + runner.optimizer.zero_grad() diff --git a/OpenMidnight/dinov2/eval/segmentation/models/__init__.py b/OpenMidnight/dinov2/eval/segmentation/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..88e4563d4c162d67e7900955a06bd9248d4c9a48 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation/models/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .backbones import * # noqa: F403 +from .decode_heads import * # noqa: F403 diff --git a/OpenMidnight/dinov2/eval/segmentation/models/backbones/__init__.py b/OpenMidnight/dinov2/eval/segmentation/models/backbones/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..520d75bc6e064b9d64487293604ac1bda6e2b6f7 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation/models/backbones/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .vision_transformer import DinoVisionTransformer diff --git a/OpenMidnight/dinov2/eval/segmentation/models/backbones/vision_transformer.py b/OpenMidnight/dinov2/eval/segmentation/models/backbones/vision_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..c3e9753ae92a36be52f100e3004cbeeff777d14a --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation/models/backbones/vision_transformer.py @@ -0,0 +1,19 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from mmcv.runner import BaseModule +from mmseg.models.builder import BACKBONES + + +@BACKBONES.register_module() +class DinoVisionTransformer(BaseModule): + """Vision Transformer.""" + + def __init__( + self, + *args, + **kwargs, + ): + super().__init__() diff --git a/OpenMidnight/dinov2/eval/segmentation/models/decode_heads/__init__.py b/OpenMidnight/dinov2/eval/segmentation/models/decode_heads/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c55317875262dadf8970c2b3882f016b8d4731ac --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation/models/decode_heads/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .linear_head import BNHead diff --git a/OpenMidnight/dinov2/eval/segmentation/models/decode_heads/linear_head.py b/OpenMidnight/dinov2/eval/segmentation/models/decode_heads/linear_head.py new file mode 100644 index 0000000000000000000000000000000000000000..d1f39c68fb136f84d1aa5284da5b69581bb177cc --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation/models/decode_heads/linear_head.py @@ -0,0 +1,90 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn + +from mmseg.models.builder import HEADS +from mmseg.models.decode_heads.decode_head import BaseDecodeHead +from mmseg.ops import resize + + +@HEADS.register_module() +class BNHead(BaseDecodeHead): + """Just a batchnorm.""" + + def __init__(self, resize_factors=None, **kwargs): + super().__init__(**kwargs) + assert self.in_channels == self.channels + self.bn = nn.SyncBatchNorm(self.in_channels) + self.resize_factors = resize_factors + + def _forward_feature(self, inputs): + """Forward function for feature maps before classifying each pixel with + ``self.cls_seg`` fc. + + Args: + inputs (list[Tensor]): List of multi-level img features. + + Returns: + feats (Tensor): A tensor of shape (batch_size, self.channels, + H, W) which is feature map for last layer of decoder head. + """ + # print("inputs", [i.shape for i in inputs]) + x = self._transform_inputs(inputs) + # print("x", x.shape) + feats = self.bn(x) + # print("feats", feats.shape) + return feats + + def _transform_inputs(self, inputs): + """Transform inputs for decoder. + Args: + inputs (list[Tensor]): List of multi-level img features. + Returns: + Tensor: The transformed inputs + """ + + if self.input_transform == "resize_concat": + # accept lists (for cls token) + input_list = [] + for x in inputs: + if isinstance(x, list): + input_list.extend(x) + else: + input_list.append(x) + inputs = input_list + # an image descriptor can be a local descriptor with resolution 1x1 + for i, x in enumerate(inputs): + if len(x.shape) == 2: + inputs[i] = x[:, :, None, None] + # select indices + inputs = [inputs[i] for i in self.in_index] + # Resizing shenanigans + # print("before", *(x.shape for x in inputs)) + if self.resize_factors is not None: + assert len(self.resize_factors) == len(inputs), (len(self.resize_factors), len(inputs)) + inputs = [ + resize(input=x, scale_factor=f, mode="bilinear" if f >= 1 else "area") + for x, f in zip(inputs, self.resize_factors) + ] + # print("after", *(x.shape for x in inputs)) + upsampled_inputs = [ + resize(input=x, size=inputs[0].shape[2:], mode="bilinear", align_corners=self.align_corners) + for x in inputs + ] + inputs = torch.cat(upsampled_inputs, dim=1) + elif self.input_transform == "multiple_select": + inputs = [inputs[i] for i in self.in_index] + else: + inputs = inputs[self.in_index] + + return inputs + + def forward(self, inputs): + """Forward function.""" + output = self._forward_feature(inputs) + output = self.cls_seg(output) + return output diff --git a/OpenMidnight/dinov2/eval/segmentation/utils/__init__.py b/OpenMidnight/dinov2/eval/segmentation/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b88da6bf80be92af00b72dfdb0a806fa64a7a2d9 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation/utils/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/OpenMidnight/dinov2/eval/segmentation/utils/colormaps.py b/OpenMidnight/dinov2/eval/segmentation/utils/colormaps.py new file mode 100644 index 0000000000000000000000000000000000000000..e6ef604b2c75792e95e438abfd51ab03d40de340 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation/utils/colormaps.py @@ -0,0 +1,362 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +ADE20K_COLORMAP = [ + (0, 0, 0), + (120, 120, 120), + (180, 120, 120), + (6, 230, 230), + (80, 50, 50), + (4, 200, 3), + (120, 120, 80), + (140, 140, 140), + (204, 5, 255), + (230, 230, 230), + (4, 250, 7), + (224, 5, 255), + (235, 255, 7), + (150, 5, 61), + (120, 120, 70), + (8, 255, 51), + (255, 6, 82), + (143, 255, 140), + (204, 255, 4), + (255, 51, 7), + (204, 70, 3), + (0, 102, 200), + (61, 230, 250), + (255, 6, 51), + (11, 102, 255), + (255, 7, 71), + (255, 9, 224), + (9, 7, 230), + (220, 220, 220), + (255, 9, 92), + (112, 9, 255), + (8, 255, 214), + (7, 255, 224), + (255, 184, 6), + (10, 255, 71), + (255, 41, 10), + (7, 255, 255), + (224, 255, 8), + (102, 8, 255), + (255, 61, 6), + (255, 194, 7), + (255, 122, 8), + (0, 255, 20), + (255, 8, 41), + (255, 5, 153), + (6, 51, 255), + (235, 12, 255), + (160, 150, 20), + (0, 163, 255), + (140, 140, 140), + (250, 10, 15), + (20, 255, 0), + (31, 255, 0), + (255, 31, 0), + (255, 224, 0), + (153, 255, 0), + (0, 0, 255), + (255, 71, 0), + (0, 235, 255), + (0, 173, 255), + (31, 0, 255), + (11, 200, 200), + (255, 82, 0), + (0, 255, 245), + (0, 61, 255), + (0, 255, 112), + (0, 255, 133), + (255, 0, 0), + (255, 163, 0), + (255, 102, 0), + (194, 255, 0), + (0, 143, 255), + (51, 255, 0), + (0, 82, 255), + (0, 255, 41), + (0, 255, 173), + (10, 0, 255), + (173, 255, 0), + (0, 255, 153), + (255, 92, 0), + (255, 0, 255), + (255, 0, 245), + (255, 0, 102), + (255, 173, 0), + (255, 0, 20), + (255, 184, 184), + (0, 31, 255), + (0, 255, 61), + (0, 71, 255), + (255, 0, 204), + (0, 255, 194), + (0, 255, 82), + (0, 10, 255), + (0, 112, 255), + (51, 0, 255), + (0, 194, 255), + (0, 122, 255), + (0, 255, 163), + (255, 153, 0), + (0, 255, 10), + (255, 112, 0), + (143, 255, 0), + (82, 0, 255), + (163, 255, 0), + (255, 235, 0), + (8, 184, 170), + (133, 0, 255), + (0, 255, 92), + (184, 0, 255), + (255, 0, 31), + (0, 184, 255), + (0, 214, 255), + (255, 0, 112), + (92, 255, 0), + (0, 224, 255), + (112, 224, 255), + (70, 184, 160), + (163, 0, 255), + (153, 0, 255), + (71, 255, 0), + (255, 0, 163), + (255, 204, 0), + (255, 0, 143), + (0, 255, 235), + (133, 255, 0), + (255, 0, 235), + (245, 0, 255), + (255, 0, 122), + (255, 245, 0), + (10, 190, 212), + (214, 255, 0), + (0, 204, 255), + (20, 0, 255), + (255, 255, 0), + (0, 153, 255), + (0, 41, 255), + (0, 255, 204), + (41, 0, 255), + (41, 255, 0), + (173, 0, 255), + (0, 245, 255), + (71, 0, 255), + (122, 0, 255), + (0, 255, 184), + (0, 92, 255), + (184, 255, 0), + (0, 133, 255), + (255, 214, 0), + (25, 194, 194), + (102, 255, 0), + (92, 0, 255), +] + +ADE20K_CLASS_NAMES = [ + "", + "wall", + "building;edifice", + "sky", + "floor;flooring", + "tree", + "ceiling", + "road;route", + "bed", + "windowpane;window", + "grass", + "cabinet", + "sidewalk;pavement", + "person;individual;someone;somebody;mortal;soul", + "earth;ground", + "door;double;door", + "table", + "mountain;mount", + "plant;flora;plant;life", + "curtain;drape;drapery;mantle;pall", + "chair", + "car;auto;automobile;machine;motorcar", + "water", + "painting;picture", + "sofa;couch;lounge", + "shelf", + "house", + "sea", + "mirror", + "rug;carpet;carpeting", + "field", + "armchair", + "seat", + "fence;fencing", + "desk", + "rock;stone", + "wardrobe;closet;press", + "lamp", + "bathtub;bathing;tub;bath;tub", + "railing;rail", + "cushion", + "base;pedestal;stand", + "box", + "column;pillar", + "signboard;sign", + "chest;of;drawers;chest;bureau;dresser", + "counter", + "sand", + "sink", + "skyscraper", + "fireplace;hearth;open;fireplace", + "refrigerator;icebox", + "grandstand;covered;stand", + "path", + "stairs;steps", + "runway", + "case;display;case;showcase;vitrine", + "pool;table;billiard;table;snooker;table", + "pillow", + "screen;door;screen", + "stairway;staircase", + "river", + "bridge;span", + "bookcase", + "blind;screen", + "coffee;table;cocktail;table", + "toilet;can;commode;crapper;pot;potty;stool;throne", + "flower", + "book", + "hill", + "bench", + "countertop", + "stove;kitchen;stove;range;kitchen;range;cooking;stove", + "palm;palm;tree", + "kitchen;island", + "computer;computing;machine;computing;device;data;processor;electronic;computer;information;processing;system", + "swivel;chair", + "boat", + "bar", + "arcade;machine", + "hovel;hut;hutch;shack;shanty", + "bus;autobus;coach;charabanc;double-decker;jitney;motorbus;motorcoach;omnibus;passenger;vehicle", + "towel", + "light;light;source", + "truck;motortruck", + "tower", + "chandelier;pendant;pendent", + "awning;sunshade;sunblind", + "streetlight;street;lamp", + "booth;cubicle;stall;kiosk", + "television;television;receiver;television;set;tv;tv;set;idiot;box;boob;tube;telly;goggle;box", + "airplane;aeroplane;plane", + "dirt;track", + "apparel;wearing;apparel;dress;clothes", + "pole", + "land;ground;soil", + "bannister;banister;balustrade;balusters;handrail", + "escalator;moving;staircase;moving;stairway", + "ottoman;pouf;pouffe;puff;hassock", + "bottle", + "buffet;counter;sideboard", + "poster;posting;placard;notice;bill;card", + "stage", + "van", + "ship", + "fountain", + "conveyer;belt;conveyor;belt;conveyer;conveyor;transporter", + "canopy", + "washer;automatic;washer;washing;machine", + "plaything;toy", + "swimming;pool;swimming;bath;natatorium", + "stool", + "barrel;cask", + "basket;handbasket", + "waterfall;falls", + "tent;collapsible;shelter", + "bag", + "minibike;motorbike", + "cradle", + "oven", + "ball", + "food;solid;food", + "step;stair", + "tank;storage;tank", + "trade;name;brand;name;brand;marque", + "microwave;microwave;oven", + "pot;flowerpot", + "animal;animate;being;beast;brute;creature;fauna", + "bicycle;bike;wheel;cycle", + "lake", + "dishwasher;dish;washer;dishwashing;machine", + "screen;silver;screen;projection;screen", + "blanket;cover", + "sculpture", + "hood;exhaust;hood", + "sconce", + "vase", + "traffic;light;traffic;signal;stoplight", + "tray", + "ashcan;trash;can;garbage;can;wastebin;ash;bin;ash-bin;ashbin;dustbin;trash;barrel;trash;bin", + "fan", + "pier;wharf;wharfage;dock", + "crt;screen", + "plate", + "monitor;monitoring;device", + "bulletin;board;notice;board", + "shower", + "radiator", + "glass;drinking;glass", + "clock", + "flag", +] + + +VOC2012_COLORMAP = [ + (0, 0, 0), + (128, 0, 0), + (0, 128, 0), + (128, 128, 0), + (0, 0, 128), + (128, 0, 128), + (0, 128, 128), + (128, 128, 128), + (64, 0, 0), + (192, 0, 0), + (64, 128, 0), + (192, 128, 0), + (64, 0, 128), + (192, 0, 128), + (64, 128, 128), + (192, 128, 128), + (0, 64, 0), + (128, 64, 0), + (0, 192, 0), + (128, 192, 0), + (0, 64, 128), +] + + +VOC2012_CLASS_NAMES = [ + "", + "aeroplane", + "bicycle", + "bird", + "boat", + "bottle", + "bus", + "car", + "cat", + "chair", + "cow", + "diningtable", + "dog", + "horse", + "motorbike", + "person", + "pottedplant", + "sheep", + "sofa", + "train", + "tvmonitor", +] diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6c678fdf8f1dee14d7cf9be70af14e6f9a1441c3 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .core import * # noqa: F403 +from .models import * # noqa: F403 +from .ops import * # noqa: F403 diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..92599806fbd221c1418d179892a0f46dc0b7d4db --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/__init__.py @@ -0,0 +1,11 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from mmseg.core.evaluation import * # noqa: F403 +from mmseg.core.seg import * # noqa: F403 + +from .anchor import * # noqa: F403 +from .box import * # noqa: F403 +from .utils import * # noqa: F403 diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/anchor/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/anchor/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e71ac4d6e01462221ae01aa16d0e1231cda7e2e7 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/anchor/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .point_generator import MlvlPointGenerator # noqa: F403 diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/anchor/builder.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/anchor/builder.py new file mode 100644 index 0000000000000000000000000000000000000000..6dba90e22de76d2f23a86d3c057f196d55a99690 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/anchor/builder.py @@ -0,0 +1,21 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import warnings + +from mmcv.utils import Registry, build_from_cfg + +PRIOR_GENERATORS = Registry("Generator for anchors and points") + +ANCHOR_GENERATORS = PRIOR_GENERATORS + + +def build_prior_generator(cfg, default_args=None): + return build_from_cfg(cfg, PRIOR_GENERATORS, default_args) + + +def build_anchor_generator(cfg, default_args=None): + warnings.warn("``build_anchor_generator`` would be deprecated soon, please use " "``build_prior_generator`` ") + return build_prior_generator(cfg, default_args=default_args) diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/anchor/point_generator.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/anchor/point_generator.py new file mode 100644 index 0000000000000000000000000000000000000000..574d71939080e22284fe99087fb2e7336657bd97 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/anchor/point_generator.py @@ -0,0 +1,205 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import numpy as np +import torch +from torch.nn.modules.utils import _pair + +from .builder import PRIOR_GENERATORS + + +@PRIOR_GENERATORS.register_module() +class MlvlPointGenerator: + """Standard points generator for multi-level (Mlvl) feature maps in 2D + points-based detectors. + + Args: + strides (list[int] | list[tuple[int, int]]): Strides of anchors + in multiple feature levels in order (w, h). + offset (float): The offset of points, the value is normalized with + corresponding stride. Defaults to 0.5. + """ + + def __init__(self, strides, offset=0.5): + self.strides = [_pair(stride) for stride in strides] + self.offset = offset + + @property + def num_levels(self): + """int: number of feature levels that the generator will be applied""" + return len(self.strides) + + @property + def num_base_priors(self): + """list[int]: The number of priors (points) at a point + on the feature grid""" + return [1 for _ in range(len(self.strides))] + + def _meshgrid(self, x, y, row_major=True): + yy, xx = torch.meshgrid(y, x) + if row_major: + # warning .flatten() would cause error in ONNX exporting + # have to use reshape here + return xx.reshape(-1), yy.reshape(-1) + + else: + return yy.reshape(-1), xx.reshape(-1) + + def grid_priors(self, featmap_sizes, dtype=torch.float32, device="cuda", with_stride=False): + """Generate grid points of multiple feature levels. + + Args: + featmap_sizes (list[tuple]): List of feature map sizes in + multiple feature levels, each size arrange as + as (h, w). + dtype (:obj:`dtype`): Dtype of priors. Default: torch.float32. + device (str): The device where the anchors will be put on. + with_stride (bool): Whether to concatenate the stride to + the last dimension of points. + + Return: + list[torch.Tensor]: Points of multiple feature levels. + The sizes of each tensor should be (N, 2) when with stride is + ``False``, where N = width * height, width and height + are the sizes of the corresponding feature level, + and the last dimension 2 represent (coord_x, coord_y), + otherwise the shape should be (N, 4), + and the last dimension 4 represent + (coord_x, coord_y, stride_w, stride_h). + """ + + assert self.num_levels == len(featmap_sizes) + multi_level_priors = [] + for i in range(self.num_levels): + priors = self.single_level_grid_priors( + featmap_sizes[i], level_idx=i, dtype=dtype, device=device, with_stride=with_stride + ) + multi_level_priors.append(priors) + return multi_level_priors + + def single_level_grid_priors(self, featmap_size, level_idx, dtype=torch.float32, device="cuda", with_stride=False): + """Generate grid Points of a single level. + + Note: + This function is usually called by method ``self.grid_priors``. + + Args: + featmap_size (tuple[int]): Size of the feature maps, arrange as + (h, w). + level_idx (int): The index of corresponding feature map level. + dtype (:obj:`dtype`): Dtype of priors. Default: torch.float32. + device (str, optional): The device the tensor will be put on. + Defaults to 'cuda'. + with_stride (bool): Concatenate the stride to the last dimension + of points. + + Return: + Tensor: Points of single feature levels. + The shape of tensor should be (N, 2) when with stride is + ``False``, where N = width * height, width and height + are the sizes of the corresponding feature level, + and the last dimension 2 represent (coord_x, coord_y), + otherwise the shape should be (N, 4), + and the last dimension 4 represent + (coord_x, coord_y, stride_w, stride_h). + """ + feat_h, feat_w = featmap_size + stride_w, stride_h = self.strides[level_idx] + shift_x = (torch.arange(0, feat_w, device=device) + self.offset) * stride_w + # keep featmap_size as Tensor instead of int, so that we + # can convert to ONNX correctly + shift_x = shift_x.to(dtype) + + shift_y = (torch.arange(0, feat_h, device=device) + self.offset) * stride_h + # keep featmap_size as Tensor instead of int, so that we + # can convert to ONNX correctly + shift_y = shift_y.to(dtype) + shift_xx, shift_yy = self._meshgrid(shift_x, shift_y) + if not with_stride: + shifts = torch.stack([shift_xx, shift_yy], dim=-1) + else: + # use `shape[0]` instead of `len(shift_xx)` for ONNX export + stride_w = shift_xx.new_full((shift_xx.shape[0],), stride_w).to(dtype) + stride_h = shift_xx.new_full((shift_yy.shape[0],), stride_h).to(dtype) + shifts = torch.stack([shift_xx, shift_yy, stride_w, stride_h], dim=-1) + all_points = shifts.to(device) + return all_points + + def valid_flags(self, featmap_sizes, pad_shape, device="cuda"): + """Generate valid flags of points of multiple feature levels. + + Args: + featmap_sizes (list(tuple)): List of feature map sizes in + multiple feature levels, each size arrange as + as (h, w). + pad_shape (tuple(int)): The padded shape of the image, + arrange as (h, w). + device (str): The device where the anchors will be put on. + + Return: + list(torch.Tensor): Valid flags of points of multiple levels. + """ + assert self.num_levels == len(featmap_sizes) + multi_level_flags = [] + for i in range(self.num_levels): + point_stride = self.strides[i] + feat_h, feat_w = featmap_sizes[i] + h, w = pad_shape[:2] + valid_feat_h = min(int(np.ceil(h / point_stride[1])), feat_h) + valid_feat_w = min(int(np.ceil(w / point_stride[0])), feat_w) + flags = self.single_level_valid_flags((feat_h, feat_w), (valid_feat_h, valid_feat_w), device=device) + multi_level_flags.append(flags) + return multi_level_flags + + def single_level_valid_flags(self, featmap_size, valid_size, device="cuda"): + """Generate the valid flags of points of a single feature map. + + Args: + featmap_size (tuple[int]): The size of feature maps, arrange as + as (h, w). + valid_size (tuple[int]): The valid size of the feature maps. + The size arrange as as (h, w). + device (str, optional): The device where the flags will be put on. + Defaults to 'cuda'. + + Returns: + torch.Tensor: The valid flags of each points in a single level \ + feature map. + """ + feat_h, feat_w = featmap_size + valid_h, valid_w = valid_size + assert valid_h <= feat_h and valid_w <= feat_w + valid_x = torch.zeros(feat_w, dtype=torch.bool, device=device) + valid_y = torch.zeros(feat_h, dtype=torch.bool, device=device) + valid_x[:valid_w] = 1 + valid_y[:valid_h] = 1 + valid_xx, valid_yy = self._meshgrid(valid_x, valid_y) + valid = valid_xx & valid_yy + return valid + + def sparse_priors(self, prior_idxs, featmap_size, level_idx, dtype=torch.float32, device="cuda"): + """Generate sparse points according to the ``prior_idxs``. + + Args: + prior_idxs (Tensor): The index of corresponding anchors + in the feature map. + featmap_size (tuple[int]): feature map size arrange as (w, h). + level_idx (int): The level index of corresponding feature + map. + dtype (obj:`torch.dtype`): Date type of points. Defaults to + ``torch.float32``. + device (obj:`torch.device`): The device where the points is + located. + Returns: + Tensor: Anchor with shape (N, 2), N should be equal to + the length of ``prior_idxs``. And last dimension + 2 represent (coord_x, coord_y). + """ + height, width = featmap_size + x = (prior_idxs % width + self.offset) * self.strides[level_idx][0] + y = ((prior_idxs // width) % height + self.offset) * self.strides[level_idx][1] + prioris = torch.stack([x, y], 1).to(dtype) + prioris = prioris.to(device) + return prioris diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bf35a613f81acd77ecab2dfb75a722fa8e5c0787 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .builder import * # noqa: F403 +from .samplers import MaskPseudoSampler # noqa: F403 diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/builder.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/builder.py new file mode 100644 index 0000000000000000000000000000000000000000..9538c0de3db682c2b111b085a8a1ce321c76a9ff --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/builder.py @@ -0,0 +1,19 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from mmcv.utils import Registry, build_from_cfg + +BBOX_SAMPLERS = Registry("bbox_sampler") +BBOX_CODERS = Registry("bbox_coder") + + +def build_sampler(cfg, **default_args): + """Builder of box sampler.""" + return build_from_cfg(cfg, BBOX_SAMPLERS, default_args) + + +def build_bbox_coder(cfg, **default_args): + """Builder of box coder.""" + return build_from_cfg(cfg, BBOX_CODERS, default_args) diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..19c363e3fabc365d92aeaf1e78189d710db279e9 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .mask_pseudo_sampler import MaskPseudoSampler # noqa: F403 diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/base_sampler.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/base_sampler.py new file mode 100644 index 0000000000000000000000000000000000000000..c45cec3ed7af5b49bb54b92d6e6bcf59b06b4c99 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/base_sampler.py @@ -0,0 +1,92 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from abc import ABCMeta, abstractmethod + +import torch + +from .sampling_result import SamplingResult + + +class BaseSampler(metaclass=ABCMeta): + """Base class of samplers.""" + + def __init__(self, num, pos_fraction, neg_pos_ub=-1, add_gt_as_proposals=True, **kwargs): + self.num = num + self.pos_fraction = pos_fraction + self.neg_pos_ub = neg_pos_ub + self.add_gt_as_proposals = add_gt_as_proposals + self.pos_sampler = self + self.neg_sampler = self + + @abstractmethod + def _sample_pos(self, assign_result, num_expected, **kwargs): + """Sample positive samples.""" + pass + + @abstractmethod + def _sample_neg(self, assign_result, num_expected, **kwargs): + """Sample negative samples.""" + pass + + def sample(self, assign_result, bboxes, gt_bboxes, gt_labels=None, **kwargs): + """Sample positive and negative bboxes. + + This is a simple implementation of bbox sampling given candidates, + assigning results and ground truth bboxes. + + Args: + assign_result (:obj:`AssignResult`): Bbox assigning results. + bboxes (Tensor): Boxes to be sampled from. + gt_bboxes (Tensor): Ground truth bboxes. + gt_labels (Tensor, optional): Class labels of ground truth bboxes. + + Returns: + :obj:`SamplingResult`: Sampling result. + + Example: + >>> from mmdet.core.bbox import RandomSampler + >>> from mmdet.core.bbox import AssignResult + >>> from mmdet.core.bbox.demodata import ensure_rng, random_boxes + >>> rng = ensure_rng(None) + >>> assign_result = AssignResult.random(rng=rng) + >>> bboxes = random_boxes(assign_result.num_preds, rng=rng) + >>> gt_bboxes = random_boxes(assign_result.num_gts, rng=rng) + >>> gt_labels = None + >>> self = RandomSampler(num=32, pos_fraction=0.5, neg_pos_ub=-1, + >>> add_gt_as_proposals=False) + >>> self = self.sample(assign_result, bboxes, gt_bboxes, gt_labels) + """ + if len(bboxes.shape) < 2: + bboxes = bboxes[None, :] + + bboxes = bboxes[:, :4] + + gt_flags = bboxes.new_zeros((bboxes.shape[0],), dtype=torch.uint8) + if self.add_gt_as_proposals and len(gt_bboxes) > 0: + if gt_labels is None: + raise ValueError("gt_labels must be given when add_gt_as_proposals is True") + bboxes = torch.cat([gt_bboxes, bboxes], dim=0) + assign_result.add_gt_(gt_labels) + gt_ones = bboxes.new_ones(gt_bboxes.shape[0], dtype=torch.uint8) + gt_flags = torch.cat([gt_ones, gt_flags]) + + num_expected_pos = int(self.num * self.pos_fraction) + pos_inds = self.pos_sampler._sample_pos(assign_result, num_expected_pos, bboxes=bboxes, **kwargs) + # We found that sampled indices have duplicated items occasionally. + # (may be a bug of PyTorch) + pos_inds = pos_inds.unique() + num_sampled_pos = pos_inds.numel() + num_expected_neg = self.num - num_sampled_pos + if self.neg_pos_ub >= 0: + _pos = max(1, num_sampled_pos) + neg_upper_bound = int(self.neg_pos_ub * _pos) + if num_expected_neg > neg_upper_bound: + num_expected_neg = neg_upper_bound + neg_inds = self.neg_sampler._sample_neg(assign_result, num_expected_neg, bboxes=bboxes, **kwargs) + neg_inds = neg_inds.unique() + + sampling_result = SamplingResult(pos_inds, neg_inds, bboxes, gt_bboxes, assign_result, gt_flags) + return sampling_result diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/mask_pseudo_sampler.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/mask_pseudo_sampler.py new file mode 100644 index 0000000000000000000000000000000000000000..3e67ea61ed0fd65cca0addde1893a3c1e176bf15 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/mask_pseudo_sampler.py @@ -0,0 +1,45 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/ZwwWayne/K-Net/blob/main/knet/det/mask_pseudo_sampler.py + +import torch + +from ..builder import BBOX_SAMPLERS +from .base_sampler import BaseSampler +from .mask_sampling_result import MaskSamplingResult + + +@BBOX_SAMPLERS.register_module() +class MaskPseudoSampler(BaseSampler): + """A pseudo sampler that does not do sampling actually.""" + + def __init__(self, **kwargs): + pass + + def _sample_pos(self, **kwargs): + """Sample positive samples.""" + raise NotImplementedError + + def _sample_neg(self, **kwargs): + """Sample negative samples.""" + raise NotImplementedError + + def sample(self, assign_result, masks, gt_masks, **kwargs): + """Directly returns the positive and negative indices of samples. + + Args: + assign_result (:obj:`AssignResult`): Assigned results + masks (torch.Tensor): Bounding boxes + gt_masks (torch.Tensor): Ground truth boxes + Returns: + :obj:`SamplingResult`: sampler results + """ + pos_inds = torch.nonzero(assign_result.gt_inds > 0, as_tuple=False).squeeze(-1).unique() + neg_inds = torch.nonzero(assign_result.gt_inds == 0, as_tuple=False).squeeze(-1).unique() + gt_flags = masks.new_zeros(masks.shape[0], dtype=torch.uint8) + sampling_result = MaskSamplingResult(pos_inds, neg_inds, masks, gt_masks, assign_result, gt_flags) + return sampling_result diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/mask_sampling_result.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/mask_sampling_result.py new file mode 100644 index 0000000000000000000000000000000000000000..270ffd35a5f120dd0560a7fea7fe83ef0bab66bb --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/mask_sampling_result.py @@ -0,0 +1,63 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/ZwwWayne/K-Net/blob/main/knet/det/mask_pseudo_sampler.py + +import torch + +from .sampling_result import SamplingResult + + +class MaskSamplingResult(SamplingResult): + """Mask sampling result.""" + + def __init__(self, pos_inds, neg_inds, masks, gt_masks, assign_result, gt_flags): + self.pos_inds = pos_inds + self.neg_inds = neg_inds + self.pos_masks = masks[pos_inds] + self.neg_masks = masks[neg_inds] + self.pos_is_gt = gt_flags[pos_inds] + + self.num_gts = gt_masks.shape[0] + self.pos_assigned_gt_inds = assign_result.gt_inds[pos_inds] - 1 + + if gt_masks.numel() == 0: + # hack for index error case + assert self.pos_assigned_gt_inds.numel() == 0 + self.pos_gt_masks = torch.empty_like(gt_masks) + else: + self.pos_gt_masks = gt_masks[self.pos_assigned_gt_inds, :] + + if assign_result.labels is not None: + self.pos_gt_labels = assign_result.labels[pos_inds] + else: + self.pos_gt_labels = None + + @property + def masks(self): + """torch.Tensor: concatenated positive and negative boxes""" + return torch.cat([self.pos_masks, self.neg_masks]) + + def __nice__(self): + data = self.info.copy() + data["pos_masks"] = data.pop("pos_masks").shape + data["neg_masks"] = data.pop("neg_masks").shape + parts = [f"'{k}': {v!r}" for k, v in sorted(data.items())] + body = " " + ",\n ".join(parts) + return "{\n" + body + "\n}" + + @property + def info(self): + """Returns a dictionary of info about the object.""" + return { + "pos_inds": self.pos_inds, + "neg_inds": self.neg_inds, + "pos_masks": self.pos_masks, + "neg_masks": self.neg_masks, + "pos_is_gt": self.pos_is_gt, + "num_gts": self.num_gts, + "pos_assigned_gt_inds": self.pos_assigned_gt_inds, + } diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/sampling_result.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/sampling_result.py new file mode 100644 index 0000000000000000000000000000000000000000..aaee3fe55aeb8c6da7edefbbd382d94b67b6a6b4 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/box/samplers/sampling_result.py @@ -0,0 +1,152 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch + + +class SamplingResult: + """Bbox sampling result. + + Example: + >>> # xdoctest: +IGNORE_WANT + >>> from mmdet.core.bbox.samplers.sampling_result import * # NOQA + >>> self = SamplingResult.random(rng=10) + >>> print(f'self = {self}') + self = + """ + + def __init__(self, pos_inds, neg_inds, bboxes, gt_bboxes, assign_result, gt_flags): + self.pos_inds = pos_inds + self.neg_inds = neg_inds + self.pos_bboxes = bboxes[pos_inds] + self.neg_bboxes = bboxes[neg_inds] + self.pos_is_gt = gt_flags[pos_inds] + + self.num_gts = gt_bboxes.shape[0] + self.pos_assigned_gt_inds = assign_result.gt_inds[pos_inds] - 1 + + if gt_bboxes.numel() == 0: + # hack for index error case + assert self.pos_assigned_gt_inds.numel() == 0 + self.pos_gt_bboxes = torch.empty_like(gt_bboxes).view(-1, 4) + else: + if len(gt_bboxes.shape) < 2: + gt_bboxes = gt_bboxes.view(-1, 4) + + self.pos_gt_bboxes = gt_bboxes[self.pos_assigned_gt_inds.long(), :] + + if assign_result.labels is not None: + self.pos_gt_labels = assign_result.labels[pos_inds] + else: + self.pos_gt_labels = None + + @property + def bboxes(self): + """torch.Tensor: concatenated positive and negative boxes""" + return torch.cat([self.pos_bboxes, self.neg_bboxes]) + + def to(self, device): + """Change the device of the data inplace. + + Example: + >>> self = SamplingResult.random() + >>> print(f'self = {self.to(None)}') + >>> # xdoctest: +REQUIRES(--gpu) + >>> print(f'self = {self.to(0)}') + """ + _dict = self.__dict__ + for key, value in _dict.items(): + if isinstance(value, torch.Tensor): + _dict[key] = value.to(device) + return self + + def __nice__(self): + data = self.info.copy() + data["pos_bboxes"] = data.pop("pos_bboxes").shape + data["neg_bboxes"] = data.pop("neg_bboxes").shape + parts = [f"'{k}': {v!r}" for k, v in sorted(data.items())] + body = " " + ",\n ".join(parts) + return "{\n" + body + "\n}" + + @property + def info(self): + """Returns a dictionary of info about the object.""" + return { + "pos_inds": self.pos_inds, + "neg_inds": self.neg_inds, + "pos_bboxes": self.pos_bboxes, + "neg_bboxes": self.neg_bboxes, + "pos_is_gt": self.pos_is_gt, + "num_gts": self.num_gts, + "pos_assigned_gt_inds": self.pos_assigned_gt_inds, + } + + @classmethod + def random(cls, rng=None, **kwargs): + """ + Args: + rng (None | int | numpy.random.RandomState): seed or state. + kwargs (keyword arguments): + - num_preds: number of predicted boxes + - num_gts: number of true boxes + - p_ignore (float): probability of a predicted box assigned to \ + an ignored truth. + - p_assigned (float): probability of a predicted box not being \ + assigned. + - p_use_label (float | bool): with labels or not. + + Returns: + :obj:`SamplingResult`: Randomly generated sampling result. + + Example: + >>> from mmdet.core.bbox.samplers.sampling_result import * # NOQA + >>> self = SamplingResult.random() + >>> print(self.__dict__) + """ + from mmdet.core.bbox import demodata + from mmdet.core.bbox.assigners.assign_result import AssignResult + from mmdet.core.bbox.samplers.random_sampler import RandomSampler + + rng = demodata.ensure_rng(rng) + + # make probabalistic? + num = 32 + pos_fraction = 0.5 + neg_pos_ub = -1 + + assign_result = AssignResult.random(rng=rng, **kwargs) + + # Note we could just compute an assignment + bboxes = demodata.random_boxes(assign_result.num_preds, rng=rng) + gt_bboxes = demodata.random_boxes(assign_result.num_gts, rng=rng) + + if rng.rand() > 0.2: + # sometimes algorithms squeeze their data, be robust to that + gt_bboxes = gt_bboxes.squeeze() + bboxes = bboxes.squeeze() + + if assign_result.labels is None: + gt_labels = None + else: + gt_labels = None + + if gt_labels is None: + add_gt_as_proposals = False + else: + add_gt_as_proposals = True # make probabalistic? + + sampler = RandomSampler( + num, pos_fraction, neg_pos_ub=neg_pos_ub, add_gt_as_proposals=add_gt_as_proposals, rng=rng + ) + self = sampler.sample(assign_result, bboxes, gt_bboxes, gt_labels) + return self diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/utils/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6cdc9e19352f50bc2d5433c412ff71186c5df019 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/utils/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .dist_utils import reduce_mean +from .misc import add_prefix, multi_apply diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/utils/dist_utils.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/utils/dist_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..7dfed42da821cd94e31b663d86b20b8f09799b30 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/utils/dist_utils.py @@ -0,0 +1,15 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch.distributed as dist + + +def reduce_mean(tensor): + """ "Obtain the mean of tensor on different GPUs.""" + if not (dist.is_available() and dist.is_initialized()): + return tensor + tensor = tensor.clone() + dist.all_reduce(tensor.div_(dist.get_world_size()), op=dist.ReduceOp.SUM) + return tensor diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/core/utils/misc.py b/OpenMidnight/dinov2/eval/segmentation_m2f/core/utils/misc.py new file mode 100644 index 0000000000000000000000000000000000000000..e07579e7b182b62153e81fe637ffd0f3081ef2a3 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/core/utils/misc.py @@ -0,0 +1,47 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from functools import partial + + +def multi_apply(func, *args, **kwargs): + """Apply function to a list of arguments. + + Note: + This function applies the ``func`` to multiple inputs and + map the multiple outputs of the ``func`` into different + list. Each list contains the same type of outputs corresponding + to different inputs. + + Args: + func (Function): A function that will be applied to a list of + arguments + + Returns: + tuple(list): A tuple containing multiple list, each list contains \ + a kind of returned results by the function + """ + pfunc = partial(func, **kwargs) if kwargs else func + map_results = map(pfunc, *args) + return tuple(map(list, zip(*map_results))) + + +def add_prefix(inputs, prefix): + """Add prefix for dict. + + Args: + inputs (dict): The input dict with str keys. + prefix (str): The prefix to add. + + Returns: + + dict: The dict with keys updated with ``prefix``. + """ + + outputs = dict() + for name, value in inputs.items(): + outputs[f"{prefix}.{name}"] = value + + return outputs diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ed89bb0064d82b4360af020798eab3d2f5a47937 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/__init__.py @@ -0,0 +1,11 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .backbones import * # noqa: F403 +from .builder import MASK_ASSIGNERS, MATCH_COST, TRANSFORMER, build_assigner, build_match_cost +from .decode_heads import * # noqa: F403 +from .losses import * # noqa: F403 +from .plugins import * # noqa: F403 +from .segmentors import * # noqa: F403 diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c4bf73bcbcee710676f81cb6517ae787f4d61cc6 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .vit_adapter import ViTAdapter diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/adapter_modules.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/adapter_modules.py new file mode 100644 index 0000000000000000000000000000000000000000..26bfdf8f6ae6c107d22d61985cce34d4b5ce275f --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/adapter_modules.py @@ -0,0 +1,442 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from functools import partial + +import torch +import torch.nn as nn +import torch.utils.checkpoint as cp + +from ...ops.modules import MSDeformAttn +from .drop_path import DropPath + + +def get_reference_points(spatial_shapes, device): + reference_points_list = [] + for lvl, (H_, W_) in enumerate(spatial_shapes): + ref_y, ref_x = torch.meshgrid( + torch.linspace(0.5, H_ - 0.5, H_, dtype=torch.float32, device=device), + torch.linspace(0.5, W_ - 0.5, W_, dtype=torch.float32, device=device), + ) + ref_y = ref_y.reshape(-1)[None] / H_ + ref_x = ref_x.reshape(-1)[None] / W_ + ref = torch.stack((ref_x, ref_y), -1) + reference_points_list.append(ref) + reference_points = torch.cat(reference_points_list, 1) + reference_points = reference_points[:, :, None] + return reference_points + + +def deform_inputs(x, patch_size): + bs, c, h, w = x.shape + spatial_shapes = torch.as_tensor( + [(h // 8, w // 8), (h // 16, w // 16), (h // 32, w // 32)], dtype=torch.long, device=x.device + ) + level_start_index = torch.cat((spatial_shapes.new_zeros((1,)), spatial_shapes.prod(1).cumsum(0)[:-1])) + reference_points = get_reference_points([(h // patch_size, w // patch_size)], x.device) + deform_inputs1 = [reference_points, spatial_shapes, level_start_index] + + spatial_shapes = torch.as_tensor([(h // patch_size, w // patch_size)], dtype=torch.long, device=x.device) + level_start_index = torch.cat((spatial_shapes.new_zeros((1,)), spatial_shapes.prod(1).cumsum(0)[:-1])) + reference_points = get_reference_points([(h // 8, w // 8), (h // 16, w // 16), (h // 32, w // 32)], x.device) + deform_inputs2 = [reference_points, spatial_shapes, level_start_index] + + return deform_inputs1, deform_inputs2 + + +class ConvFFN(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.0): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features) + self.dwconv = DWConv(hidden_features) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features) + self.drop = nn.Dropout(drop) + + def forward(self, x, H, W): + x = self.fc1(x) + x = self.dwconv(x, H, W) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + +class DWConv(nn.Module): + def __init__(self, dim=768): + super().__init__() + self.dwconv = nn.Conv2d(dim, dim, 3, 1, 1, bias=True, groups=dim) + + def forward(self, x, H, W): + B, N, C = x.shape + n = N // 21 + x1 = x[:, 0 : 16 * n, :].transpose(1, 2).view(B, C, H * 2, W * 2).contiguous() + x2 = x[:, 16 * n : 20 * n, :].transpose(1, 2).view(B, C, H, W).contiguous() + x3 = x[:, 20 * n :, :].transpose(1, 2).view(B, C, H // 2, W // 2).contiguous() + x1 = self.dwconv(x1).flatten(2).transpose(1, 2) + x2 = self.dwconv(x2).flatten(2).transpose(1, 2) + x3 = self.dwconv(x3).flatten(2).transpose(1, 2) + x = torch.cat([x1, x2, x3], dim=1) + return x + + +class Extractor(nn.Module): + def __init__( + self, + dim, + num_heads=6, + n_points=4, + n_levels=1, + deform_ratio=1.0, + with_cffn=True, + cffn_ratio=0.25, + drop=0.0, + drop_path=0.0, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + with_cp=False, + ): + super().__init__() + self.query_norm = norm_layer(dim) + self.feat_norm = norm_layer(dim) + self.attn = MSDeformAttn( + d_model=dim, n_levels=n_levels, n_heads=num_heads, n_points=n_points, ratio=deform_ratio + ) + self.with_cffn = with_cffn + self.with_cp = with_cp + if with_cffn: + self.ffn = ConvFFN(in_features=dim, hidden_features=int(dim * cffn_ratio), drop=drop) + self.ffn_norm = norm_layer(dim) + self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + + def forward(self, query, reference_points, feat, spatial_shapes, level_start_index, H, W): + def _inner_forward(query, feat): + + attn = self.attn( + self.query_norm(query), reference_points, self.feat_norm(feat), spatial_shapes, level_start_index, None + ) + query = query + attn + + if self.with_cffn: + query = query + self.drop_path(self.ffn(self.ffn_norm(query), H, W)) + return query + + if self.with_cp and query.requires_grad: + query = cp.checkpoint(_inner_forward, query, feat) + else: + query = _inner_forward(query, feat) + + return query + + +class Injector(nn.Module): + def __init__( + self, + dim, + num_heads=6, + n_points=4, + n_levels=1, + deform_ratio=1.0, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + init_values=0.0, + with_cp=False, + ): + super().__init__() + self.with_cp = with_cp + self.query_norm = norm_layer(dim) + self.feat_norm = norm_layer(dim) + self.attn = MSDeformAttn( + d_model=dim, n_levels=n_levels, n_heads=num_heads, n_points=n_points, ratio=deform_ratio + ) + self.gamma = nn.Parameter(init_values * torch.ones((dim)), requires_grad=True) + + def forward(self, query, reference_points, feat, spatial_shapes, level_start_index): + def _inner_forward(query, feat): + + attn = self.attn( + self.query_norm(query), reference_points, self.feat_norm(feat), spatial_shapes, level_start_index, None + ) + return query + self.gamma * attn + + if self.with_cp and query.requires_grad: + query = cp.checkpoint(_inner_forward, query, feat) + else: + query = _inner_forward(query, feat) + + return query + + +class InteractionBlock(nn.Module): + def __init__( + self, + dim, + num_heads=6, + n_points=4, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + drop=0.0, + drop_path=0.0, + with_cffn=True, + cffn_ratio=0.25, + init_values=0.0, + deform_ratio=1.0, + extra_extractor=False, + with_cp=False, + ): + super().__init__() + + self.injector = Injector( + dim=dim, + n_levels=3, + num_heads=num_heads, + init_values=init_values, + n_points=n_points, + norm_layer=norm_layer, + deform_ratio=deform_ratio, + with_cp=with_cp, + ) + self.extractor = Extractor( + dim=dim, + n_levels=1, + num_heads=num_heads, + n_points=n_points, + norm_layer=norm_layer, + deform_ratio=deform_ratio, + with_cffn=with_cffn, + cffn_ratio=cffn_ratio, + drop=drop, + drop_path=drop_path, + with_cp=with_cp, + ) + if extra_extractor: + self.extra_extractors = nn.Sequential( + *[ + Extractor( + dim=dim, + num_heads=num_heads, + n_points=n_points, + norm_layer=norm_layer, + with_cffn=with_cffn, + cffn_ratio=cffn_ratio, + deform_ratio=deform_ratio, + drop=drop, + drop_path=drop_path, + with_cp=with_cp, + ) + for _ in range(2) + ] + ) + else: + self.extra_extractors = None + + def forward(self, x, c, blocks, deform_inputs1, deform_inputs2, H_c, W_c, H_toks, W_toks): + x = self.injector( + query=x, + reference_points=deform_inputs1[0], + feat=c, + spatial_shapes=deform_inputs1[1], + level_start_index=deform_inputs1[2], + ) + for idx, blk in enumerate(blocks): + x = blk(x, H_toks, W_toks) + c = self.extractor( + query=c, + reference_points=deform_inputs2[0], + feat=x, + spatial_shapes=deform_inputs2[1], + level_start_index=deform_inputs2[2], + H=H_c, + W=W_c, + ) + if self.extra_extractors is not None: + for extractor in self.extra_extractors: + c = extractor( + query=c, + reference_points=deform_inputs2[0], + feat=x, + spatial_shapes=deform_inputs2[1], + level_start_index=deform_inputs2[2], + H=H_c, + W=W_c, + ) + return x, c + + +class InteractionBlockWithCls(nn.Module): + def __init__( + self, + dim, + num_heads=6, + n_points=4, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + drop=0.0, + drop_path=0.0, + with_cffn=True, + cffn_ratio=0.25, + init_values=0.0, + deform_ratio=1.0, + extra_extractor=False, + with_cp=False, + ): + super().__init__() + + self.injector = Injector( + dim=dim, + n_levels=3, + num_heads=num_heads, + init_values=init_values, + n_points=n_points, + norm_layer=norm_layer, + deform_ratio=deform_ratio, + with_cp=with_cp, + ) + self.extractor = Extractor( + dim=dim, + n_levels=1, + num_heads=num_heads, + n_points=n_points, + norm_layer=norm_layer, + deform_ratio=deform_ratio, + with_cffn=with_cffn, + cffn_ratio=cffn_ratio, + drop=drop, + drop_path=drop_path, + with_cp=with_cp, + ) + if extra_extractor: + self.extra_extractors = nn.Sequential( + *[ + Extractor( + dim=dim, + num_heads=num_heads, + n_points=n_points, + norm_layer=norm_layer, + with_cffn=with_cffn, + cffn_ratio=cffn_ratio, + deform_ratio=deform_ratio, + drop=drop, + drop_path=drop_path, + with_cp=with_cp, + ) + for _ in range(2) + ] + ) + else: + self.extra_extractors = None + + def forward(self, x, c, cls, blocks, deform_inputs1, deform_inputs2, H_c, W_c, H_toks, W_toks): + x = self.injector( + query=x, + reference_points=deform_inputs1[0], + feat=c, + spatial_shapes=deform_inputs1[1], + level_start_index=deform_inputs1[2], + ) + x = torch.cat((cls, x), dim=1) + for idx, blk in enumerate(blocks): + x = blk(x, H_toks, W_toks) + cls, x = ( + x[ + :, + :1, + ], + x[ + :, + 1:, + ], + ) + c = self.extractor( + query=c, + reference_points=deform_inputs2[0], + feat=x, + spatial_shapes=deform_inputs2[1], + level_start_index=deform_inputs2[2], + H=H_c, + W=W_c, + ) + if self.extra_extractors is not None: + for extractor in self.extra_extractors: + c = extractor( + query=c, + reference_points=deform_inputs2[0], + feat=x, + spatial_shapes=deform_inputs2[1], + level_start_index=deform_inputs2[2], + H=H_c, + W=W_c, + ) + return x, c, cls + + +class SpatialPriorModule(nn.Module): + def __init__(self, inplanes=64, embed_dim=384, with_cp=False): + super().__init__() + self.with_cp = with_cp + + self.stem = nn.Sequential( + *[ + nn.Conv2d(3, inplanes, kernel_size=3, stride=2, padding=1, bias=False), + nn.SyncBatchNorm(inplanes), + nn.ReLU(inplace=True), + nn.Conv2d(inplanes, inplanes, kernel_size=3, stride=1, padding=1, bias=False), + nn.SyncBatchNorm(inplanes), + nn.ReLU(inplace=True), + nn.Conv2d(inplanes, inplanes, kernel_size=3, stride=1, padding=1, bias=False), + nn.SyncBatchNorm(inplanes), + nn.ReLU(inplace=True), + nn.MaxPool2d(kernel_size=3, stride=2, padding=1), + ] + ) + self.conv2 = nn.Sequential( + *[ + nn.Conv2d(inplanes, 2 * inplanes, kernel_size=3, stride=2, padding=1, bias=False), + nn.SyncBatchNorm(2 * inplanes), + nn.ReLU(inplace=True), + ] + ) + self.conv3 = nn.Sequential( + *[ + nn.Conv2d(2 * inplanes, 4 * inplanes, kernel_size=3, stride=2, padding=1, bias=False), + nn.SyncBatchNorm(4 * inplanes), + nn.ReLU(inplace=True), + ] + ) + self.conv4 = nn.Sequential( + *[ + nn.Conv2d(4 * inplanes, 4 * inplanes, kernel_size=3, stride=2, padding=1, bias=False), + nn.SyncBatchNorm(4 * inplanes), + nn.ReLU(inplace=True), + ] + ) + self.fc1 = nn.Conv2d(inplanes, embed_dim, kernel_size=1, stride=1, padding=0, bias=True) + self.fc2 = nn.Conv2d(2 * inplanes, embed_dim, kernel_size=1, stride=1, padding=0, bias=True) + self.fc3 = nn.Conv2d(4 * inplanes, embed_dim, kernel_size=1, stride=1, padding=0, bias=True) + self.fc4 = nn.Conv2d(4 * inplanes, embed_dim, kernel_size=1, stride=1, padding=0, bias=True) + + def forward(self, x): + def _inner_forward(x): + c1 = self.stem(x) + c2 = self.conv2(c1) + c3 = self.conv3(c2) + c4 = self.conv4(c3) + c1 = self.fc1(c1) + c2 = self.fc2(c2) + c3 = self.fc3(c3) + c4 = self.fc4(c4) + + bs, dim, _, _ = c1.shape + # c1 = c1.view(bs, dim, -1).transpose(1, 2) # 4s + c2 = c2.view(bs, dim, -1).transpose(1, 2) # 8s + c3 = c3.view(bs, dim, -1).transpose(1, 2) # 16s + c4 = c4.view(bs, dim, -1).transpose(1, 2) # 32s + + return c1, c2, c3, c4 + + if self.with_cp and x.requires_grad: + outs = cp.checkpoint(_inner_forward, x) + else: + outs = _inner_forward(x) + return outs diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/drop_path.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/drop_path.py new file mode 100644 index 0000000000000000000000000000000000000000..864eb8738c44652d12b979fc811503f21cbb00dd --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/drop_path.py @@ -0,0 +1,32 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/drop.py + +from torch import nn + + +def drop_path(x, drop_prob: float = 0.0, training: bool = False): + if drop_prob == 0.0 or not training: + return x + keep_prob = 1 - drop_prob + shape = (x.shape[0],) + (1,) * (x.ndim - 1) # work with diff dim tensors, not just 2D ConvNets + random_tensor = x.new_empty(shape).bernoulli_(keep_prob) + if keep_prob > 0.0: + random_tensor.div_(keep_prob) + return x * random_tensor + + +class DropPath(nn.Module): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).""" + + def __init__(self, drop_prob: float = 0.0): + super(DropPath, self).__init__() + self.drop_prob = drop_prob + + def forward(self, x): + return drop_path(x, self.drop_prob, self.training) diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/vit.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/vit.py new file mode 100644 index 0000000000000000000000000000000000000000..8a147570451bd2fbd016ddfafbbfa33035cbd4f8 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/vit.py @@ -0,0 +1,552 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +"""Vision Transformer (ViT) in PyTorch. + +A PyTorch implement of Vision Transformers as described in: + +'An Image Is Worth 16 x 16 Words: Transformers for Image Recognition at Scale' + - https://arxiv.org/abs/2010.11929 + +`How to train your ViT? Data, Augmentation, and Regularization in Vision Transformers` + - https://arxiv.org/abs/2106.10270 + +The official jax code is released and available at https://github.com/google-research/vision_transformer + +DeiT model defs and weights from https://github.com/facebookresearch/deit, +paper `DeiT: Data-efficient Image Transformers` - https://arxiv.org/abs/2012.12877 + +Acknowledgments: +* The paper authors for releasing code and weights, thanks! +* I fixed my class token impl based on Phil Wang's https://github.com/lucidrains/vit-pytorch ... check it out +for some einops/einsum fun +* Simple transformer style inspired by Andrej Karpathy's https://github.com/karpathy/minGPT +* Bert reference code checks against Huggingface Transformers and Tensorflow Bert + +Hacked together by / Copyright 2021 Ross Wightman +""" +import logging +import math +from functools import partial +from itertools import repeat +from typing import Callable, Optional + +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.utils.checkpoint as cp +from mmcv.runner import BaseModule, load_checkpoint +from mmseg.ops import resize +from mmseg.utils import get_root_logger +from torch import Tensor + +from .drop_path import DropPath + + +def to_2tuple(x): + return tuple(repeat(x, 2)) + + +class Mlp(nn.Module): + def __init__( + self, + in_features: int, + hidden_features: Optional[int] = None, + out_features: Optional[int] = None, + act_layer: Callable[..., nn.Module] = nn.GELU, + drop: float = 0.0, + bias: bool = True, + ) -> None: + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features, bias=bias) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features, bias=bias) + self.drop = nn.Dropout(drop) + + def forward(self, x: Tensor) -> Tensor: + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + +class SwiGLUFFN(nn.Module): + def __init__( + self, + in_features: int, + hidden_features: Optional[int] = None, + out_features: Optional[int] = None, + act_layer: Callable[..., nn.Module] = None, + drop: float = 0.0, + ) -> None: + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + swiglu_hidden_features = int(2 * hidden_features / 3) + align_as = 8 + swiglu_hidden_features = (swiglu_hidden_features + align_as - 1) // align_as * align_as + self.w1 = nn.Linear(in_features, swiglu_hidden_features) + self.w2 = nn.Linear(in_features, swiglu_hidden_features) + self.w3 = nn.Linear(swiglu_hidden_features, out_features) + + def forward(self, x: Tensor) -> Tensor: + x1 = self.w1(x) + x2 = self.w2(x) + hidden = F.silu(x1) * x2 + return self.w3(hidden) + + +class PatchEmbed(nn.Module): + """2D Image to Patch Embedding.""" + + def __init__( + self, img_size=224, patch_size=16, in_chans=3, embed_dim=768, norm_layer=None, flatten=True, bias=True + ): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + self.img_size = img_size + self.patch_size = patch_size + self.grid_size = (img_size[0] // patch_size[0], img_size[1] // patch_size[1]) + self.num_patches = self.grid_size[0] * self.grid_size[1] + self.flatten = flatten + + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size, bias=bias) + self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity() + + def forward(self, x): + x = self.proj(x) + _, _, H, W = x.shape + if self.flatten: + x = x.flatten(2).transpose(1, 2) # BCHW -> BNC + x = self.norm(x) + return x, H, W + + +class Attention(nn.Module): + def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0.0, proj_drop=0.0): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + self.scale = head_dim**-0.5 + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + + def forward(self, x, H, W): + B, N, C = x.shape + qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4) + q, k, v = qkv.unbind(0) # make torchscript happy (cannot use tensor as tuple) + + attn = (q @ k.transpose(-2, -1)) * self.scale + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) + + x = (attn @ v).transpose(1, 2).reshape(B, N, C) + x = self.proj(x) + x = self.proj_drop(x) + return x + + +class MemEffAttention(nn.Module): + def __init__( + self, + dim: int, + num_heads: int = 8, + qkv_bias: bool = False, + attn_drop: float = 0.0, + proj_drop: float = 0.0, + ) -> None: + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + self.scale = head_dim**-0.5 + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + + def forward(self, x: Tensor, H, W) -> Tensor: + from xformers.ops import memory_efficient_attention, unbind + + B, N, C = x.shape + qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads) + + q, k, v = unbind(qkv, 2) + + x = memory_efficient_attention(q, k, v) + x = x.reshape([B, N, C]) + + x = self.proj(x) + x = self.proj_drop(x) + return x + + +def window_partition(x, window_size): + """ + Args: + x: (B, H, W, C) + window_size (int): window size + Returns: + windows: (num_windows*B, window_size, window_size, C) + """ + B, H, W, C = x.shape + x = x.view(B, H // window_size, window_size, W // window_size, window_size, C) + windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C) + return windows + + +def window_reverse(windows, window_size, H, W): + """ + Args: + windows: (num_windows*B, window_size, window_size, C) + window_size (int): Window size + H (int): Height of image + W (int): Width of image + Returns: + x: (B, H, W, C) + """ + B = int(windows.shape[0] / (H * W / window_size / window_size)) + x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1) + x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1) + return x + + +class WindowedAttention(nn.Module): + def __init__( + self, dim, num_heads=8, qkv_bias=False, attn_drop=0.0, proj_drop=0.0, window_size=14, pad_mode="constant" + ): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + self.scale = head_dim**-0.5 + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + self.window_size = window_size + self.pad_mode = pad_mode + + def forward(self, x, H, W): + B, N, C = x.shape + N_ = self.window_size * self.window_size + H_ = math.ceil(H / self.window_size) * self.window_size + W_ = math.ceil(W / self.window_size) * self.window_size + + qkv = self.qkv(x) # [B, N, C] + qkv = qkv.transpose(1, 2).reshape(B, C * 3, H, W) # [B, C, H, W] + qkv = F.pad(qkv, [0, W_ - W, 0, H_ - H], mode=self.pad_mode) + + qkv = F.unfold( + qkv, kernel_size=(self.window_size, self.window_size), stride=(self.window_size, self.window_size) + ) + B, C_kw_kw, L = qkv.shape # L - the num of windows + qkv = qkv.reshape(B, C * 3, N_, L).permute(0, 3, 2, 1) # [B, L, N_, C] + qkv = qkv.reshape(B, L, N_, 3, self.num_heads, C // self.num_heads).permute(3, 0, 1, 4, 2, 5) + q, k, v = qkv.unbind(0) # make torchscript happy (cannot use tensor as tuple) + + # q,k,v [B, L, num_head, N_, C/num_head] + attn = (q @ k.transpose(-2, -1)) * self.scale # [B, L, num_head, N_, N_] + # if self.mask: + # attn = attn * mask + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) # [B, L, num_head, N_, N_] + # attn @ v = [B, L, num_head, N_, C/num_head] + x = (attn @ v).permute(0, 2, 4, 3, 1).reshape(B, C_kw_kw // 3, L) + + x = F.fold( + x, + output_size=(H_, W_), + kernel_size=(self.window_size, self.window_size), + stride=(self.window_size, self.window_size), + ) # [B, C, H_, W_] + x = x[:, :, :H, :W].reshape(B, C, N).transpose(-1, -2) + x = self.proj(x) + x = self.proj_drop(x) + return x + + +# class WindowedAttention(nn.Module): +# def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0., proj_drop=0., window_size=14, pad_mode="constant"): +# super().__init__() +# self.num_heads = num_heads +# head_dim = dim // num_heads +# self.scale = head_dim ** -0.5 +# +# self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) +# self.attn_drop = nn.Dropout(attn_drop) +# self.proj = nn.Linear(dim, dim) +# self.proj_drop = nn.Dropout(proj_drop) +# self.window_size = window_size +# self.pad_mode = pad_mode +# +# def forward(self, x, H, W): +# B, N, C = x.shape +# +# N_ = self.window_size * self.window_size +# H_ = math.ceil(H / self.window_size) * self.window_size +# W_ = math.ceil(W / self.window_size) * self.window_size +# x = x.view(B, H, W, C) +# x = F.pad(x, [0, 0, 0, W_ - W, 0, H_- H], mode=self.pad_mode) +# +# x = window_partition(x, window_size=self.window_size)# nW*B, window_size, window_size, C +# x = x.view(-1, N_, C) +# +# qkv = self.qkv(x).view(-1, N_, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4) +# q, k, v = qkv.unbind(0) # make torchscript happy (cannot use tensor as tuple) +# attn = (q @ k.transpose(-2, -1)) * self.scale # [B, L, num_head, N_, N_] +# attn = attn.softmax(dim=-1) +# attn = self.attn_drop(attn) # [B, L, num_head, N_, N_] +# x = (attn @ v).transpose(1, 2).reshape(-1, self.window_size, self.window_size, C) +# +# x = window_reverse(x, self.window_size, H_, W_) +# x = x[:, :H, :W, :].reshape(B, N, C).contiguous() +# x = self.proj(x) +# x = self.proj_drop(x) +# return x + + +class Block(nn.Module): + def __init__( + self, + dim, + num_heads, + mlp_ratio=4.0, + qkv_bias=False, + drop=0.0, + attn_drop=0.0, + drop_path=0.0, + act_layer=nn.GELU, + norm_layer=nn.LayerNorm, + windowed=False, + window_size=14, + pad_mode="constant", + layer_scale=False, + with_cp=False, + ffn_layer=Mlp, + memeff=False, + ): + super().__init__() + self.with_cp = with_cp + self.norm1 = norm_layer(dim) + if windowed: + self.attn = WindowedAttention( + dim, + num_heads=num_heads, + qkv_bias=qkv_bias, + attn_drop=attn_drop, + proj_drop=drop, + window_size=window_size, + pad_mode=pad_mode, + ) + elif memeff: + self.attn = MemEffAttention( + dim, num_heads=num_heads, qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=drop + ) + else: + self.attn = Attention(dim, num_heads=num_heads, qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=drop) + # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here + self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + self.norm2 = norm_layer(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = ffn_layer(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) + self.layer_scale = layer_scale + if layer_scale: + self.gamma1 = nn.Parameter(torch.ones((dim)), requires_grad=True) + self.gamma2 = nn.Parameter(torch.ones((dim)), requires_grad=True) + + def forward(self, x, H, W): + def _inner_forward(x): + if self.layer_scale: + x = x + self.drop_path(self.gamma1 * self.attn(self.norm1(x), H, W)) + x = x + self.drop_path(self.gamma2 * self.mlp(self.norm2(x))) + else: + x = x + self.drop_path(self.attn(self.norm1(x), H, W)) + x = x + self.drop_path(self.mlp(self.norm2(x))) + return x + + if self.with_cp and x.requires_grad: + x = cp.checkpoint(_inner_forward, x) + else: + x = _inner_forward(x) + + return x + + +class TIMMVisionTransformer(BaseModule): + """Vision Transformer. + + A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale` + - https://arxiv.org/abs/2010.11929 + + Includes distillation token & head support for `DeiT: Data-efficient Image Transformers` + - https://arxiv.org/abs/2012.12877 + """ + + def __init__( + self, + img_size=224, + patch_size=16, + in_chans=3, + num_classes=1000, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4.0, + qkv_bias=True, + drop_rate=0.0, + attn_drop_rate=0.0, + drop_path_rate=0.0, + layer_scale=True, + embed_layer=PatchEmbed, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + act_layer=nn.GELU, + window_attn=False, + window_size=14, + pretrained=None, + with_cp=False, + pre_norm=False, + ffn_type="mlp", + memeff=False, + ): + """ + Args: + img_size (int, tuple): input image size + patch_size (int, tuple): patch size + in_chans (int): number of input channels + num_classes (int): number of classes for classification head + embed_dim (int): embedding dimension + depth (int): depth of transformer + num_heads (int): number of attention heads + mlp_ratio (int): ratio of mlp hidden dim to embedding dim + qkv_bias (bool): enable bias for qkv if True + drop_rate (float): dropout rate + attn_drop_rate (float): attention dropout rate + drop_path_rate (float): stochastic depth rate + embed_layer (nn.Module): patch embedding layer + norm_layer: (nn.Module): normalization layer + pretrained: (str): pretrained path + """ + super().__init__() + self.num_classes = num_classes + self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models + self.num_tokens = 1 + norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6) + act_layer = act_layer or nn.GELU + self.norm_layer = norm_layer + self.act_layer = act_layer + self.pretrain_size = img_size + self.drop_path_rate = drop_path_rate + self.drop_rate = drop_rate + self.patch_size = patch_size + + window_attn = [window_attn] * depth if not isinstance(window_attn, list) else window_attn + window_size = [window_size] * depth if not isinstance(window_size, list) else window_size + logging.info("window attention:", window_attn) + logging.info("window size:", window_size) + logging.info("layer scale:", layer_scale) + + self.patch_embed = embed_layer( + img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim, bias=not pre_norm + ) + num_patches = self.patch_embed.num_patches + + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim)) + self.pos_drop = nn.Dropout(p=drop_rate) + + ffn_types = {"mlp": Mlp, "swiglu": SwiGLUFFN} + + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)] # stochastic depth decay rule + self.blocks = nn.Sequential( + *[ + Block( + dim=embed_dim, + num_heads=num_heads, + mlp_ratio=mlp_ratio, + qkv_bias=qkv_bias, + drop=drop_rate, + attn_drop=attn_drop_rate, + drop_path=dpr[i], + norm_layer=norm_layer, + act_layer=act_layer, + windowed=window_attn[i], + window_size=window_size[i], + layer_scale=layer_scale, + with_cp=with_cp, + ffn_layer=ffn_types[ffn_type], + memeff=memeff, + ) + for i in range(depth) + ] + ) + + # self.norm = norm_layer(embed_dim) + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + # For CLIP + if pre_norm: + norm_pre = norm_layer(embed_dim) + self.norm_pre = norm_pre + else: + self.norm_pre = nn.Identity() + self.init_weights(pretrained) + + def init_weights(self, pretrained=None): + if isinstance(pretrained, str): + logger = get_root_logger() + load_checkpoint(self, pretrained, map_location="cpu", strict=False, logger=logger) + + def forward_features(self, x): + x, H, W = self.patch_embed(x) + cls_token = self.cls_token.expand(x.shape[0], -1, -1) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_token, x), dim=1) + x = self.pos_drop(x + self.pos_embed) + + # For CLIP + x = self.norm_pre(x) + + for blk in self.blocks: + x = blk(x, H, W) + x = self.norm(x) + return x + + def forward(self, x): + x = self.forward_features(x) + return x + + @staticmethod + def resize_pos_embed(pos_embed, input_shpae, pos_shape, mode): + """Resize pos_embed weights. + + Resize pos_embed using bicubic interpolate method. + Args: + pos_embed (torch.Tensor): Position embedding weights. + input_shpae (tuple): Tuple for (downsampled input image height, + downsampled input image width). + pos_shape (tuple): The resolution of downsampled origin training + image. + mode (str): Algorithm used for upsampling: + ``'nearest'`` | ``'linear'`` | ``'bilinear'`` | ``'bicubic'`` | + ``'trilinear'``. Default: ``'nearest'`` + Return: + torch.Tensor: The resized pos_embed of shape [B, L_new, C] + """ + assert pos_embed.ndim == 3, "shape of pos_embed must be [B, L, C]" + pos_h, pos_w = pos_shape + # keep dim for easy deployment + cls_token_weight = pos_embed[:, 0:1] + pos_embed_weight = pos_embed[:, (-1 * pos_h * pos_w) :] + pos_embed_weight = pos_embed_weight.reshape(1, pos_h, pos_w, pos_embed.shape[2]).permute(0, 3, 1, 2) + pos_embed_weight = resize(pos_embed_weight, size=input_shpae, align_corners=False, mode=mode) + pos_embed_weight = torch.flatten(pos_embed_weight, 2).transpose(1, 2) + pos_embed = torch.cat((cls_token_weight, pos_embed_weight), dim=1) + return pos_embed diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/vit_adapter.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/vit_adapter.py new file mode 100644 index 0000000000000000000000000000000000000000..ebc4f0f65e04ed764464d141607b3b2073220f6b --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/backbones/vit_adapter.py @@ -0,0 +1,217 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmseg.models.builder import BACKBONES +from torch.nn.init import normal_ + +from ...ops.modules import MSDeformAttn +from .adapter_modules import InteractionBlock, InteractionBlockWithCls, SpatialPriorModule, deform_inputs +from .vit import TIMMVisionTransformer + + +@BACKBONES.register_module() +class ViTAdapter(TIMMVisionTransformer): + def __init__( + self, + pretrain_size=224, + num_heads=12, + conv_inplane=64, + n_points=4, + deform_num_heads=6, + init_values=0.0, + interaction_indexes=None, + with_cffn=True, + cffn_ratio=0.25, + deform_ratio=1.0, + add_vit_feature=True, + pretrained=None, + use_extra_extractor=True, + freeze_vit=False, + use_cls=True, + with_cp=False, + *args, + **kwargs + ): + + super().__init__(num_heads=num_heads, pretrained=pretrained, with_cp=with_cp, *args, **kwargs) + if freeze_vit: + for param in self.parameters(): + param.requires_grad = False + + # self.num_classes = 80 + self.use_cls = use_cls + if not self.use_cls: + self.cls_token = None + self.num_block = len(self.blocks) + self.pretrain_size = (pretrain_size, pretrain_size) + self.interaction_indexes = interaction_indexes + self.add_vit_feature = add_vit_feature + embed_dim = self.embed_dim + + block_fn = InteractionBlockWithCls if use_cls else InteractionBlock + + self.level_embed = nn.Parameter(torch.zeros(3, embed_dim)) + self.spm = SpatialPriorModule(inplanes=conv_inplane, embed_dim=embed_dim, with_cp=False) + self.interactions = nn.Sequential( + *[ + block_fn( + dim=embed_dim, + num_heads=deform_num_heads, + n_points=n_points, + init_values=init_values, + drop_path=self.drop_path_rate, + norm_layer=self.norm_layer, + with_cffn=with_cffn, + cffn_ratio=cffn_ratio, + deform_ratio=deform_ratio, + extra_extractor=((True if i == len(interaction_indexes) - 1 else False) and use_extra_extractor), + with_cp=with_cp, + ) + for i in range(len(interaction_indexes)) + ] + ) + self.up = nn.ConvTranspose2d(embed_dim, embed_dim, 2, 2) + self.norm1 = nn.SyncBatchNorm(embed_dim) + self.norm2 = nn.SyncBatchNorm(embed_dim) + self.norm3 = nn.SyncBatchNorm(embed_dim) + self.norm4 = nn.SyncBatchNorm(embed_dim) + + self.up.apply(self._init_weights) + self.spm.apply(self._init_weights) + self.interactions.apply(self._init_weights) + self.apply(self._init_deform_weights) + normal_(self.level_embed) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + torch.nn.init.trunc_normal_(m.weight, std=0.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm) or isinstance(m, nn.BatchNorm2d): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + elif isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + + def _get_pos_embed(self, pos_embed, H, W): + pos_embed = pos_embed.reshape( + 1, self.pretrain_size[0] // self.patch_size, self.pretrain_size[1] // self.patch_size, -1 + ).permute(0, 3, 1, 2) + pos_embed = ( + F.interpolate(pos_embed, size=(H, W), mode="bicubic", align_corners=False) + .reshape(1, -1, H * W) + .permute(0, 2, 1) + ) + return pos_embed + + def _init_deform_weights(self, m): + if isinstance(m, MSDeformAttn): + m._reset_parameters() + + def _add_level_embed(self, c2, c3, c4): + c2 = c2 + self.level_embed[0] + c3 = c3 + self.level_embed[1] + c4 = c4 + self.level_embed[2] + return c2, c3, c4 + + def forward(self, x): + deform_inputs1, deform_inputs2 = deform_inputs(x, self.patch_size) + + # SPM forward + c1, c2, c3, c4 = self.spm(x) + c2, c3, c4 = self._add_level_embed(c2, c3, c4) + c = torch.cat([c2, c3, c4], dim=1) + + # Patch Embedding forward + H_c, W_c = x.shape[2] // 16, x.shape[3] // 16 + x, H_toks, W_toks = self.patch_embed(x) + # print("H_toks, W_toks =", H_toks, W_toks) + bs, n, dim = x.shape + pos_embed = self._get_pos_embed(self.pos_embed[:, 1:], H_toks, W_toks) + if self.use_cls: + cls_token = self.cls_token.expand(x.shape[0], -1, -1) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_token, x), dim=1) + pos_embed = torch.cat((self.pos_embed[:, :1], pos_embed), dim=1) + x = self.pos_drop(x + pos_embed) + # For CLIP + x = self.norm_pre(x) + + # Interaction + if self.use_cls: + cls, x = ( + x[ + :, + :1, + ], + x[ + :, + 1:, + ], + ) + outs = list() + for i, layer in enumerate(self.interactions): + indexes = self.interaction_indexes[i] + if self.use_cls: + x, c, cls = layer( + x, + c, + cls, + self.blocks[indexes[0] : indexes[-1] + 1], + deform_inputs1, + deform_inputs2, + H_c, + W_c, + H_toks, + W_toks, + ) + else: + x, c = layer( + x, + c, + self.blocks[indexes[0] : indexes[-1] + 1], + deform_inputs1, + deform_inputs2, + H_c, + W_c, + H_toks, + W_toks, + ) + outs.append(x.transpose(1, 2).view(bs, dim, H_toks, W_toks).contiguous()) + + # Split & Reshape + c2 = c[:, 0 : c2.size(1), :] + c3 = c[:, c2.size(1) : c2.size(1) + c3.size(1), :] + c4 = c[:, c2.size(1) + c3.size(1) :, :] + + c2 = c2.transpose(1, 2).view(bs, dim, H_c * 2, W_c * 2).contiguous() + c3 = c3.transpose(1, 2).view(bs, dim, H_c, W_c).contiguous() + c4 = c4.transpose(1, 2).view(bs, dim, H_c // 2, W_c // 2).contiguous() + c1 = self.up(c2) + c1 + + if self.add_vit_feature: + x1, x2, x3, x4 = outs + + x1 = F.interpolate(x1, size=(4 * H_c, 4 * W_c), mode="bilinear", align_corners=False) + x2 = F.interpolate(x2, size=(2 * H_c, 2 * W_c), mode="bilinear", align_corners=False) + x3 = F.interpolate(x3, size=(1 * H_c, 1 * W_c), mode="bilinear", align_corners=False) + x4 = F.interpolate(x4, size=(H_c // 2, W_c // 2), mode="bilinear", align_corners=False) + # print(c1.shape, c2.shape, c3.shape, c4.shape, x1.shape, x2.shape, x3.shape, x4.shape, H_c, H_toks) + c1, c2, c3, c4 = c1 + x1, c2 + x2, c3 + x3, c4 + x4 + + # Final Norm + f1 = self.norm1(c1) + f2 = self.norm2(c2) + f3 = self.norm3(c3) + f4 = self.norm4(c4) + return [f1, f2, f3, f4] diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/builder.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/builder.py new file mode 100644 index 0000000000000000000000000000000000000000..d7cf7b919f6b0e8e00bde45bc244d9c29a36fed6 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/builder.py @@ -0,0 +1,25 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from mmcv.utils import Registry + +TRANSFORMER = Registry("Transformer") +MASK_ASSIGNERS = Registry("mask_assigner") +MATCH_COST = Registry("match_cost") + + +def build_match_cost(cfg): + """Build Match Cost.""" + return MATCH_COST.build(cfg) + + +def build_assigner(cfg): + """Build Assigner.""" + return MASK_ASSIGNERS.build(cfg) + + +def build_transformer(cfg): + """Build Transformer.""" + return TRANSFORMER.build(cfg) diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/decode_heads/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/decode_heads/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..01f08b88950750337781fc671adfea2a935ea8fe --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/decode_heads/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .mask2former_head import Mask2FormerHead diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/decode_heads/mask2former_head.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/decode_heads/mask2former_head.py new file mode 100644 index 0000000000000000000000000000000000000000..d1705fc444fa8d1583d88fca36d7fe1e060db9e7 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/decode_heads/mask2former_head.py @@ -0,0 +1,544 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import copy + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import Conv2d, build_plugin_layer, caffe2_xavier_init +from mmcv.cnn.bricks.transformer import build_positional_encoding, build_transformer_layer_sequence +from mmcv.ops import point_sample +from mmcv.runner import ModuleList, force_fp32 +from mmseg.models.builder import HEADS, build_loss +from mmseg.models.decode_heads.decode_head import BaseDecodeHead + +from ...core import build_sampler, multi_apply, reduce_mean +from ..builder import build_assigner +from ..utils import get_uncertain_point_coords_with_randomness + + +@HEADS.register_module() +class Mask2FormerHead(BaseDecodeHead): + """Implements the Mask2Former head. + + See `Masked-attention Mask Transformer for Universal Image + Segmentation `_ for details. + + Args: + in_channels (list[int]): Number of channels in the input feature map. + feat_channels (int): Number of channels for features. + out_channels (int): Number of channels for output. + num_things_classes (int): Number of things. + num_stuff_classes (int): Number of stuff. + num_queries (int): Number of query in Transformer decoder. + pixel_decoder (:obj:`mmcv.ConfigDict` | dict): Config for pixel + decoder. Defaults to None. + enforce_decoder_input_project (bool, optional): Whether to add + a layer to change the embed_dim of tranformer encoder in + pixel decoder to the embed_dim of transformer decoder. + Defaults to False. + transformer_decoder (:obj:`mmcv.ConfigDict` | dict): Config for + transformer decoder. Defaults to None. + positional_encoding (:obj:`mmcv.ConfigDict` | dict): Config for + transformer decoder position encoding. Defaults to None. + loss_cls (:obj:`mmcv.ConfigDict` | dict): Config of the classification + loss. Defaults to None. + loss_mask (:obj:`mmcv.ConfigDict` | dict): Config of the mask loss. + Defaults to None. + loss_dice (:obj:`mmcv.ConfigDict` | dict): Config of the dice loss. + Defaults to None. + train_cfg (:obj:`mmcv.ConfigDict` | dict): Training config of + Mask2Former head. + test_cfg (:obj:`mmcv.ConfigDict` | dict): Testing config of + Mask2Former head. + init_cfg (dict or list[dict], optional): Initialization config dict. + Defaults to None. + """ + + def __init__( + self, + in_channels, + feat_channels, + out_channels, + num_things_classes=80, + num_stuff_classes=53, + num_queries=100, + num_transformer_feat_level=3, + pixel_decoder=None, + enforce_decoder_input_project=False, + transformer_decoder=None, + positional_encoding=None, + loss_cls=None, + loss_mask=None, + loss_dice=None, + train_cfg=None, + test_cfg=None, + init_cfg=None, + **kwargs, + ): + super(Mask2FormerHead, self).__init__( + in_channels=in_channels, + channels=feat_channels, + num_classes=(num_things_classes + num_stuff_classes), + init_cfg=init_cfg, + input_transform="multiple_select", + **kwargs, + ) + self.num_things_classes = num_things_classes + self.num_stuff_classes = num_stuff_classes + self.num_classes = self.num_things_classes + self.num_stuff_classes + self.num_queries = num_queries + self.num_transformer_feat_level = num_transformer_feat_level + self.num_heads = transformer_decoder.transformerlayers.attn_cfgs.num_heads + self.num_transformer_decoder_layers = transformer_decoder.num_layers + assert pixel_decoder.encoder.transformerlayers.attn_cfgs.num_levels == num_transformer_feat_level + pixel_decoder_ = copy.deepcopy(pixel_decoder) + pixel_decoder_.update(in_channels=in_channels, feat_channels=feat_channels, out_channels=out_channels) + self.pixel_decoder = build_plugin_layer(pixel_decoder_)[1] + self.transformer_decoder = build_transformer_layer_sequence(transformer_decoder) + self.decoder_embed_dims = self.transformer_decoder.embed_dims + + self.decoder_input_projs = ModuleList() + # from low resolution to high resolution + for _ in range(num_transformer_feat_level): + if self.decoder_embed_dims != feat_channels or enforce_decoder_input_project: + self.decoder_input_projs.append(Conv2d(feat_channels, self.decoder_embed_dims, kernel_size=1)) + else: + self.decoder_input_projs.append(nn.Identity()) + self.decoder_positional_encoding = build_positional_encoding(positional_encoding) + self.query_embed = nn.Embedding(self.num_queries, feat_channels) + self.query_feat = nn.Embedding(self.num_queries, feat_channels) + # from low resolution to high resolution + self.level_embed = nn.Embedding(self.num_transformer_feat_level, feat_channels) + + self.cls_embed = nn.Linear(feat_channels, self.num_classes + 1) + self.mask_embed = nn.Sequential( + nn.Linear(feat_channels, feat_channels), + nn.ReLU(inplace=True), + nn.Linear(feat_channels, feat_channels), + nn.ReLU(inplace=True), + nn.Linear(feat_channels, out_channels), + ) + self.conv_seg = None # fix a bug here (conv_seg is not used) + + self.test_cfg = test_cfg + self.train_cfg = train_cfg + if train_cfg: + self.assigner = build_assigner(self.train_cfg.assigner) + self.sampler = build_sampler(self.train_cfg.sampler, context=self) + self.num_points = self.train_cfg.get("num_points", 12544) + self.oversample_ratio = self.train_cfg.get("oversample_ratio", 3.0) + self.importance_sample_ratio = self.train_cfg.get("importance_sample_ratio", 0.75) + + self.class_weight = loss_cls.class_weight + self.loss_cls = build_loss(loss_cls) + self.loss_mask = build_loss(loss_mask) + self.loss_dice = build_loss(loss_dice) + + def init_weights(self): + for m in self.decoder_input_projs: + if isinstance(m, Conv2d): + caffe2_xavier_init(m, bias=0) + + self.pixel_decoder.init_weights() + + for p in self.transformer_decoder.parameters(): + if p.dim() > 1: + nn.init.xavier_normal_(p) + + def get_targets(self, cls_scores_list, mask_preds_list, gt_labels_list, gt_masks_list, img_metas): + """Compute classification and mask targets for all images for a decoder + layer. + + Args: + cls_scores_list (list[Tensor]): Mask score logits from a single + decoder layer for all images. Each with shape [num_queries, + cls_out_channels]. + mask_preds_list (list[Tensor]): Mask logits from a single decoder + layer for all images. Each with shape [num_queries, h, w]. + gt_labels_list (list[Tensor]): Ground truth class indices for all + images. Each with shape (n, ), n is the sum of number of stuff + type and number of instance in a image. + gt_masks_list (list[Tensor]): Ground truth mask for each image, + each with shape (n, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + tuple[list[Tensor]]: a tuple containing the following targets. + + - labels_list (list[Tensor]): Labels of all images. + Each with shape [num_queries, ]. + - label_weights_list (list[Tensor]): Label weights of all + images.Each with shape [num_queries, ]. + - mask_targets_list (list[Tensor]): Mask targets of all images. + Each with shape [num_queries, h, w]. + - mask_weights_list (list[Tensor]): Mask weights of all images. + Each with shape [num_queries, ]. + - num_total_pos (int): Number of positive samples in all + images. + - num_total_neg (int): Number of negative samples in all + images. + """ + ( + labels_list, + label_weights_list, + mask_targets_list, + mask_weights_list, + pos_inds_list, + neg_inds_list, + ) = multi_apply( + self._get_target_single, cls_scores_list, mask_preds_list, gt_labels_list, gt_masks_list, img_metas + ) + + num_total_pos = sum((inds.numel() for inds in pos_inds_list)) + num_total_neg = sum((inds.numel() for inds in neg_inds_list)) + return (labels_list, label_weights_list, mask_targets_list, mask_weights_list, num_total_pos, num_total_neg) + + def _get_target_single(self, cls_score, mask_pred, gt_labels, gt_masks, img_metas): + """Compute classification and mask targets for one image. + + Args: + cls_score (Tensor): Mask score logits from a single decoder layer + for one image. Shape (num_queries, cls_out_channels). + mask_pred (Tensor): Mask logits for a single decoder layer for one + image. Shape (num_queries, h, w). + gt_labels (Tensor): Ground truth class indices for one image with + shape (num_gts, ). + gt_masks (Tensor): Ground truth mask for each image, each with + shape (num_gts, h, w). + img_metas (dict): Image informtation. + + Returns: + tuple[Tensor]: A tuple containing the following for one image. + + - labels (Tensor): Labels of each image. \ + shape (num_queries, ). + - label_weights (Tensor): Label weights of each image. \ + shape (num_queries, ). + - mask_targets (Tensor): Mask targets of each image. \ + shape (num_queries, h, w). + - mask_weights (Tensor): Mask weights of each image. \ + shape (num_queries, ). + - pos_inds (Tensor): Sampled positive indices for each \ + image. + - neg_inds (Tensor): Sampled negative indices for each \ + image. + """ + # sample points + num_queries = cls_score.shape[0] + num_gts = gt_labels.shape[0] + + point_coords = torch.rand((1, self.num_points, 2), device=cls_score.device) + # shape (num_queries, num_points) + mask_points_pred = point_sample(mask_pred.unsqueeze(1), point_coords.repeat(num_queries, 1, 1)).squeeze(1) + # shape (num_gts, num_points) + gt_points_masks = point_sample(gt_masks.unsqueeze(1).float(), point_coords.repeat(num_gts, 1, 1)).squeeze(1) + + # assign and sample + assign_result = self.assigner.assign(cls_score, mask_points_pred, gt_labels, gt_points_masks, img_metas) + sampling_result = self.sampler.sample(assign_result, mask_pred, gt_masks) + pos_inds = sampling_result.pos_inds + neg_inds = sampling_result.neg_inds + + # label target + labels = gt_labels.new_full((self.num_queries,), self.num_classes, dtype=torch.long) + labels[pos_inds] = gt_labels[sampling_result.pos_assigned_gt_inds] + label_weights = gt_labels.new_ones((self.num_queries,)) + + # mask target + mask_targets = gt_masks[sampling_result.pos_assigned_gt_inds] + mask_weights = mask_pred.new_zeros((self.num_queries,)) + mask_weights[pos_inds] = 1.0 + + return (labels, label_weights, mask_targets, mask_weights, pos_inds, neg_inds) + + def loss_single(self, cls_scores, mask_preds, gt_labels_list, gt_masks_list, img_metas): + """Loss function for outputs from a single decoder layer. + + Args: + cls_scores (Tensor): Mask score logits from a single decoder layer + for all images. Shape (batch_size, num_queries, + cls_out_channels). Note `cls_out_channels` should includes + background. + mask_preds (Tensor): Mask logits for a pixel decoder for all + images. Shape (batch_size, num_queries, h, w). + gt_labels_list (list[Tensor]): Ground truth class indices for each + image, each with shape (num_gts, ). + gt_masks_list (list[Tensor]): Ground truth mask for each image, + each with shape (num_gts, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + tuple[Tensor]: Loss components for outputs from a single \ + decoder layer. + """ + num_imgs = cls_scores.size(0) + cls_scores_list = [cls_scores[i] for i in range(num_imgs)] + mask_preds_list = [mask_preds[i] for i in range(num_imgs)] + ( + labels_list, + label_weights_list, + mask_targets_list, + mask_weights_list, + num_total_pos, + num_total_neg, + ) = self.get_targets(cls_scores_list, mask_preds_list, gt_labels_list, gt_masks_list, img_metas) + # shape (batch_size, num_queries) + labels = torch.stack(labels_list, dim=0) + # shape (batch_size, num_queries) + label_weights = torch.stack(label_weights_list, dim=0) + # shape (num_total_gts, h, w) + mask_targets = torch.cat(mask_targets_list, dim=0) + # shape (batch_size, num_queries) + mask_weights = torch.stack(mask_weights_list, dim=0) + + # classfication loss + # shape (batch_size * num_queries, ) + cls_scores = cls_scores.flatten(0, 1) + labels = labels.flatten(0, 1) + label_weights = label_weights.flatten(0, 1) + + class_weight = cls_scores.new_tensor(self.class_weight) + loss_cls = self.loss_cls(cls_scores, labels, label_weights, avg_factor=class_weight[labels].sum()) + + num_total_masks = reduce_mean(cls_scores.new_tensor([num_total_pos])) + num_total_masks = max(num_total_masks, 1) + + # extract positive ones + # shape (batch_size, num_queries, h, w) -> (num_total_gts, h, w) + mask_preds = mask_preds[mask_weights > 0] + + if mask_targets.shape[0] == 0: + # zero match + loss_dice = mask_preds.sum() + loss_mask = mask_preds.sum() + return loss_cls, loss_mask, loss_dice + + with torch.no_grad(): + points_coords = get_uncertain_point_coords_with_randomness( + mask_preds.unsqueeze(1), None, self.num_points, self.oversample_ratio, self.importance_sample_ratio + ) + # shape (num_total_gts, h, w) -> (num_total_gts, num_points) + mask_point_targets = point_sample(mask_targets.unsqueeze(1).float(), points_coords).squeeze(1) + # shape (num_queries, h, w) -> (num_queries, num_points) + mask_point_preds = point_sample(mask_preds.unsqueeze(1), points_coords).squeeze(1) + + # dice loss + loss_dice = self.loss_dice(mask_point_preds, mask_point_targets, avg_factor=num_total_masks) + + # mask loss + # shape (num_queries, num_points) -> (num_queries * num_points, ) + mask_point_preds = mask_point_preds.reshape(-1, 1) + # shape (num_total_gts, num_points) -> (num_total_gts * num_points, ) + mask_point_targets = mask_point_targets.reshape(-1) + loss_mask = self.loss_mask(mask_point_preds, mask_point_targets, avg_factor=num_total_masks * self.num_points) + + return loss_cls, loss_mask, loss_dice + + @force_fp32(apply_to=("all_cls_scores", "all_mask_preds")) + def loss(self, all_cls_scores, all_mask_preds, gt_labels_list, gt_masks_list, img_metas): + """Loss function. + + Args: + all_cls_scores (Tensor): Classification scores for all decoder + layers with shape [num_decoder, batch_size, num_queries, + cls_out_channels]. + all_mask_preds (Tensor): Mask scores for all decoder layers with + shape [num_decoder, batch_size, num_queries, h, w]. + gt_labels_list (list[Tensor]): Ground truth class indices for each + image with shape (n, ). n is the sum of number of stuff type + and number of instance in a image. + gt_masks_list (list[Tensor]): Ground truth mask for each image with + shape (n, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + dict[str, Tensor]: A dictionary of loss components. + """ + num_dec_layers = len(all_cls_scores) + all_gt_labels_list = [gt_labels_list for _ in range(num_dec_layers)] + all_gt_masks_list = [gt_masks_list for _ in range(num_dec_layers)] + img_metas_list = [img_metas for _ in range(num_dec_layers)] + losses_cls, losses_mask, losses_dice = multi_apply( + self.loss_single, all_cls_scores, all_mask_preds, all_gt_labels_list, all_gt_masks_list, img_metas_list + ) + + loss_dict = dict() + # loss from the last decoder layer + loss_dict["loss_cls"] = losses_cls[-1] + loss_dict["loss_mask"] = losses_mask[-1] + loss_dict["loss_dice"] = losses_dice[-1] + # loss from other decoder layers + num_dec_layer = 0 + for loss_cls_i, loss_mask_i, loss_dice_i in zip(losses_cls[:-1], losses_mask[:-1], losses_dice[:-1]): + loss_dict[f"d{num_dec_layer}.loss_cls"] = loss_cls_i + loss_dict[f"d{num_dec_layer}.loss_mask"] = loss_mask_i + loss_dict[f"d{num_dec_layer}.loss_dice"] = loss_dice_i + num_dec_layer += 1 + return loss_dict + + def forward_head(self, decoder_out, mask_feature, attn_mask_target_size): + """Forward for head part which is called after every decoder layer. + + Args: + decoder_out (Tensor): in shape (num_queries, batch_size, c). + mask_feature (Tensor): in shape (batch_size, c, h, w). + attn_mask_target_size (tuple[int, int]): target attention + mask size. + + Returns: + tuple: A tuple contain three elements. + + - cls_pred (Tensor): Classification scores in shape \ + (batch_size, num_queries, cls_out_channels). \ + Note `cls_out_channels` should includes background. + - mask_pred (Tensor): Mask scores in shape \ + (batch_size, num_queries,h, w). + - attn_mask (Tensor): Attention mask in shape \ + (batch_size * num_heads, num_queries, h, w). + """ + decoder_out = self.transformer_decoder.post_norm(decoder_out) + decoder_out = decoder_out.transpose(0, 1) + # shape (num_queries, batch_size, c) + cls_pred = self.cls_embed(decoder_out) + # shape (num_queries, batch_size, c) + mask_embed = self.mask_embed(decoder_out) + # shape (num_queries, batch_size, h, w) + mask_pred = torch.einsum("bqc,bchw->bqhw", mask_embed, mask_feature) + attn_mask = F.interpolate(mask_pred, attn_mask_target_size, mode="bilinear", align_corners=False) + # shape (num_queries, batch_size, h, w) -> + # (batch_size * num_head, num_queries, h, w) + attn_mask = attn_mask.flatten(2).unsqueeze(1).repeat((1, self.num_heads, 1, 1)).flatten(0, 1) + attn_mask = attn_mask.sigmoid() < 0.5 + attn_mask = attn_mask.detach() + + return cls_pred, mask_pred, attn_mask + + def forward(self, feats, img_metas): + """Forward function. + + Args: + feats (list[Tensor]): Multi scale Features from the + upstream network, each is a 4D-tensor. + img_metas (list[dict]): List of image information. + + Returns: + tuple: A tuple contains two elements. + + - cls_pred_list (list[Tensor)]: Classification logits \ + for each decoder layer. Each is a 3D-tensor with shape \ + (batch_size, num_queries, cls_out_channels). \ + Note `cls_out_channels` should includes background. + - mask_pred_list (list[Tensor]): Mask logits for each \ + decoder layer. Each with shape (batch_size, num_queries, \ + h, w). + """ + batch_size = len(img_metas) + mask_features, multi_scale_memorys = self.pixel_decoder(feats) + # multi_scale_memorys (from low resolution to high resolution) + decoder_inputs = [] + decoder_positional_encodings = [] + for i in range(self.num_transformer_feat_level): + decoder_input = self.decoder_input_projs[i](multi_scale_memorys[i]) + # shape (batch_size, c, h, w) -> (h*w, batch_size, c) + decoder_input = decoder_input.flatten(2).permute(2, 0, 1) + level_embed = self.level_embed.weight[i].view(1, 1, -1) + decoder_input = decoder_input + level_embed + # shape (batch_size, c, h, w) -> (h*w, batch_size, c) + mask = decoder_input.new_zeros((batch_size,) + multi_scale_memorys[i].shape[-2:], dtype=torch.bool) + decoder_positional_encoding = self.decoder_positional_encoding(mask) + decoder_positional_encoding = decoder_positional_encoding.flatten(2).permute(2, 0, 1) + decoder_inputs.append(decoder_input) + decoder_positional_encodings.append(decoder_positional_encoding) + # shape (num_queries, c) -> (num_queries, batch_size, c) + query_feat = self.query_feat.weight.unsqueeze(1).repeat((1, batch_size, 1)) + query_embed = self.query_embed.weight.unsqueeze(1).repeat((1, batch_size, 1)) + + cls_pred_list = [] + mask_pred_list = [] + cls_pred, mask_pred, attn_mask = self.forward_head(query_feat, mask_features, multi_scale_memorys[0].shape[-2:]) + cls_pred_list.append(cls_pred) + mask_pred_list.append(mask_pred) + + for i in range(self.num_transformer_decoder_layers): + level_idx = i % self.num_transformer_feat_level + # if a mask is all True(all background), then set it all False. + attn_mask[torch.where(attn_mask.sum(-1) == attn_mask.shape[-1])] = False + + # cross_attn + self_attn + layer = self.transformer_decoder.layers[i] + attn_masks = [attn_mask, None] + query_feat = layer( + query=query_feat, + key=decoder_inputs[level_idx], + value=decoder_inputs[level_idx], + query_pos=query_embed, + key_pos=decoder_positional_encodings[level_idx], + attn_masks=attn_masks, + query_key_padding_mask=None, + # here we do not apply masking on padded region + key_padding_mask=None, + ) + cls_pred, mask_pred, attn_mask = self.forward_head( + query_feat, mask_features, multi_scale_memorys[(i + 1) % self.num_transformer_feat_level].shape[-2:] + ) + + cls_pred_list.append(cls_pred) + mask_pred_list.append(mask_pred) + + return cls_pred_list, mask_pred_list + + def forward_train(self, x, img_metas, gt_semantic_seg, gt_labels, gt_masks): + """Forward function for training mode. + + Args: + x (list[Tensor]): Multi-level features from the upstream network, + each is a 4D-tensor. + img_metas (list[Dict]): List of image information. + gt_semantic_seg (list[tensor]):Each element is the ground truth + of semantic segmentation with the shape (N, H, W). + train_cfg (dict): The training config, which not been used in + maskformer. + gt_labels (list[Tensor]): Each element is ground truth labels of + each box, shape (num_gts,). + gt_masks (list[BitmapMasks]): Each element is masks of instances + of a image, shape (num_gts, h, w). + + Returns: + losses (dict[str, Tensor]): a dictionary of loss components + """ + + # forward + all_cls_scores, all_mask_preds = self(x, img_metas) + + # loss + losses = self.loss(all_cls_scores, all_mask_preds, gt_labels, gt_masks, img_metas) + + return losses + + def forward_test(self, inputs, img_metas, test_cfg): + """Test segment without test-time aumengtation. + + Only the output of last decoder layers was used. + + Args: + inputs (list[Tensor]): Multi-level features from the + upstream network, each is a 4D-tensor. + img_metas (list[dict]): List of image information. + test_cfg (dict): Testing config. + + Returns: + seg_mask (Tensor): Predicted semantic segmentation logits. + """ + all_cls_scores, all_mask_preds = self(inputs, img_metas) + cls_score, mask_pred = all_cls_scores[-1], all_mask_preds[-1] + ori_h, ori_w, _ = img_metas[0]["ori_shape"] + + # semantic inference + cls_score = F.softmax(cls_score, dim=-1)[..., :-1] + mask_pred = mask_pred.sigmoid() + seg_mask = torch.einsum("bqc,bqhw->bchw", cls_score, mask_pred) + return seg_mask diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/losses/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/losses/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..229a887817372f4991b32354180592cfb236d728 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/losses/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .cross_entropy_loss import CrossEntropyLoss, binary_cross_entropy, cross_entropy, mask_cross_entropy +from .dice_loss import DiceLoss +from .match_costs import ClassificationCost, CrossEntropyLossCost, DiceCost diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/losses/cross_entropy_loss.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/losses/cross_entropy_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..0a1f9dd4aa52ebe94cc527db36b1c7fa2f53813e --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/losses/cross_entropy_loss.py @@ -0,0 +1,279 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import warnings + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmseg.models.builder import LOSSES +from mmseg.models.losses.utils import get_class_weight, weight_reduce_loss + + +def cross_entropy( + pred, + label, + weight=None, + class_weight=None, + reduction="mean", + avg_factor=None, + ignore_index=-100, + avg_non_ignore=False, +): + """cross_entropy. The wrapper function for :func:`F.cross_entropy` + + Args: + pred (torch.Tensor): The prediction with shape (N, 1). + label (torch.Tensor): The learning label of the prediction. + weight (torch.Tensor, optional): Sample-wise loss weight. + Default: None. + class_weight (list[float], optional): The weight for each class. + Default: None. + reduction (str, optional): The method used to reduce the loss. + Options are 'none', 'mean' and 'sum'. Default: 'mean'. + avg_factor (int, optional): Average factor that is used to average + the loss. Default: None. + ignore_index (int): Specifies a target value that is ignored and + does not contribute to the input gradients. When + ``avg_non_ignore `` is ``True``, and the ``reduction`` is + ``''mean''``, the loss is averaged over non-ignored targets. + Defaults: -100. + avg_non_ignore (bool): The flag decides to whether the loss is + only averaged over non-ignored targets. Default: False. + `New in version 0.23.0.` + """ + + # class_weight is a manual rescaling weight given to each class. + # If given, has to be a Tensor of size C element-wise losses + loss = F.cross_entropy(pred, label, weight=class_weight, reduction="none", ignore_index=ignore_index) + + # apply weights and do the reduction + # average loss over non-ignored elements + # pytorch's official cross_entropy average loss over non-ignored elements + # refer to https://github.com/pytorch/pytorch/blob/56b43f4fec1f76953f15a627694d4bba34588969/torch/nn/functional.py#L2660 # noqa + if (avg_factor is None) and avg_non_ignore and reduction == "mean": + avg_factor = label.numel() - (label == ignore_index).sum().item() + if weight is not None: + weight = weight.float() + loss = weight_reduce_loss(loss, weight=weight, reduction=reduction, avg_factor=avg_factor) + + return loss + + +def _expand_onehot_labels(labels, label_weights, target_shape, ignore_index): + """Expand onehot labels to match the size of prediction.""" + bin_labels = labels.new_zeros(target_shape) + valid_mask = (labels >= 0) & (labels != ignore_index) + inds = torch.nonzero(valid_mask, as_tuple=True) + + if inds[0].numel() > 0: + if labels.dim() == 3: + bin_labels[inds[0], labels[valid_mask], inds[1], inds[2]] = 1 + else: + bin_labels[inds[0], labels[valid_mask]] = 1 + + valid_mask = valid_mask.unsqueeze(1).expand(target_shape).float() + + if label_weights is None: + bin_label_weights = valid_mask + else: + bin_label_weights = label_weights.unsqueeze(1).expand(target_shape) + bin_label_weights = bin_label_weights * valid_mask + + return bin_labels, bin_label_weights, valid_mask + + +def binary_cross_entropy( + pred, + label, + weight=None, + reduction="mean", + avg_factor=None, + class_weight=None, + ignore_index=-100, + avg_non_ignore=False, + **kwargs, +): + """Calculate the binary CrossEntropy loss. + + Args: + pred (torch.Tensor): The prediction with shape (N, 1). + label (torch.Tensor): The learning label of the prediction. + Note: In bce loss, label < 0 is invalid. + weight (torch.Tensor, optional): Sample-wise loss weight. + reduction (str, optional): The method used to reduce the loss. + Options are "none", "mean" and "sum". + avg_factor (int, optional): Average factor that is used to average + the loss. Defaults to None. + class_weight (list[float], optional): The weight for each class. + ignore_index (int): The label index to be ignored. Default: -100. + avg_non_ignore (bool): The flag decides to whether the loss is + only averaged over non-ignored targets. Default: False. + `New in version 0.23.0.` + + Returns: + torch.Tensor: The calculated loss + """ + if pred.size(1) == 1: + # For binary class segmentation, the shape of pred is + # [N, 1, H, W] and that of label is [N, H, W]. + assert label.max() <= 1, "For pred with shape [N, 1, H, W], its label must have at " "most 2 classes" + pred = pred.squeeze() + if pred.dim() != label.dim(): + assert (pred.dim() == 2 and label.dim() == 1) or (pred.dim() == 4 and label.dim() == 3), ( + "Only pred shape [N, C], label shape [N] or pred shape [N, C, " "H, W], label shape [N, H, W] are supported" + ) + # `weight` returned from `_expand_onehot_labels` + # has been treated for valid (non-ignore) pixels + label, weight, valid_mask = _expand_onehot_labels(label, weight, pred.shape, ignore_index) + else: + # should mask out the ignored elements + valid_mask = ((label >= 0) & (label != ignore_index)).float() + if weight is not None: + weight = weight * valid_mask + else: + weight = valid_mask + # average loss over non-ignored and valid elements + if reduction == "mean" and avg_factor is None and avg_non_ignore: + avg_factor = valid_mask.sum().item() + + loss = F.binary_cross_entropy_with_logits(pred, label.float(), pos_weight=class_weight, reduction="none") + # do the reduction for the weighted loss + loss = weight_reduce_loss(loss, weight, reduction=reduction, avg_factor=avg_factor) + + return loss + + +def mask_cross_entropy( + pred, target, label, reduction="mean", avg_factor=None, class_weight=None, ignore_index=None, **kwargs +): + """Calculate the CrossEntropy loss for masks. + + Args: + pred (torch.Tensor): The prediction with shape (N, C), C is the number + of classes. + target (torch.Tensor): The learning label of the prediction. + label (torch.Tensor): ``label`` indicates the class label of the mask' + corresponding object. This will be used to select the mask in the + of the class which the object belongs to when the mask prediction + if not class-agnostic. + reduction (str, optional): The method used to reduce the loss. + Options are "none", "mean" and "sum". + avg_factor (int, optional): Average factor that is used to average + the loss. Defaults to None. + class_weight (list[float], optional): The weight for each class. + ignore_index (None): Placeholder, to be consistent with other loss. + Default: None. + + Returns: + torch.Tensor: The calculated loss + """ + assert ignore_index is None, "BCE loss does not support ignore_index" + assert reduction == "mean" and avg_factor is None + num_rois = pred.size()[0] + inds = torch.arange(0, num_rois, dtype=torch.long, device=pred.device) + pred_slice = pred[inds, label].squeeze(1) + return F.binary_cross_entropy_with_logits(pred_slice, target, weight=class_weight, reduction="mean")[None] + + +@LOSSES.register_module(force=True) +class CrossEntropyLoss(nn.Module): + """CrossEntropyLoss. + + Args: + use_sigmoid (bool, optional): Whether the prediction uses sigmoid + of softmax. Defaults to False. + use_mask (bool, optional): Whether to use mask cross entropy loss. + Defaults to False. + reduction (str, optional): . Defaults to 'mean'. + Options are "none", "mean" and "sum". + class_weight (list[float] | str, optional): Weight of each class. If in + str format, read them from a file. Defaults to None. + loss_weight (float, optional): Weight of the loss. Defaults to 1.0. + loss_name (str, optional): Name of the loss item. If you want this loss + item to be included into the backward graph, `loss_` must be the + prefix of the name. Defaults to 'loss_ce'. + avg_non_ignore (bool): The flag decides to whether the loss is + only averaged over non-ignored targets. Default: False. + `New in version 0.23.0.` + """ + + def __init__( + self, + use_sigmoid=False, + use_mask=False, + reduction="mean", + class_weight=None, + loss_weight=1.0, + loss_name="loss_ce", + avg_non_ignore=False, + ): + super(CrossEntropyLoss, self).__init__() + assert (use_sigmoid is False) or (use_mask is False) + self.use_sigmoid = use_sigmoid + self.use_mask = use_mask + self.reduction = reduction + self.loss_weight = loss_weight + self.class_weight = get_class_weight(class_weight) + self.avg_non_ignore = avg_non_ignore + if not self.avg_non_ignore and self.reduction == "mean": + warnings.warn( + "Default ``avg_non_ignore`` is False, if you would like to " + "ignore the certain label and average loss over non-ignore " + "labels, which is the same with PyTorch official " + "cross_entropy, set ``avg_non_ignore=True``." + ) + + if self.use_sigmoid: + self.cls_criterion = binary_cross_entropy + elif self.use_mask: + self.cls_criterion = mask_cross_entropy + else: + self.cls_criterion = cross_entropy + self._loss_name = loss_name + + def extra_repr(self): + """Extra repr.""" + s = f"avg_non_ignore={self.avg_non_ignore}" + return s + + def forward( + self, cls_score, label, weight=None, avg_factor=None, reduction_override=None, ignore_index=-100, **kwargs + ): + """Forward function.""" + assert reduction_override in (None, "none", "mean", "sum") + reduction = reduction_override if reduction_override else self.reduction + if self.class_weight is not None: + class_weight = cls_score.new_tensor(self.class_weight) + else: + class_weight = None + # Note: for BCE loss, label < 0 is invalid. + loss_cls = self.loss_weight * self.cls_criterion( + cls_score, + label, + weight, + class_weight=class_weight, + reduction=reduction, + avg_factor=avg_factor, + avg_non_ignore=self.avg_non_ignore, + ignore_index=ignore_index, + **kwargs, + ) + return loss_cls + + @property + def loss_name(self): + """Loss Name. + + This function must be implemented and will return the name of this + loss function. This name will be used to combine different loss items + by simple sum operation. In addition, if you want this loss item to be + included into the backward graph, `loss_` must be the prefix of the + name. + + Returns: + str: The name of this loss item. + """ + return self._loss_name diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/losses/dice_loss.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/losses/dice_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..1bc5ba893c502861032ed531283f225e183eb693 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/losses/dice_loss.py @@ -0,0 +1,153 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +from mmseg.models.builder import LOSSES +from mmseg.models.losses.utils import weight_reduce_loss + + +def dice_loss(pred, target, weight=None, eps=1e-3, reduction="mean", avg_factor=None): + """Calculate dice loss, which is proposed in + `V-Net: Fully Convolutional Neural Networks for Volumetric + Medical Image Segmentation `_. + + Args: + pred (torch.Tensor): The prediction, has a shape (n, *) + target (torch.Tensor): The learning label of the prediction, + shape (n, *), same shape of pred. + weight (torch.Tensor, optional): The weight of loss for each + prediction, has a shape (n,). Defaults to None. + eps (float): Avoid dividing by zero. Default: 1e-3. + reduction (str, optional): The method used to reduce the loss into + a scalar. Defaults to 'mean'. + Options are "none", "mean" and "sum". + avg_factor (int, optional): Average factor that is used to average + the loss. Defaults to None. + """ + + input = pred.flatten(1) + target = target.flatten(1).float() + + a = torch.sum(input * target, 1) + b = torch.sum(input * input, 1) + eps + c = torch.sum(target * target, 1) + eps + d = (2 * a) / (b + c) + loss = 1 - d + if weight is not None: + assert weight.ndim == loss.ndim + assert len(weight) == len(pred) + loss = weight_reduce_loss(loss, weight, reduction, avg_factor) + return loss + + +def naive_dice_loss(pred, target, weight=None, eps=1e-3, reduction="mean", avg_factor=None): + """Calculate naive dice loss, the coefficient in the denominator is the + first power instead of the second power. + + Args: + pred (torch.Tensor): The prediction, has a shape (n, *) + target (torch.Tensor): The learning label of the prediction, + shape (n, *), same shape of pred. + weight (torch.Tensor, optional): The weight of loss for each + prediction, has a shape (n,). Defaults to None. + eps (float): Avoid dividing by zero. Default: 1e-3. + reduction (str, optional): The method used to reduce the loss into + a scalar. Defaults to 'mean'. + Options are "none", "mean" and "sum". + avg_factor (int, optional): Average factor that is used to average + the loss. Defaults to None. + """ + input = pred.flatten(1) + target = target.flatten(1).float() + + a = torch.sum(input * target, 1) + b = torch.sum(input, 1) + c = torch.sum(target, 1) + d = (2 * a + eps) / (b + c + eps) + loss = 1 - d + if weight is not None: + assert weight.ndim == loss.ndim + assert len(weight) == len(pred) + loss = weight_reduce_loss(loss, weight, reduction, avg_factor) + return loss + + +@LOSSES.register_module(force=True) +class DiceLoss(nn.Module): + def __init__(self, use_sigmoid=True, activate=True, reduction="mean", naive_dice=False, loss_weight=1.0, eps=1e-3): + """Dice Loss, there are two forms of dice loss is supported: + + - the one proposed in `V-Net: Fully Convolutional Neural + Networks for Volumetric Medical Image Segmentation + `_. + - the dice loss in which the power of the number in the + denominator is the first power instead of the second + power. + + Args: + use_sigmoid (bool, optional): Whether to the prediction is + used for sigmoid or softmax. Defaults to True. + activate (bool): Whether to activate the predictions inside, + this will disable the inside sigmoid operation. + Defaults to True. + reduction (str, optional): The method used + to reduce the loss. Options are "none", + "mean" and "sum". Defaults to 'mean'. + naive_dice (bool, optional): If false, use the dice + loss defined in the V-Net paper, otherwise, use the + naive dice loss in which the power of the number in the + denominator is the first power instead of the second + power.Defaults to False. + loss_weight (float, optional): Weight of loss. Defaults to 1.0. + eps (float): Avoid dividing by zero. Defaults to 1e-3. + """ + + super(DiceLoss, self).__init__() + self.use_sigmoid = use_sigmoid + self.reduction = reduction + self.naive_dice = naive_dice + self.loss_weight = loss_weight + self.eps = eps + self.activate = activate + + def forward(self, pred, target, weight=None, reduction_override=None, avg_factor=None): + """Forward function. + + Args: + pred (torch.Tensor): The prediction, has a shape (n, *). + target (torch.Tensor): The label of the prediction, + shape (n, *), same shape of pred. + weight (torch.Tensor, optional): The weight of loss for each + prediction, has a shape (n,). Defaults to None. + avg_factor (int, optional): Average factor that is used to average + the loss. Defaults to None. + reduction_override (str, optional): The reduction method used to + override the original reduction method of the loss. + Options are "none", "mean" and "sum". + + Returns: + torch.Tensor: The calculated loss + """ + + assert reduction_override in (None, "none", "mean", "sum") + reduction = reduction_override if reduction_override else self.reduction + + if self.activate: + if self.use_sigmoid: + pred = pred.sigmoid() + else: + raise NotImplementedError + + if self.naive_dice: + loss = self.loss_weight * naive_dice_loss( + pred, target, weight, eps=self.eps, reduction=reduction, avg_factor=avg_factor + ) + else: + loss = self.loss_weight * dice_loss( + pred, target, weight, eps=self.eps, reduction=reduction, avg_factor=avg_factor + ) + + return loss diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/losses/match_costs.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/losses/match_costs.py new file mode 100644 index 0000000000000000000000000000000000000000..4917d2a939c01398dd49c0d90b06f4c37d283ce0 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/losses/match_costs.py @@ -0,0 +1,153 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn.functional as F + +from ..builder import MATCH_COST + + +@MATCH_COST.register_module() +class ClassificationCost: + """ClsSoftmaxCost.Borrow from + mmdet.core.bbox.match_costs.match_cost.ClassificationCost. + + Args: + weight (int | float, optional): loss_weight + + Examples: + >>> import torch + >>> self = ClassificationCost() + >>> cls_pred = torch.rand(4, 3) + >>> gt_labels = torch.tensor([0, 1, 2]) + >>> factor = torch.tensor([10, 8, 10, 8]) + >>> self(cls_pred, gt_labels) + tensor([[-0.3430, -0.3525, -0.3045], + [-0.3077, -0.2931, -0.3992], + [-0.3664, -0.3455, -0.2881], + [-0.3343, -0.2701, -0.3956]]) + """ + + def __init__(self, weight=1.0): + self.weight = weight + + def __call__(self, cls_pred, gt_labels): + """ + Args: + cls_pred (Tensor): Predicted classification logits, shape + [num_query, num_class]. + gt_labels (Tensor): Label of `gt_bboxes`, shape (num_gt,). + + Returns: + torch.Tensor: cls_cost value with weight + """ + # Following the official DETR repo, contrary to the loss that + # NLL is used, we approximate it in 1 - cls_score[gt_label]. + # The 1 is a constant that doesn't change the matching, + # so it can be omitted. + cls_score = cls_pred.softmax(-1) + cls_cost = -cls_score[:, gt_labels] + return cls_cost * self.weight + + +@MATCH_COST.register_module() +class DiceCost: + """Cost of mask assignments based on dice losses. + + Args: + weight (int | float, optional): loss_weight. Defaults to 1. + pred_act (bool, optional): Whether to apply sigmoid to mask_pred. + Defaults to False. + eps (float, optional): default 1e-12. + """ + + def __init__(self, weight=1.0, pred_act=False, eps=1e-3): + self.weight = weight + self.pred_act = pred_act + self.eps = eps + + def binary_mask_dice_loss(self, mask_preds, gt_masks): + """ + Args: + mask_preds (Tensor): Mask prediction in shape (N1, H, W). + gt_masks (Tensor): Ground truth in shape (N2, H, W) + store 0 or 1, 0 for negative class and 1 for + positive class. + + Returns: + Tensor: Dice cost matrix in shape (N1, N2). + """ + mask_preds = mask_preds.reshape((mask_preds.shape[0], -1)) + gt_masks = gt_masks.reshape((gt_masks.shape[0], -1)).float() + numerator = 2 * torch.einsum("nc,mc->nm", mask_preds, gt_masks) + denominator = mask_preds.sum(-1)[:, None] + gt_masks.sum(-1)[None, :] + loss = 1 - (numerator + self.eps) / (denominator + self.eps) + return loss + + def __call__(self, mask_preds, gt_masks): + """ + Args: + mask_preds (Tensor): Mask prediction logits in shape (N1, H, W). + gt_masks (Tensor): Ground truth in shape (N2, H, W). + + Returns: + Tensor: Dice cost matrix in shape (N1, N2). + """ + if self.pred_act: + mask_preds = mask_preds.sigmoid() + dice_cost = self.binary_mask_dice_loss(mask_preds, gt_masks) + return dice_cost * self.weight + + +@MATCH_COST.register_module() +class CrossEntropyLossCost: + """CrossEntropyLossCost. + + Args: + weight (int | float, optional): loss weight. Defaults to 1. + use_sigmoid (bool, optional): Whether the prediction uses sigmoid + of softmax. Defaults to True. + """ + + def __init__(self, weight=1.0, use_sigmoid=True): + assert use_sigmoid, "use_sigmoid = False is not supported yet." + self.weight = weight + self.use_sigmoid = use_sigmoid + + def _binary_cross_entropy(self, cls_pred, gt_labels): + """ + Args: + cls_pred (Tensor): The prediction with shape (num_query, 1, *) or + (num_query, *). + gt_labels (Tensor): The learning label of prediction with + shape (num_gt, *). + Returns: + Tensor: Cross entropy cost matrix in shape (num_query, num_gt). + """ + cls_pred = cls_pred.flatten(1).float() + gt_labels = gt_labels.flatten(1).float() + n = cls_pred.shape[1] + pos = F.binary_cross_entropy_with_logits(cls_pred, torch.ones_like(cls_pred), reduction="none") + neg = F.binary_cross_entropy_with_logits(cls_pred, torch.zeros_like(cls_pred), reduction="none") + cls_cost = torch.einsum("nc,mc->nm", pos, gt_labels) + torch.einsum("nc,mc->nm", neg, 1 - gt_labels) + cls_cost = cls_cost / n + + return cls_cost + + def __call__(self, cls_pred, gt_labels): + """ + Args: + cls_pred (Tensor): Predicted classification logits. + gt_labels (Tensor): Labels. + Returns: + Tensor: Cross entropy cost matrix with weight in + shape (num_query, num_gt). + """ + if self.use_sigmoid: + cls_cost = self._binary_cross_entropy(cls_pred, gt_labels) + else: + raise NotImplementedError + + return cls_cost * self.weight diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/plugins/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/plugins/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81a60db4de31238cb38e078683e5ca265839fe60 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/plugins/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .msdeformattn_pixel_decoder import MSDeformAttnPixelDecoder diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/plugins/msdeformattn_pixel_decoder.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/plugins/msdeformattn_pixel_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..db1947175917f73f3f24184cb09c78e092d46ef8 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/plugins/msdeformattn_pixel_decoder.py @@ -0,0 +1,242 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import PLUGIN_LAYERS, Conv2d, ConvModule, caffe2_xavier_init, normal_init, xavier_init +from mmcv.cnn.bricks.transformer import build_positional_encoding, build_transformer_layer_sequence +from mmcv.runner import BaseModule, ModuleList + +from ...core.anchor import MlvlPointGenerator +from ..utils.transformer import MultiScaleDeformableAttention + + +@PLUGIN_LAYERS.register_module() +class MSDeformAttnPixelDecoder(BaseModule): + """Pixel decoder with multi-scale deformable attention. + + Args: + in_channels (list[int] | tuple[int]): Number of channels in the + input feature maps. + strides (list[int] | tuple[int]): Output strides of feature from + backbone. + feat_channels (int): Number of channels for feature. + out_channels (int): Number of channels for output. + num_outs (int): Number of output scales. + norm_cfg (:obj:`mmcv.ConfigDict` | dict): Config for normalization. + Defaults to dict(type='GN', num_groups=32). + act_cfg (:obj:`mmcv.ConfigDict` | dict): Config for activation. + Defaults to dict(type='ReLU'). + encoder (:obj:`mmcv.ConfigDict` | dict): Config for transformer + encoder. Defaults to `DetrTransformerEncoder`. + positional_encoding (:obj:`mmcv.ConfigDict` | dict): Config for + transformer encoder position encoding. Defaults to + dict(type='SinePositionalEncoding', num_feats=128, + normalize=True). + init_cfg (:obj:`mmcv.ConfigDict` | dict): Initialization config dict. + """ + + def __init__( + self, + in_channels=[256, 512, 1024, 2048], + strides=[4, 8, 16, 32], + feat_channels=256, + out_channels=256, + num_outs=3, + norm_cfg=dict(type="GN", num_groups=32), + act_cfg=dict(type="ReLU"), + encoder=dict( + type="DetrTransformerEncoder", + num_layers=6, + transformerlayers=dict( + type="BaseTransformerLayer", + attn_cfgs=dict( + type="MultiScaleDeformableAttention", + embed_dims=256, + num_heads=8, + num_levels=3, + num_points=4, + im2col_step=64, + dropout=0.0, + batch_first=False, + norm_cfg=None, + init_cfg=None, + ), + feedforward_channels=1024, + ffn_dropout=0.0, + operation_order=("self_attn", "norm", "ffn", "norm"), + ), + init_cfg=None, + ), + positional_encoding=dict(type="SinePositionalEncoding", num_feats=128, normalize=True), + init_cfg=None, + ): + super().__init__(init_cfg=init_cfg) + self.strides = strides + self.num_input_levels = len(in_channels) + self.num_encoder_levels = encoder.transformerlayers.attn_cfgs.num_levels + assert self.num_encoder_levels >= 1, "num_levels in attn_cfgs must be at least one" + input_conv_list = [] + # from top to down (low to high resolution) + for i in range(self.num_input_levels - 1, self.num_input_levels - self.num_encoder_levels - 1, -1): + input_conv = ConvModule( + in_channels[i], feat_channels, kernel_size=1, norm_cfg=norm_cfg, act_cfg=None, bias=True + ) + input_conv_list.append(input_conv) + self.input_convs = ModuleList(input_conv_list) + + self.encoder = build_transformer_layer_sequence(encoder) + self.postional_encoding = build_positional_encoding(positional_encoding) + # high resolution to low resolution + self.level_encoding = nn.Embedding(self.num_encoder_levels, feat_channels) + + # fpn-like structure + self.lateral_convs = ModuleList() + self.output_convs = ModuleList() + self.use_bias = norm_cfg is None + # from top to down (low to high resolution) + # fpn for the rest features that didn't pass in encoder + for i in range(self.num_input_levels - self.num_encoder_levels - 1, -1, -1): + lateral_conv = ConvModule( + in_channels[i], feat_channels, kernel_size=1, bias=self.use_bias, norm_cfg=norm_cfg, act_cfg=None + ) + output_conv = ConvModule( + feat_channels, + feat_channels, + kernel_size=3, + stride=1, + padding=1, + bias=self.use_bias, + norm_cfg=norm_cfg, + act_cfg=act_cfg, + ) + self.lateral_convs.append(lateral_conv) + self.output_convs.append(output_conv) + + self.mask_feature = Conv2d(feat_channels, out_channels, kernel_size=1, stride=1, padding=0) + + self.num_outs = num_outs + self.point_generator = MlvlPointGenerator(strides) + + def init_weights(self): + """Initialize weights.""" + for i in range(0, self.num_encoder_levels): + xavier_init(self.input_convs[i].conv, gain=1, bias=0, distribution="uniform") + + for i in range(0, self.num_input_levels - self.num_encoder_levels): + caffe2_xavier_init(self.lateral_convs[i].conv, bias=0) + caffe2_xavier_init(self.output_convs[i].conv, bias=0) + + caffe2_xavier_init(self.mask_feature, bias=0) + + normal_init(self.level_encoding, mean=0, std=1) + for p in self.encoder.parameters(): + if p.dim() > 1: + nn.init.xavier_normal_(p) + + # init_weights defined in MultiScaleDeformableAttention + for layer in self.encoder.layers: + for attn in layer.attentions: + if isinstance(attn, MultiScaleDeformableAttention): + attn.init_weights() + + def forward(self, feats): + """ + Args: + feats (list[Tensor]): Feature maps of each level. Each has + shape of (batch_size, c, h, w). + + Returns: + tuple: A tuple containing the following: + + - mask_feature (Tensor): shape (batch_size, c, h, w). + - multi_scale_features (list[Tensor]): Multi scale \ + features, each in shape (batch_size, c, h, w). + """ + # generate padding mask for each level, for each image + batch_size = feats[0].shape[0] + encoder_input_list = [] + padding_mask_list = [] + level_positional_encoding_list = [] + spatial_shapes = [] + reference_points_list = [] + for i in range(self.num_encoder_levels): + level_idx = self.num_input_levels - i - 1 + feat = feats[level_idx] + feat_projected = self.input_convs[i](feat) + h, w = feat.shape[-2:] + + # no padding + padding_mask_resized = feat.new_zeros((batch_size,) + feat.shape[-2:], dtype=torch.bool) + pos_embed = self.postional_encoding(padding_mask_resized) + level_embed = self.level_encoding.weight[i] + level_pos_embed = level_embed.view(1, -1, 1, 1) + pos_embed + # (h_i * w_i, 2) + reference_points = self.point_generator.single_level_grid_priors( + feat.shape[-2:], level_idx, device=feat.device + ) + # normalize + factor = feat.new_tensor([[w, h]]) * self.strides[level_idx] + reference_points = reference_points / factor + + # shape (batch_size, c, h_i, w_i) -> (h_i * w_i, batch_size, c) + feat_projected = feat_projected.flatten(2).permute(2, 0, 1) + level_pos_embed = level_pos_embed.flatten(2).permute(2, 0, 1) + padding_mask_resized = padding_mask_resized.flatten(1) + + encoder_input_list.append(feat_projected) + padding_mask_list.append(padding_mask_resized) + level_positional_encoding_list.append(level_pos_embed) + spatial_shapes.append(feat.shape[-2:]) + reference_points_list.append(reference_points) + # shape (batch_size, total_num_query), + # total_num_query=sum([., h_i * w_i,.]) + padding_masks = torch.cat(padding_mask_list, dim=1) + # shape (total_num_query, batch_size, c) + encoder_inputs = torch.cat(encoder_input_list, dim=0) + level_positional_encodings = torch.cat(level_positional_encoding_list, dim=0) + device = encoder_inputs.device + # shape (num_encoder_levels, 2), from low + # resolution to high resolution + spatial_shapes = torch.as_tensor(spatial_shapes, dtype=torch.long, device=device) + # shape (0, h_0*w_0, h_0*w_0+h_1*w_1, ...) + level_start_index = torch.cat((spatial_shapes.new_zeros((1,)), spatial_shapes.prod(1).cumsum(0)[:-1])) + reference_points = torch.cat(reference_points_list, dim=0) + reference_points = reference_points[None, :, None].repeat(batch_size, 1, self.num_encoder_levels, 1) + valid_radios = reference_points.new_ones((batch_size, self.num_encoder_levels, 2)) + # shape (num_total_query, batch_size, c) + memory = self.encoder( + query=encoder_inputs, + key=None, + value=None, + query_pos=level_positional_encodings, + key_pos=None, + attn_masks=None, + key_padding_mask=None, + query_key_padding_mask=padding_masks, + spatial_shapes=spatial_shapes, + reference_points=reference_points, + level_start_index=level_start_index, + valid_radios=valid_radios, + ) + # (num_total_query, batch_size, c) -> (batch_size, c, num_total_query) + memory = memory.permute(1, 2, 0) + + # from low resolution to high resolution + num_query_per_level = [e[0] * e[1] for e in spatial_shapes] + outs = torch.split(memory, num_query_per_level, dim=-1) + outs = [x.reshape(batch_size, -1, spatial_shapes[i][0], spatial_shapes[i][1]) for i, x in enumerate(outs)] + + for i in range(self.num_input_levels - self.num_encoder_levels - 1, -1, -1): + x = feats[i] + cur_feat = self.lateral_convs[i](x) + y = cur_feat + F.interpolate(outs[-1], size=cur_feat.shape[-2:], mode="bilinear", align_corners=False) + y = self.output_convs[i](y) + outs.append(y) + multi_scale_features = outs[: self.num_outs] + + mask_feature = self.mask_feature(outs[-1]) + return mask_feature, multi_scale_features diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/segmentors/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/segmentors/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..adf0062691e4889612e118f28ced853cd0bc33db --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/segmentors/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .encoder_decoder_mask2former import EncoderDecoderMask2Former diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/segmentors/encoder_decoder_mask2former.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/segmentors/encoder_decoder_mask2former.py new file mode 100644 index 0000000000000000000000000000000000000000..cfe572c9d317303bff8d51b85217d144906ebfe7 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/segmentors/encoder_decoder_mask2former.py @@ -0,0 +1,271 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmseg.core import add_prefix +from mmseg.models import builder +from mmseg.models.builder import SEGMENTORS +from mmseg.models.segmentors.base import BaseSegmentor +from mmseg.ops import resize + + +@SEGMENTORS.register_module() +class EncoderDecoderMask2Former(BaseSegmentor): + """Encoder Decoder segmentors. + + EncoderDecoder typically consists of backbone, decode_head, auxiliary_head. + Note that auxiliary_head is only used for deep supervision during training, + which could be dumped during inference. + """ + + def __init__( + self, + backbone, + decode_head, + neck=None, + auxiliary_head=None, + train_cfg=None, + test_cfg=None, + pretrained=None, + init_cfg=None, + ): + super(EncoderDecoderMask2Former, self).__init__(init_cfg) + if pretrained is not None: + assert backbone.get("pretrained") is None, "both backbone and segmentor set pretrained weight" + backbone.pretrained = pretrained + self.backbone = builder.build_backbone(backbone) + if neck is not None: + self.neck = builder.build_neck(neck) + decode_head.update(train_cfg=train_cfg) + decode_head.update(test_cfg=test_cfg) + self._init_decode_head(decode_head) + self._init_auxiliary_head(auxiliary_head) + + self.train_cfg = train_cfg + self.test_cfg = test_cfg + + assert self.with_decode_head + + def _init_decode_head(self, decode_head): + """Initialize ``decode_head``""" + self.decode_head = builder.build_head(decode_head) + self.align_corners = self.decode_head.align_corners + self.num_classes = self.decode_head.num_classes + + def _init_auxiliary_head(self, auxiliary_head): + """Initialize ``auxiliary_head``""" + if auxiliary_head is not None: + if isinstance(auxiliary_head, list): + self.auxiliary_head = nn.ModuleList() + for head_cfg in auxiliary_head: + self.auxiliary_head.append(builder.build_head(head_cfg)) + else: + self.auxiliary_head = builder.build_head(auxiliary_head) + + def extract_feat(self, img): + """Extract features from images.""" + x = self.backbone(img) + if self.with_neck: + x = self.neck(x) + return x + + def encode_decode(self, img, img_metas): + """Encode images with backbone and decode into a semantic segmentation + map of the same size as input.""" + x = self.extract_feat(img) + out = self._decode_head_forward_test(x, img_metas) + out = resize(input=out, size=img.shape[2:], mode="bilinear", align_corners=self.align_corners) + return out + + def _decode_head_forward_train(self, x, img_metas, gt_semantic_seg, **kwargs): + """Run forward function and calculate loss for decode head in + training.""" + losses = dict() + loss_decode = self.decode_head.forward_train(x, img_metas, gt_semantic_seg, **kwargs) + + losses.update(add_prefix(loss_decode, "decode")) + return losses + + def _decode_head_forward_test(self, x, img_metas): + """Run forward function and calculate loss for decode head in + inference.""" + seg_logits = self.decode_head.forward_test(x, img_metas, self.test_cfg) + return seg_logits + + def _auxiliary_head_forward_train(self, x, img_metas, gt_semantic_seg): + """Run forward function and calculate loss for auxiliary head in + training.""" + losses = dict() + if isinstance(self.auxiliary_head, nn.ModuleList): + for idx, aux_head in enumerate(self.auxiliary_head): + loss_aux = aux_head.forward_train(x, img_metas, gt_semantic_seg, self.train_cfg) + losses.update(add_prefix(loss_aux, f"aux_{idx}")) + else: + loss_aux = self.auxiliary_head.forward_train(x, img_metas, gt_semantic_seg, self.train_cfg) + losses.update(add_prefix(loss_aux, "aux")) + + return losses + + def forward_dummy(self, img): + """Dummy forward function.""" + seg_logit = self.encode_decode(img, None) + + return seg_logit + + def forward_train(self, img, img_metas, gt_semantic_seg, **kwargs): + """Forward function for training. + + Args: + img (Tensor): Input images. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `mmseg/datasets/pipelines/formatting.py:Collect`. + gt_semantic_seg (Tensor): Semantic segmentation masks + used if the architecture supports semantic segmentation task. + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + + x = self.extract_feat(img) + + losses = dict() + + loss_decode = self._decode_head_forward_train(x, img_metas, gt_semantic_seg, **kwargs) + losses.update(loss_decode) + + if self.with_auxiliary_head: + loss_aux = self._auxiliary_head_forward_train(x, img_metas, gt_semantic_seg) + losses.update(loss_aux) + + return losses + + def slide_inference(self, img, img_meta, rescale): + """Inference by sliding-window with overlap. + + If h_crop > h_img or w_crop > w_img, the small patch will be used to + decode without padding. + """ + + h_stride, w_stride = self.test_cfg.stride + h_crop, w_crop = self.test_cfg.crop_size + batch_size, _, h_img, w_img = img.size() + num_classes = self.num_classes + h_grids = max(h_img - h_crop + h_stride - 1, 0) // h_stride + 1 + w_grids = max(w_img - w_crop + w_stride - 1, 0) // w_stride + 1 + preds = img.new_zeros((batch_size, num_classes, h_img, w_img)) + count_mat = img.new_zeros((batch_size, 1, h_img, w_img)) + for h_idx in range(h_grids): + for w_idx in range(w_grids): + y1 = h_idx * h_stride + x1 = w_idx * w_stride + y2 = min(y1 + h_crop, h_img) + x2 = min(x1 + w_crop, w_img) + y1 = max(y2 - h_crop, 0) + x1 = max(x2 - w_crop, 0) + crop_img = img[:, :, y1:y2, x1:x2] + crop_seg_logit = self.encode_decode(crop_img, img_meta) + preds += F.pad(crop_seg_logit, (int(x1), int(preds.shape[3] - x2), int(y1), int(preds.shape[2] - y2))) + + count_mat[:, :, y1:y2, x1:x2] += 1 + assert (count_mat == 0).sum() == 0 + if torch.onnx.is_in_onnx_export(): + # cast count_mat to constant while exporting to ONNX + count_mat = torch.from_numpy(count_mat.cpu().detach().numpy()).to(device=img.device) + preds = preds / count_mat + if rescale: + preds = resize( + preds, + size=img_meta[0]["ori_shape"][:2], + mode="bilinear", + align_corners=self.align_corners, + warning=False, + ) + return preds + + def whole_inference(self, img, img_meta, rescale): + """Inference with full image.""" + + seg_logit = self.encode_decode(img, img_meta) + if rescale: + # support dynamic shape for onnx + if torch.onnx.is_in_onnx_export(): + size = img.shape[2:] + else: + size = img_meta[0]["ori_shape"][:2] + seg_logit = resize(seg_logit, size=size, mode="bilinear", align_corners=self.align_corners, warning=False) + + return seg_logit + + def inference(self, img, img_meta, rescale): + """Inference with slide/whole style. + + Args: + img (Tensor): The input image of shape (N, 3, H, W). + img_meta (dict): Image info dict where each dict has: 'img_shape', + 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `mmseg/datasets/pipelines/formatting.py:Collect`. + rescale (bool): Whether rescale back to original shape. + + Returns: + Tensor: The output segmentation map. + """ + + assert self.test_cfg.mode in ["slide", "whole"] + ori_shape = img_meta[0]["ori_shape"] + assert all(_["ori_shape"] == ori_shape for _ in img_meta) + if self.test_cfg.mode == "slide": + seg_logit = self.slide_inference(img, img_meta, rescale) + else: + seg_logit = self.whole_inference(img, img_meta, rescale) + output = F.softmax(seg_logit, dim=1) + flip = img_meta[0]["flip"] + if flip: + flip_direction = img_meta[0]["flip_direction"] + assert flip_direction in ["horizontal", "vertical"] + if flip_direction == "horizontal": + output = output.flip(dims=(3,)) + elif flip_direction == "vertical": + output = output.flip(dims=(2,)) + + return output + + def simple_test(self, img, img_meta, rescale=True): + """Simple test with single image.""" + seg_logit = self.inference(img, img_meta, rescale) + seg_pred = seg_logit.argmax(dim=1) + if torch.onnx.is_in_onnx_export(): + # our inference backend only support 4D output + seg_pred = seg_pred.unsqueeze(0) + return seg_pred + seg_pred = seg_pred.cpu().numpy() + # unravel batch dim + seg_pred = list(seg_pred) + return seg_pred + + def aug_test(self, imgs, img_metas, rescale=True): + """Test with augmentations. + + Only rescale=True is supported. + """ + # aug_test rescale all imgs back to ori_shape for now + assert rescale + # to save memory, we get augmented seg logit inplace + seg_logit = self.inference(imgs[0], img_metas[0], rescale) + for i in range(1, len(imgs)): + cur_seg_logit = self.inference(imgs[i], img_metas[i], rescale) + seg_logit += cur_seg_logit + seg_logit /= len(imgs) + seg_pred = seg_logit.argmax(dim=1) + seg_pred = seg_pred.cpu().numpy() + # unravel batch dim + seg_pred = list(seg_pred) + return seg_pred diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e7fdc1668b1015c8feea8fa1a4691bc0ebdbd936 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/__init__.py @@ -0,0 +1,9 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .assigner import MaskHungarianAssigner +from .point_sample import get_uncertain_point_coords_with_randomness +from .positional_encoding import LearnedPositionalEncoding, SinePositionalEncoding +from .transformer import DetrTransformerDecoder, DetrTransformerDecoderLayer, DynamicConv, Transformer diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/assigner.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/assigner.py new file mode 100644 index 0000000000000000000000000000000000000000..3cb08fc1bb2e36336989b45a1d3850f260c05963 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/assigner.py @@ -0,0 +1,157 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from abc import ABCMeta, abstractmethod + +import torch + +from ..builder import MASK_ASSIGNERS, build_match_cost + +try: + from scipy.optimize import linear_sum_assignment +except ImportError: + linear_sum_assignment = None + + +class AssignResult(metaclass=ABCMeta): + """Collection of assign results.""" + + def __init__(self, num_gts, gt_inds, labels): + self.num_gts = num_gts + self.gt_inds = gt_inds + self.labels = labels + + @property + def info(self): + info = { + "num_gts": self.num_gts, + "gt_inds": self.gt_inds, + "labels": self.labels, + } + return info + + +class BaseAssigner(metaclass=ABCMeta): + """Base assigner that assigns boxes to ground truth boxes.""" + + @abstractmethod + def assign(self, masks, gt_masks, gt_masks_ignore=None, gt_labels=None): + """Assign boxes to either a ground truth boxes or a negative boxes.""" + pass + + +@MASK_ASSIGNERS.register_module() +class MaskHungarianAssigner(BaseAssigner): + """Computes one-to-one matching between predictions and ground truth for + mask. + + This class computes an assignment between the targets and the predictions + based on the costs. The costs are weighted sum of three components: + classification cost, regression L1 cost and regression iou cost. The + targets don't include the no_object, so generally there are more + predictions than targets. After the one-to-one matching, the un-matched + are treated as backgrounds. Thus each query prediction will be assigned + with `0` or a positive integer indicating the ground truth index: + + - 0: negative sample, no assigned gt + - positive integer: positive sample, index (1-based) of assigned gt + + Args: + cls_cost (obj:`mmcv.ConfigDict`|dict): Classification cost config. + mask_cost (obj:`mmcv.ConfigDict`|dict): Mask cost config. + dice_cost (obj:`mmcv.ConfigDict`|dict): Dice cost config. + """ + + def __init__( + self, + cls_cost=dict(type="ClassificationCost", weight=1.0), + dice_cost=dict(type="DiceCost", weight=1.0), + mask_cost=dict(type="MaskFocalCost", weight=1.0), + ): + self.cls_cost = build_match_cost(cls_cost) + self.dice_cost = build_match_cost(dice_cost) + self.mask_cost = build_match_cost(mask_cost) + + def assign(self, cls_pred, mask_pred, gt_labels, gt_masks, img_meta, gt_masks_ignore=None, eps=1e-7): + """Computes one-to-one matching based on the weighted costs. + + This method assign each query prediction to a ground truth or + background. The `assigned_gt_inds` with -1 means don't care, + 0 means negative sample, and positive number is the index (1-based) + of assigned gt. + The assignment is done in the following steps, the order matters. + + 1. assign every prediction to -1 + 2. compute the weighted costs + 3. do Hungarian matching on CPU based on the costs + 4. assign all to 0 (background) first, then for each matched pair + between predictions and gts, treat this prediction as foreground + and assign the corresponding gt index (plus 1) to it. + + Args: + mask_pred (Tensor): Predicted mask, shape [num_query, h, w] + cls_pred (Tensor): Predicted classification logits, shape + [num_query, num_class]. + gt_masks (Tensor): Ground truth mask, shape [num_gt, h, w]. + gt_labels (Tensor): Label of `gt_masks`, shape (num_gt,). + img_meta (dict): Meta information for current image. + gt_masks_ignore (Tensor, optional): Ground truth masks that are + labelled as `ignored`. Default None. + eps (int | float, optional): A value added to the denominator for + numerical stability. Default 1e-7. + + Returns: + :obj:`AssignResult`: The assigned result. + """ + assert gt_masks_ignore is None, "Only case when gt_masks_ignore is None is supported." + num_gts, num_queries = gt_labels.shape[0], cls_pred.shape[0] + + # 1. assign -1 by default + assigned_gt_inds = cls_pred.new_full((num_queries,), -1, dtype=torch.long) + assigned_labels = cls_pred.new_full((num_queries,), -1, dtype=torch.long) + if num_gts == 0 or num_queries == 0: + # No ground truth or boxes, return empty assignment + if num_gts == 0: + # No ground truth, assign all to background + assigned_gt_inds[:] = 0 + return AssignResult(num_gts, assigned_gt_inds, labels=assigned_labels) + + # 2. compute the weighted costs + # classification and maskcost. + if self.cls_cost.weight != 0 and cls_pred is not None: + cls_cost = self.cls_cost(cls_pred, gt_labels) + else: + cls_cost = 0 + + if self.mask_cost.weight != 0: + # mask_pred shape = [nq, h, w] + # gt_mask shape = [ng, h, w] + # mask_cost shape = [nq, ng] + mask_cost = self.mask_cost(mask_pred, gt_masks) + else: + mask_cost = 0 + + if self.dice_cost.weight != 0: + dice_cost = self.dice_cost(mask_pred, gt_masks) + else: + dice_cost = 0 + cost = cls_cost + mask_cost + dice_cost + + # 3. do Hungarian matching on CPU using linear_sum_assignment + cost = cost.detach().cpu() + if linear_sum_assignment is None: + raise ImportError('Please run "pip install scipy" ' "to install scipy first.") + + matched_row_inds, matched_col_inds = linear_sum_assignment(cost) + matched_row_inds = torch.from_numpy(matched_row_inds).to(cls_pred.device) + matched_col_inds = torch.from_numpy(matched_col_inds).to(cls_pred.device) + + # 4. assign backgrounds and foregrounds + # assign all indices to backgrounds first + assigned_gt_inds[:] = 0 + # assign foregrounds based on matching results + assigned_gt_inds[matched_row_inds] = matched_col_inds + 1 + assigned_labels[matched_row_inds] = gt_labels[matched_col_inds] + return AssignResult(num_gts, assigned_gt_inds, labels=assigned_labels) diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/point_sample.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/point_sample.py new file mode 100644 index 0000000000000000000000000000000000000000..9f1134082bafb51432618a9632592db070f87284 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/point_sample.py @@ -0,0 +1,86 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +from mmcv.ops import point_sample + + +def get_uncertainty(mask_pred, labels): + """Estimate uncertainty based on pred logits. + + We estimate uncertainty as L1 distance between 0.0 and the logits + prediction in 'mask_pred' for the foreground class in `classes`. + + Args: + mask_pred (Tensor): mask predication logits, shape (num_rois, + num_classes, mask_height, mask_width). + + labels (list[Tensor]): Either predicted or ground truth label for + each predicted mask, of length num_rois. + + Returns: + scores (Tensor): Uncertainty scores with the most uncertain + locations having the highest uncertainty score, + shape (num_rois, 1, mask_height, mask_width) + """ + if mask_pred.shape[1] == 1: + gt_class_logits = mask_pred.clone() + else: + inds = torch.arange(mask_pred.shape[0], device=mask_pred.device) + gt_class_logits = mask_pred[inds, labels].unsqueeze(1) + return -torch.abs(gt_class_logits) + + +def get_uncertain_point_coords_with_randomness( + mask_pred, labels, num_points, oversample_ratio, importance_sample_ratio +): + """Get ``num_points`` most uncertain points with random points during + train. + + Sample points in [0, 1] x [0, 1] coordinate space based on their + uncertainty. The uncertainties are calculated for each point using + 'get_uncertainty()' function that takes point's logit prediction as + input. + + Args: + mask_pred (Tensor): A tensor of shape (num_rois, num_classes, + mask_height, mask_width) for class-specific or class-agnostic + prediction. + labels (list): The ground truth class for each instance. + num_points (int): The number of points to sample. + oversample_ratio (int): Oversampling parameter. + importance_sample_ratio (float): Ratio of points that are sampled + via importnace sampling. + + Returns: + point_coords (Tensor): A tensor of shape (num_rois, num_points, 2) + that contains the coordinates sampled points. + """ + assert oversample_ratio >= 1 + assert 0 <= importance_sample_ratio <= 1 + batch_size = mask_pred.shape[0] + num_sampled = int(num_points * oversample_ratio) + point_coords = torch.rand(batch_size, num_sampled, 2, device=mask_pred.device) + point_logits = point_sample(mask_pred, point_coords) + # It is crucial to calculate uncertainty based on the sampled + # prediction value for the points. Calculating uncertainties of the + # coarse predictions first and sampling them for points leads to + # incorrect results. To illustrate this: assume uncertainty func( + # logits)=-abs(logits), a sampled point between two coarse + # predictions with -1 and 1 logits has 0 logits, and therefore 0 + # uncertainty value. However, if we calculate uncertainties for the + # coarse predictions first, both will have -1 uncertainty, + # and sampled point will get -1 uncertainty. + point_uncertainties = get_uncertainty(point_logits, labels) + num_uncertain_points = int(importance_sample_ratio * num_points) + num_random_points = num_points - num_uncertain_points + idx = torch.topk(point_uncertainties[:, 0, :], k=num_uncertain_points, dim=1)[1] + shift = num_sampled * torch.arange(batch_size, dtype=torch.long, device=mask_pred.device) + idx += shift[:, None] + point_coords = point_coords.view(-1, 2)[idx.view(-1), :].view(batch_size, num_uncertain_points, 2) + if num_random_points > 0: + rand_roi_coords = torch.rand(batch_size, num_random_points, 2, device=mask_pred.device) + point_coords = torch.cat((point_coords, rand_roi_coords), dim=1) + return point_coords diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/positional_encoding.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/positional_encoding.py new file mode 100644 index 0000000000000000000000000000000000000000..bf5d6fabe946d06fe97cc799da47bae93758b34e --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/positional_encoding.py @@ -0,0 +1,152 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn as nn +from mmcv.cnn.bricks.transformer import POSITIONAL_ENCODING +from mmcv.runner import BaseModule + + +@POSITIONAL_ENCODING.register_module() +class SinePositionalEncoding(BaseModule): + """Position encoding with sine and cosine functions. + + See `End-to-End Object Detection with Transformers + `_ for details. + + Args: + num_feats (int): The feature dimension for each position + along x-axis or y-axis. Note the final returned dimension + for each position is 2 times of this value. + temperature (int, optional): The temperature used for scaling + the position embedding. Defaults to 10000. + normalize (bool, optional): Whether to normalize the position + embedding. Defaults to False. + scale (float, optional): A scale factor that scales the position + embedding. The scale will be used only when `normalize` is True. + Defaults to 2*pi. + eps (float, optional): A value added to the denominator for + numerical stability. Defaults to 1e-6. + offset (float): offset add to embed when do the normalization. + Defaults to 0. + init_cfg (dict or list[dict], optional): Initialization config dict. + Default: None + """ + + def __init__( + self, num_feats, temperature=10000, normalize=False, scale=2 * math.pi, eps=1e-6, offset=0.0, init_cfg=None + ): + super(SinePositionalEncoding, self).__init__(init_cfg) + if normalize: + assert isinstance(scale, (float, int)), ( + "when normalize is set," "scale should be provided and in float or int type, " f"found {type(scale)}" + ) + self.num_feats = num_feats + self.temperature = temperature + self.normalize = normalize + self.scale = scale + self.eps = eps + self.offset = offset + + def forward(self, mask): + """Forward function for `SinePositionalEncoding`. + + Args: + mask (Tensor): ByteTensor mask. Non-zero values representing + ignored positions, while zero values means valid positions + for this image. Shape [bs, h, w]. + + Returns: + pos (Tensor): Returned position embedding with shape + [bs, num_feats*2, h, w]. + """ + # For convenience of exporting to ONNX, it's required to convert + # `masks` from bool to int. + mask = mask.to(torch.int) + not_mask = 1 - mask # logical_not + y_embed = not_mask.cumsum(1, dtype=torch.float32) + x_embed = not_mask.cumsum(2, dtype=torch.float32) + if self.normalize: + y_embed = (y_embed + self.offset) / (y_embed[:, -1:, :] + self.eps) * self.scale + x_embed = (x_embed + self.offset) / (x_embed[:, :, -1:] + self.eps) * self.scale + dim_t = torch.arange(self.num_feats, dtype=torch.float32, device=mask.device) + dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_feats) + pos_x = x_embed[:, :, :, None] / dim_t + pos_y = y_embed[:, :, :, None] / dim_t + # use `view` instead of `flatten` for dynamically exporting to ONNX + B, H, W = mask.size() + pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).view(B, H, W, -1) + pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).view(B, H, W, -1) + pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2) + return pos + + def __repr__(self): + """str: a string that describes the module""" + repr_str = self.__class__.__name__ + repr_str += f"(num_feats={self.num_feats}, " + repr_str += f"temperature={self.temperature}, " + repr_str += f"normalize={self.normalize}, " + repr_str += f"scale={self.scale}, " + repr_str += f"eps={self.eps})" + return repr_str + + +@POSITIONAL_ENCODING.register_module() +class LearnedPositionalEncoding(BaseModule): + """Position embedding with learnable embedding weights. + + Args: + num_feats (int): The feature dimension for each position + along x-axis or y-axis. The final returned dimension for + each position is 2 times of this value. + row_num_embed (int, optional): The dictionary size of row embeddings. + Default 50. + col_num_embed (int, optional): The dictionary size of col embeddings. + Default 50. + init_cfg (dict or list[dict], optional): Initialization config dict. + """ + + def __init__(self, num_feats, row_num_embed=50, col_num_embed=50, init_cfg=dict(type="Uniform", layer="Embedding")): + super(LearnedPositionalEncoding, self).__init__(init_cfg) + self.row_embed = nn.Embedding(row_num_embed, num_feats) + self.col_embed = nn.Embedding(col_num_embed, num_feats) + self.num_feats = num_feats + self.row_num_embed = row_num_embed + self.col_num_embed = col_num_embed + + def forward(self, mask): + """Forward function for `LearnedPositionalEncoding`. + + Args: + mask (Tensor): ByteTensor mask. Non-zero values representing + ignored positions, while zero values means valid positions + for this image. Shape [bs, h, w]. + + Returns: + pos (Tensor): Returned position embedding with shape + [bs, num_feats*2, h, w]. + """ + h, w = mask.shape[-2:] + x = torch.arange(w, device=mask.device) + y = torch.arange(h, device=mask.device) + x_embed = self.col_embed(x) + y_embed = self.row_embed(y) + pos = ( + torch.cat((x_embed.unsqueeze(0).repeat(h, 1, 1), y_embed.unsqueeze(1).repeat(1, w, 1)), dim=-1) + .permute(2, 0, 1) + .unsqueeze(0) + .repeat(mask.shape[0], 1, 1, 1) + ) + return pos + + def __repr__(self): + """str: a string that describes the module""" + repr_str = self.__class__.__name__ + repr_str += f"(num_feats={self.num_feats}, " + repr_str += f"row_num_embed={self.row_num_embed}, " + repr_str += f"col_num_embed={self.col_num_embed})" + return repr_str diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/transformer.py b/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..8befe6011a34d5ccecb82c8b17b61e19f732f96b --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/models/utils/transformer.py @@ -0,0 +1,989 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import math +import warnings +from typing import Sequence + +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.utils.checkpoint as cp +from mmcv.cnn import Linear, build_activation_layer, build_norm_layer, xavier_init +from mmcv.cnn.bricks.drop import build_dropout +from mmcv.cnn.bricks.registry import FEEDFORWARD_NETWORK, TRANSFORMER_LAYER, TRANSFORMER_LAYER_SEQUENCE +from mmcv.cnn.bricks.transformer import BaseTransformerLayer, TransformerLayerSequence, build_transformer_layer_sequence +from mmcv.runner.base_module import BaseModule, Sequential +from mmcv.utils import deprecated_api_warning, to_2tuple +from torch.nn.init import normal_ + +from ..builder import TRANSFORMER + +try: + from mmcv.ops.multi_scale_deform_attn import MultiScaleDeformableAttention + +except ImportError: + warnings.warn( + "`MultiScaleDeformableAttention` in MMCV has been moved to " + "`mmcv.ops.multi_scale_deform_attn`, please update your MMCV" + ) + from mmcv.cnn.bricks.transformer import MultiScaleDeformableAttention + + +class AdaptivePadding(nn.Module): + """Applies padding to input (if needed) so that input can get fully covered + by filter you specified. It support two modes "same" and "corner". The + "same" mode is same with "SAME" padding mode in TensorFlow, pad zero around + input. The "corner" mode would pad zero to bottom right. + + Args: + kernel_size (int | tuple): Size of the kernel: + stride (int | tuple): Stride of the filter. Default: 1: + dilation (int | tuple): Spacing between kernel elements. + Default: 1 + padding (str): Support "same" and "corner", "corner" mode + would pad zero to bottom right, and "same" mode would + pad zero around input. Default: "corner". + Example: + >>> kernel_size = 16 + >>> stride = 16 + >>> dilation = 1 + >>> input = torch.rand(1, 1, 15, 17) + >>> adap_pad = AdaptivePadding( + >>> kernel_size=kernel_size, + >>> stride=stride, + >>> dilation=dilation, + >>> padding="corner") + >>> out = adap_pad(input) + >>> assert (out.shape[2], out.shape[3]) == (16, 32) + >>> input = torch.rand(1, 1, 16, 17) + >>> out = adap_pad(input) + >>> assert (out.shape[2], out.shape[3]) == (16, 32) + """ + + def __init__(self, kernel_size=1, stride=1, dilation=1, padding="corner"): + + super(AdaptivePadding, self).__init__() + + assert padding in ("same", "corner") + + kernel_size = to_2tuple(kernel_size) + stride = to_2tuple(stride) + padding = to_2tuple(padding) + dilation = to_2tuple(dilation) + + self.padding = padding + self.kernel_size = kernel_size + self.stride = stride + self.dilation = dilation + + def get_pad_shape(self, input_shape): + input_h, input_w = input_shape + kernel_h, kernel_w = self.kernel_size + stride_h, stride_w = self.stride + output_h = math.ceil(input_h / stride_h) + output_w = math.ceil(input_w / stride_w) + pad_h = max((output_h - 1) * stride_h + (kernel_h - 1) * self.dilation[0] + 1 - input_h, 0) + pad_w = max((output_w - 1) * stride_w + (kernel_w - 1) * self.dilation[1] + 1 - input_w, 0) + return pad_h, pad_w + + def forward(self, x): + pad_h, pad_w = self.get_pad_shape(x.size()[-2:]) + if pad_h > 0 or pad_w > 0: + if self.padding == "corner": + x = F.pad(x, [0, pad_w, 0, pad_h]) + elif self.padding == "same": + x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2]) + return x + + +class PatchMerging(BaseModule): + """Merge patch feature map. + + This layer groups feature map by kernel_size, and applies norm and linear + layers to the grouped feature map. Our implementation uses `nn.Unfold` to + merge patch, which is about 25% faster than original implementation. + Instead, we need to modify pretrained models for compatibility. + + Args: + in_channels (int): The num of input channels. + to gets fully covered by filter and stride you specified.. + Default: True. + out_channels (int): The num of output channels. + kernel_size (int | tuple, optional): the kernel size in the unfold + layer. Defaults to 2. + stride (int | tuple, optional): the stride of the sliding blocks in the + unfold layer. Default: None. (Would be set as `kernel_size`) + padding (int | tuple | string ): The padding length of + embedding conv. When it is a string, it means the mode + of adaptive padding, support "same" and "corner" now. + Default: "corner". + dilation (int | tuple, optional): dilation parameter in the unfold + layer. Default: 1. + bias (bool, optional): Whether to add bias in linear layer or not. + Defaults: False. + norm_cfg (dict, optional): Config dict for normalization layer. + Default: dict(type='LN'). + init_cfg (dict, optional): The extra config for initialization. + Default: None. + """ + + def __init__( + self, + in_channels, + out_channels, + kernel_size=2, + stride=None, + padding="corner", + dilation=1, + bias=False, + norm_cfg=dict(type="LN"), + init_cfg=None, + ): + super().__init__(init_cfg=init_cfg) + self.in_channels = in_channels + self.out_channels = out_channels + if stride: + stride = stride + else: + stride = kernel_size + + kernel_size = to_2tuple(kernel_size) + stride = to_2tuple(stride) + dilation = to_2tuple(dilation) + + if isinstance(padding, str): + self.adap_padding = AdaptivePadding( + kernel_size=kernel_size, stride=stride, dilation=dilation, padding=padding + ) + # disable the padding of unfold + padding = 0 + else: + self.adap_padding = None + + padding = to_2tuple(padding) + self.sampler = nn.Unfold(kernel_size=kernel_size, dilation=dilation, padding=padding, stride=stride) + + sample_dim = kernel_size[0] * kernel_size[1] * in_channels + + if norm_cfg is not None: + self.norm = build_norm_layer(norm_cfg, sample_dim)[1] + else: + self.norm = None + + self.reduction = nn.Linear(sample_dim, out_channels, bias=bias) + + def forward(self, x, input_size): + """ + Args: + x (Tensor): Has shape (B, H*W, C_in). + input_size (tuple[int]): The spatial shape of x, arrange as (H, W). + Default: None. + + Returns: + tuple: Contains merged results and its spatial shape. + + - x (Tensor): Has shape (B, Merged_H * Merged_W, C_out) + - out_size (tuple[int]): Spatial shape of x, arrange as + (Merged_H, Merged_W). + """ + B, L, C = x.shape + assert isinstance(input_size, Sequence), f"Expect " f"input_size is " f"`Sequence` " f"but get {input_size}" + + H, W = input_size + assert L == H * W, "input feature has wrong size" + + x = x.view(B, H, W, C).permute([0, 3, 1, 2]) # B, C, H, W + # Use nn.Unfold to merge patch. About 25% faster than original method, + # but need to modify pretrained model for compatibility + + if self.adap_padding: + x = self.adap_padding(x) + H, W = x.shape[-2:] + + x = self.sampler(x) + # if kernel_size=2 and stride=2, x should has shape (B, 4*C, H/2*W/2) + + out_h = ( + H + 2 * self.sampler.padding[0] - self.sampler.dilation[0] * (self.sampler.kernel_size[0] - 1) - 1 + ) // self.sampler.stride[0] + 1 + out_w = ( + W + 2 * self.sampler.padding[1] - self.sampler.dilation[1] * (self.sampler.kernel_size[1] - 1) - 1 + ) // self.sampler.stride[1] + 1 + + output_size = (out_h, out_w) + x = x.transpose(1, 2) # B, H/2*W/2, 4*C + x = self.norm(x) if self.norm else x + x = self.reduction(x) + return x, output_size + + +def inverse_sigmoid(x, eps=1e-5): + """Inverse function of sigmoid. + + Args: + x (Tensor): The tensor to do the + inverse. + eps (float): EPS avoid numerical + overflow. Defaults 1e-5. + Returns: + Tensor: The x has passed the inverse + function of sigmoid, has same + shape with input. + """ + x = x.clamp(min=0, max=1) + x1 = x.clamp(min=eps) + x2 = (1 - x).clamp(min=eps) + return torch.log(x1 / x2) + + +@FEEDFORWARD_NETWORK.register_module(force=True) +class FFN(BaseModule): + """Implements feed-forward networks (FFNs) with identity connection. + Args: + embed_dims (int): The feature dimension. Same as + `MultiheadAttention`. Defaults: 256. + feedforward_channels (int): The hidden dimension of FFNs. + Defaults: 1024. + num_fcs (int, optional): The number of fully-connected layers in + FFNs. Default: 2. + act_cfg (dict, optional): The activation config for FFNs. + Default: dict(type='ReLU') + ffn_drop (float, optional): Probability of an element to be + zeroed in FFN. Default 0.0. + add_identity (bool, optional): Whether to add the + identity connection. Default: `True`. + dropout_layer (obj:`ConfigDict`): The dropout_layer used + when adding the shortcut. + init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization. + Default: None. + """ + + @deprecated_api_warning({"dropout": "ffn_drop", "add_residual": "add_identity"}, cls_name="FFN") + def __init__( + self, + embed_dims=256, + feedforward_channels=1024, + num_fcs=2, + act_cfg=dict(type="ReLU", inplace=True), + ffn_drop=0.0, + dropout_layer=None, + add_identity=True, + init_cfg=None, + with_cp=False, + **kwargs, + ): + super().__init__(init_cfg) + assert num_fcs >= 2, "num_fcs should be no less " f"than 2. got {num_fcs}." + self.embed_dims = embed_dims + self.feedforward_channels = feedforward_channels + self.num_fcs = num_fcs + self.act_cfg = act_cfg + self.activate = build_activation_layer(act_cfg) + self.with_cp = with_cp + layers = [] + in_channels = embed_dims + for _ in range(num_fcs - 1): + layers.append(Sequential(Linear(in_channels, feedforward_channels), self.activate, nn.Dropout(ffn_drop))) + in_channels = feedforward_channels + layers.append(Linear(feedforward_channels, embed_dims)) + layers.append(nn.Dropout(ffn_drop)) + self.layers = Sequential(*layers) + self.dropout_layer = build_dropout(dropout_layer) if dropout_layer else torch.nn.Identity() + self.add_identity = add_identity + + @deprecated_api_warning({"residual": "identity"}, cls_name="FFN") + def forward(self, x, identity=None): + """Forward function for `FFN`. + The function would add x to the output tensor if residue is None. + """ + + if self.with_cp and x.requires_grad: + out = cp.checkpoint(self.layers, x) + else: + out = self.layers(x) + + if not self.add_identity: + return self.dropout_layer(out) + if identity is None: + identity = x + return identity + self.dropout_layer(out) + + +@TRANSFORMER_LAYER.register_module() +class DetrTransformerDecoderLayer(BaseTransformerLayer): + """Implements decoder layer in DETR transformer. + + Args: + attn_cfgs (list[`mmcv.ConfigDict`] | list[dict] | dict )): + Configs for self_attention or cross_attention, the order + should be consistent with it in `operation_order`. If it is + a dict, it would be expand to the number of attention in + `operation_order`. + feedforward_channels (int): The hidden dimension for FFNs. + ffn_dropout (float): Probability of an element to be zeroed + in ffn. Default 0.0. + operation_order (tuple[str]): The execution order of operation + in transformer. Such as ('self_attn', 'norm', 'ffn', 'norm'). + Default：None + act_cfg (dict): The activation config for FFNs. Default: `LN` + norm_cfg (dict): Config dict for normalization layer. + Default: `LN`. + ffn_num_fcs (int): The number of fully-connected layers in FFNs. + Default：2. + """ + + def __init__( + self, + attn_cfgs, + feedforward_channels, + ffn_dropout=0.0, + operation_order=None, + act_cfg=dict(type="ReLU", inplace=True), + norm_cfg=dict(type="LN"), + ffn_num_fcs=2, + **kwargs, + ): + super(DetrTransformerDecoderLayer, self).__init__( + attn_cfgs=attn_cfgs, + feedforward_channels=feedforward_channels, + ffn_dropout=ffn_dropout, + operation_order=operation_order, + act_cfg=act_cfg, + norm_cfg=norm_cfg, + ffn_num_fcs=ffn_num_fcs, + **kwargs, + ) + assert len(operation_order) == 6 + assert set(operation_order) == set(["self_attn", "norm", "cross_attn", "ffn"]) + + +@TRANSFORMER_LAYER_SEQUENCE.register_module() +class DetrTransformerEncoder(TransformerLayerSequence): + """TransformerEncoder of DETR. + + Args: + post_norm_cfg (dict): Config of last normalization layer. Default： + `LN`. Only used when `self.pre_norm` is `True` + """ + + def __init__(self, *args, post_norm_cfg=dict(type="LN"), **kwargs): + super(DetrTransformerEncoder, self).__init__(*args, **kwargs) + if post_norm_cfg is not None: + self.post_norm = build_norm_layer(post_norm_cfg, self.embed_dims)[1] if self.pre_norm else None + else: + assert not self.pre_norm, f"Use prenorm in " f"{self.__class__.__name__}," f"Please specify post_norm_cfg" + self.post_norm = None + + def forward(self, *args, **kwargs): + """Forward function for `TransformerCoder`. + + Returns: + Tensor: forwarded results with shape [num_query, bs, embed_dims]. + """ + x = super(DetrTransformerEncoder, self).forward(*args, **kwargs) + if self.post_norm is not None: + x = self.post_norm(x) + return x + + +@TRANSFORMER_LAYER_SEQUENCE.register_module() +class DetrTransformerDecoder(TransformerLayerSequence): + """Implements the decoder in DETR transformer. + + Args: + return_intermediate (bool): Whether to return intermediate outputs. + post_norm_cfg (dict): Config of last normalization layer. Default： + `LN`. + """ + + def __init__(self, *args, post_norm_cfg=dict(type="LN"), return_intermediate=False, **kwargs): + + super(DetrTransformerDecoder, self).__init__(*args, **kwargs) + self.return_intermediate = return_intermediate + if post_norm_cfg is not None: + self.post_norm = build_norm_layer(post_norm_cfg, self.embed_dims)[1] + else: + self.post_norm = None + + def forward(self, query, *args, **kwargs): + """Forward function for `TransformerDecoder`. + + Args: + query (Tensor): Input query with shape + `(num_query, bs, embed_dims)`. + + Returns: + Tensor: Results with shape [1, num_query, bs, embed_dims] when + return_intermediate is `False`, otherwise it has shape + [num_layers, num_query, bs, embed_dims]. + """ + if not self.return_intermediate: + x = super().forward(query, *args, **kwargs) + if self.post_norm: + x = self.post_norm(x)[None] + return x + + intermediate = [] + for layer in self.layers: + query = layer(query, *args, **kwargs) + if self.return_intermediate: + if self.post_norm is not None: + intermediate.append(self.post_norm(query)) + else: + intermediate.append(query) + return torch.stack(intermediate) + + +@TRANSFORMER.register_module() +class Transformer(BaseModule): + """Implements the DETR transformer. + + Following the official DETR implementation, this module copy-paste + from torch.nn.Transformer with modifications: + + * positional encodings are passed in MultiheadAttention + * extra LN at the end of encoder is removed + * decoder returns a stack of activations from all decoding layers + + See `paper: End-to-End Object Detection with Transformers + `_ for details. + + Args: + encoder (`mmcv.ConfigDict` | Dict): Config of + TransformerEncoder. Defaults to None. + decoder ((`mmcv.ConfigDict` | Dict)): Config of + TransformerDecoder. Defaults to None + init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization. + Defaults to None. + """ + + def __init__(self, encoder=None, decoder=None, init_cfg=None): + super(Transformer, self).__init__(init_cfg=init_cfg) + self.encoder = build_transformer_layer_sequence(encoder) + self.decoder = build_transformer_layer_sequence(decoder) + self.embed_dims = self.encoder.embed_dims + + def init_weights(self): + # follow the official DETR to init parameters + for m in self.modules(): + if hasattr(m, "weight") and m.weight.dim() > 1: + xavier_init(m, distribution="uniform") + self._is_init = True + + def forward(self, x, mask, query_embed, pos_embed): + """Forward function for `Transformer`. + + Args: + x (Tensor): Input query with shape [bs, c, h, w] where + c = embed_dims. + mask (Tensor): The key_padding_mask used for encoder and decoder, + with shape [bs, h, w]. + query_embed (Tensor): The query embedding for decoder, with shape + [num_query, c]. + pos_embed (Tensor): The positional encoding for encoder and + decoder, with the same shape as `x`. + + Returns: + tuple[Tensor]: results of decoder containing the following tensor. + + - out_dec: Output from decoder. If return_intermediate_dec \ + is True output has shape [num_dec_layers, bs, + num_query, embed_dims], else has shape [1, bs, \ + num_query, embed_dims]. + - memory: Output results from encoder, with shape \ + [bs, embed_dims, h, w]. + """ + bs, c, h, w = x.shape + # use `view` instead of `flatten` for dynamically exporting to ONNX + x = x.view(bs, c, -1).permute(2, 0, 1) # [bs, c, h, w] -> [h*w, bs, c] + pos_embed = pos_embed.view(bs, c, -1).permute(2, 0, 1) + query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1) # [num_query, dim] -> [num_query, bs, dim] + mask = mask.view(bs, -1) # [bs, h, w] -> [bs, h*w] + memory = self.encoder(query=x, key=None, value=None, query_pos=pos_embed, query_key_padding_mask=mask) + target = torch.zeros_like(query_embed) + # out_dec: [num_layers, num_query, bs, dim] + out_dec = self.decoder( + query=target, key=memory, value=memory, key_pos=pos_embed, query_pos=query_embed, key_padding_mask=mask + ) + out_dec = out_dec.transpose(1, 2) + memory = memory.permute(1, 2, 0).reshape(bs, c, h, w) + return out_dec, memory + + +@TRANSFORMER_LAYER_SEQUENCE.register_module() +class DeformableDetrTransformerDecoder(TransformerLayerSequence): + """Implements the decoder in DETR transformer. + + Args: + return_intermediate (bool): Whether to return intermediate outputs. + coder_norm_cfg (dict): Config of last normalization layer. Default： + `LN`. + """ + + def __init__(self, *args, return_intermediate=False, **kwargs): + + super(DeformableDetrTransformerDecoder, self).__init__(*args, **kwargs) + self.return_intermediate = return_intermediate + + def forward(self, query, *args, reference_points=None, valid_ratios=None, reg_branches=None, **kwargs): + """Forward function for `TransformerDecoder`. + + Args: + query (Tensor): Input query with shape + `(num_query, bs, embed_dims)`. + reference_points (Tensor): The reference + points of offset. has shape + (bs, num_query, 4) when as_two_stage, + otherwise has shape ((bs, num_query, 2). + valid_ratios (Tensor): The radios of valid + points on the feature map, has shape + (bs, num_levels, 2) + reg_branch: (obj:`nn.ModuleList`): Used for + refining the regression results. Only would + be passed when with_box_refine is True, + otherwise would be passed a `None`. + + Returns: + Tensor: Results with shape [1, num_query, bs, embed_dims] when + return_intermediate is `False`, otherwise it has shape + [num_layers, num_query, bs, embed_dims]. + """ + output = query + intermediate = [] + intermediate_reference_points = [] + for lid, layer in enumerate(self.layers): + if reference_points.shape[-1] == 4: + reference_points_input = ( + reference_points[:, :, None] * torch.cat([valid_ratios, valid_ratios], -1)[:, None] + ) + else: + assert reference_points.shape[-1] == 2 + reference_points_input = reference_points[:, :, None] * valid_ratios[:, None] + output = layer(output, *args, reference_points=reference_points_input, **kwargs) + output = output.permute(1, 0, 2) + + if reg_branches is not None: + tmp = reg_branches[lid](output) + if reference_points.shape[-1] == 4: + new_reference_points = tmp + inverse_sigmoid(reference_points) + new_reference_points = new_reference_points.sigmoid() + else: + assert reference_points.shape[-1] == 2 + new_reference_points = tmp + new_reference_points[..., :2] = tmp[..., :2] + inverse_sigmoid(reference_points) + new_reference_points = new_reference_points.sigmoid() + reference_points = new_reference_points.detach() + + output = output.permute(1, 0, 2) + if self.return_intermediate: + intermediate.append(output) + intermediate_reference_points.append(reference_points) + + if self.return_intermediate: + return torch.stack(intermediate), torch.stack(intermediate_reference_points) + + return output, reference_points + + +@TRANSFORMER.register_module() +class DeformableDetrTransformer(Transformer): + """Implements the DeformableDETR transformer. + + Args: + as_two_stage (bool): Generate query from encoder features. + Default: False. + num_feature_levels (int): Number of feature maps from FPN: + Default: 4. + two_stage_num_proposals (int): Number of proposals when set + `as_two_stage` as True. Default: 300. + """ + + def __init__(self, as_two_stage=False, num_feature_levels=4, two_stage_num_proposals=300, **kwargs): + super(DeformableDetrTransformer, self).__init__(**kwargs) + self.as_two_stage = as_two_stage + self.num_feature_levels = num_feature_levels + self.two_stage_num_proposals = two_stage_num_proposals + self.embed_dims = self.encoder.embed_dims + self.init_layers() + + def init_layers(self): + """Initialize layers of the DeformableDetrTransformer.""" + self.level_embeds = nn.Parameter(torch.Tensor(self.num_feature_levels, self.embed_dims)) + + if self.as_two_stage: + self.enc_output = nn.Linear(self.embed_dims, self.embed_dims) + self.enc_output_norm = nn.LayerNorm(self.embed_dims) + self.pos_trans = nn.Linear(self.embed_dims * 2, self.embed_dims * 2) + self.pos_trans_norm = nn.LayerNorm(self.embed_dims * 2) + else: + self.reference_points = nn.Linear(self.embed_dims, 2) + + def init_weights(self): + """Initialize the transformer weights.""" + for p in self.parameters(): + if p.dim() > 1: + nn.init.xavier_uniform_(p) + for m in self.modules(): + if isinstance(m, MultiScaleDeformableAttention): + m.init_weights() + if not self.as_two_stage: + xavier_init(self.reference_points, distribution="uniform", bias=0.0) + normal_(self.level_embeds) + + def gen_encoder_output_proposals(self, memory, memory_padding_mask, spatial_shapes): + """Generate proposals from encoded memory. + + Args: + memory (Tensor) : The output of encoder, + has shape (bs, num_key, embed_dim). num_key is + equal the number of points on feature map from + all level. + memory_padding_mask (Tensor): Padding mask for memory. + has shape (bs, num_key). + spatial_shapes (Tensor): The shape of all feature maps. + has shape (num_level, 2). + + Returns: + tuple: A tuple of feature map and bbox prediction. + + - output_memory (Tensor): The input of decoder, \ + has shape (bs, num_key, embed_dim). num_key is \ + equal the number of points on feature map from \ + all levels. + - output_proposals (Tensor): The normalized proposal \ + after a inverse sigmoid, has shape \ + (bs, num_keys, 4). + """ + + N, S, C = memory.shape + proposals = [] + _cur = 0 + for lvl, (H, W) in enumerate(spatial_shapes): + mask_flatten_ = memory_padding_mask[:, _cur : (_cur + H * W)].view(N, H, W, 1) + valid_H = torch.sum(~mask_flatten_[:, :, 0, 0], 1) + valid_W = torch.sum(~mask_flatten_[:, 0, :, 0], 1) + + grid_y, grid_x = torch.meshgrid( + torch.linspace(0, H - 1, H, dtype=torch.float32, device=memory.device), + torch.linspace(0, W - 1, W, dtype=torch.float32, device=memory.device), + ) + grid = torch.cat([grid_x.unsqueeze(-1), grid_y.unsqueeze(-1)], -1) + + scale = torch.cat([valid_W.unsqueeze(-1), valid_H.unsqueeze(-1)], 1).view(N, 1, 1, 2) + grid = (grid.unsqueeze(0).expand(N, -1, -1, -1) + 0.5) / scale + wh = torch.ones_like(grid) * 0.05 * (2.0**lvl) + proposal = torch.cat((grid, wh), -1).view(N, -1, 4) + proposals.append(proposal) + _cur += H * W + output_proposals = torch.cat(proposals, 1) + output_proposals_valid = ((output_proposals > 0.01) & (output_proposals < 0.99)).all(-1, keepdim=True) + output_proposals = torch.log(output_proposals / (1 - output_proposals)) + output_proposals = output_proposals.masked_fill(memory_padding_mask.unsqueeze(-1), float("inf")) + output_proposals = output_proposals.masked_fill(~output_proposals_valid, float("inf")) + + output_memory = memory + output_memory = output_memory.masked_fill(memory_padding_mask.unsqueeze(-1), float(0)) + output_memory = output_memory.masked_fill(~output_proposals_valid, float(0)) + output_memory = self.enc_output_norm(self.enc_output(output_memory)) + return output_memory, output_proposals + + @staticmethod + def get_reference_points(spatial_shapes, valid_ratios, device): + """Get the reference points used in decoder. + + Args: + spatial_shapes (Tensor): The shape of all + feature maps, has shape (num_level, 2). + valid_ratios (Tensor): The radios of valid + points on the feature map, has shape + (bs, num_levels, 2) + device (obj:`device`): The device where + reference_points should be. + + Returns: + Tensor: reference points used in decoder, has \ + shape (bs, num_keys, num_levels, 2). + """ + reference_points_list = [] + for lvl, (H, W) in enumerate(spatial_shapes): + ref_y, ref_x = torch.meshgrid( + torch.linspace(0.5, H - 0.5, H, dtype=torch.float32, device=device), + torch.linspace(0.5, W - 0.5, W, dtype=torch.float32, device=device), + ) + ref_y = ref_y.reshape(-1)[None] / (valid_ratios[:, None, lvl, 1] * H) + ref_x = ref_x.reshape(-1)[None] / (valid_ratios[:, None, lvl, 0] * W) + ref = torch.stack((ref_x, ref_y), -1) + reference_points_list.append(ref) + reference_points = torch.cat(reference_points_list, 1) + reference_points = reference_points[:, :, None] * valid_ratios[:, None] + return reference_points + + def get_valid_ratio(self, mask): + """Get the valid radios of feature maps of all level.""" + _, H, W = mask.shape + valid_H = torch.sum(~mask[:, :, 0], 1) + valid_W = torch.sum(~mask[:, 0, :], 1) + valid_ratio_h = valid_H.float() / H + valid_ratio_w = valid_W.float() / W + valid_ratio = torch.stack([valid_ratio_w, valid_ratio_h], -1) + return valid_ratio + + def get_proposal_pos_embed(self, proposals, num_pos_feats=128, temperature=10000): + """Get the position embedding of proposal.""" + scale = 2 * math.pi + dim_t = torch.arange(num_pos_feats, dtype=torch.float32, device=proposals.device) + dim_t = temperature ** (2 * (dim_t // 2) / num_pos_feats) + # N, L, 4 + proposals = proposals.sigmoid() * scale + # N, L, 4, 128 + pos = proposals[:, :, :, None] / dim_t + # N, L, 4, 64, 2 + pos = torch.stack((pos[:, :, :, 0::2].sin(), pos[:, :, :, 1::2].cos()), dim=4).flatten(2) + return pos + + def forward( + self, mlvl_feats, mlvl_masks, query_embed, mlvl_pos_embeds, reg_branches=None, cls_branches=None, **kwargs + ): + """Forward function for `Transformer`. + + Args: + mlvl_feats (list(Tensor)): Input queries from + different level. Each element has shape + [bs, embed_dims, h, w]. + mlvl_masks (list(Tensor)): The key_padding_mask from + different level used for encoder and decoder, + each element has shape [bs, h, w]. + query_embed (Tensor): The query embedding for decoder, + with shape [num_query, c]. + mlvl_pos_embeds (list(Tensor)): The positional encoding + of feats from different level, has the shape + [bs, embed_dims, h, w]. + reg_branches (obj:`nn.ModuleList`): Regression heads for + feature maps from each decoder layer. Only would + be passed when + `with_box_refine` is True. Default to None. + cls_branches (obj:`nn.ModuleList`): Classification heads + for feature maps from each decoder layer. Only would + be passed when `as_two_stage` + is True. Default to None. + + + Returns: + tuple[Tensor]: results of decoder containing the following tensor. + + - inter_states: Outputs from decoder. If + return_intermediate_dec is True output has shape \ + (num_dec_layers, bs, num_query, embed_dims), else has \ + shape (1, bs, num_query, embed_dims). + - init_reference_out: The initial value of reference \ + points, has shape (bs, num_queries, 4). + - inter_references_out: The internal value of reference \ + points in decoder, has shape \ + (num_dec_layers, bs,num_query, embed_dims) + - enc_outputs_class: The classification score of \ + proposals generated from \ + encoder's feature maps, has shape \ + (batch, h*w, num_classes). \ + Only would be returned when `as_two_stage` is True, \ + otherwise None. + - enc_outputs_coord_unact: The regression results \ + generated from encoder's feature maps., has shape \ + (batch, h*w, 4). Only would \ + be returned when `as_two_stage` is True, \ + otherwise None. + """ + assert self.as_two_stage or query_embed is not None + + feat_flatten = [] + mask_flatten = [] + lvl_pos_embed_flatten = [] + spatial_shapes = [] + for lvl, (feat, mask, pos_embed) in enumerate(zip(mlvl_feats, mlvl_masks, mlvl_pos_embeds)): + bs, c, h, w = feat.shape + spatial_shape = (h, w) + spatial_shapes.append(spatial_shape) + feat = feat.flatten(2).transpose(1, 2) + mask = mask.flatten(1) + pos_embed = pos_embed.flatten(2).transpose(1, 2) + lvl_pos_embed = pos_embed + self.level_embeds[lvl].view(1, 1, -1) + lvl_pos_embed_flatten.append(lvl_pos_embed) + feat_flatten.append(feat) + mask_flatten.append(mask) + feat_flatten = torch.cat(feat_flatten, 1) + mask_flatten = torch.cat(mask_flatten, 1) + lvl_pos_embed_flatten = torch.cat(lvl_pos_embed_flatten, 1) + spatial_shapes = torch.as_tensor(spatial_shapes, dtype=torch.long, device=feat_flatten.device) + level_start_index = torch.cat((spatial_shapes.new_zeros((1,)), spatial_shapes.prod(1).cumsum(0)[:-1])) + valid_ratios = torch.stack([self.get_valid_ratio(m) for m in mlvl_masks], 1) + + reference_points = self.get_reference_points(spatial_shapes, valid_ratios, device=feat.device) + + feat_flatten = feat_flatten.permute(1, 0, 2) # (H*W, bs, embed_dims) + lvl_pos_embed_flatten = lvl_pos_embed_flatten.permute(1, 0, 2) # (H*W, bs, embed_dims) + memory = self.encoder( + query=feat_flatten, + key=None, + value=None, + query_pos=lvl_pos_embed_flatten, + query_key_padding_mask=mask_flatten, + spatial_shapes=spatial_shapes, + reference_points=reference_points, + level_start_index=level_start_index, + valid_ratios=valid_ratios, + **kwargs, + ) + + memory = memory.permute(1, 0, 2) + bs, _, c = memory.shape + if self.as_two_stage: + output_memory, output_proposals = self.gen_encoder_output_proposals(memory, mask_flatten, spatial_shapes) + enc_outputs_class = cls_branches[self.decoder.num_layers](output_memory) + enc_outputs_coord_unact = reg_branches[self.decoder.num_layers](output_memory) + output_proposals + + topk = self.two_stage_num_proposals + topk_proposals = torch.topk(enc_outputs_class[..., 0], topk, dim=1)[1] + topk_coords_unact = torch.gather(enc_outputs_coord_unact, 1, topk_proposals.unsqueeze(-1).repeat(1, 1, 4)) + topk_coords_unact = topk_coords_unact.detach() + reference_points = topk_coords_unact.sigmoid() + init_reference_out = reference_points + pos_trans_out = self.pos_trans_norm(self.pos_trans(self.get_proposal_pos_embed(topk_coords_unact))) + query_pos, query = torch.split(pos_trans_out, c, dim=2) + else: + query_pos, query = torch.split(query_embed, c, dim=1) + query_pos = query_pos.unsqueeze(0).expand(bs, -1, -1) + query = query.unsqueeze(0).expand(bs, -1, -1) + reference_points = self.reference_points(query_pos).sigmoid() + init_reference_out = reference_points + + # decoder + query = query.permute(1, 0, 2) + memory = memory.permute(1, 0, 2) + query_pos = query_pos.permute(1, 0, 2) + inter_states, inter_references = self.decoder( + query=query, + key=None, + value=memory, + query_pos=query_pos, + key_padding_mask=mask_flatten, + reference_points=reference_points, + spatial_shapes=spatial_shapes, + level_start_index=level_start_index, + valid_ratios=valid_ratios, + reg_branches=reg_branches, + **kwargs, + ) + + inter_references_out = inter_references + if self.as_two_stage: + return inter_states, init_reference_out, inter_references_out, enc_outputs_class, enc_outputs_coord_unact + return inter_states, init_reference_out, inter_references_out, None, None + + +@TRANSFORMER.register_module() +class DynamicConv(BaseModule): + """Implements Dynamic Convolution. + + This module generate parameters for each sample and + use bmm to implement 1*1 convolution. Code is modified + from the `official github repo `_ . + + Args: + in_channels (int): The input feature channel. + Defaults to 256. + feat_channels (int): The inner feature channel. + Defaults to 64. + out_channels (int, optional): The output feature channel. + When not specified, it will be set to `in_channels` + by default + input_feat_shape (int): The shape of input feature. + Defaults to 7. + with_proj (bool): Project two-dimentional feature to + one-dimentional feature. Default to True. + act_cfg (dict): The activation config for DynamicConv. + norm_cfg (dict): Config dict for normalization layer. Default + layer normalization. + init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization. + Default: None. + """ + + def __init__( + self, + in_channels=256, + feat_channels=64, + out_channels=None, + input_feat_shape=7, + with_proj=True, + act_cfg=dict(type="ReLU", inplace=True), + norm_cfg=dict(type="LN"), + init_cfg=None, + ): + super(DynamicConv, self).__init__(init_cfg) + self.in_channels = in_channels + self.feat_channels = feat_channels + self.out_channels_raw = out_channels + self.input_feat_shape = input_feat_shape + self.with_proj = with_proj + self.act_cfg = act_cfg + self.norm_cfg = norm_cfg + self.out_channels = out_channels if out_channels else in_channels + + self.num_params_in = self.in_channels * self.feat_channels + self.num_params_out = self.out_channels * self.feat_channels + self.dynamic_layer = nn.Linear(self.in_channels, self.num_params_in + self.num_params_out) + + self.norm_in = build_norm_layer(norm_cfg, self.feat_channels)[1] + self.norm_out = build_norm_layer(norm_cfg, self.out_channels)[1] + + self.activation = build_activation_layer(act_cfg) + + num_output = self.out_channels * input_feat_shape**2 + if self.with_proj: + self.fc_layer = nn.Linear(num_output, self.out_channels) + self.fc_norm = build_norm_layer(norm_cfg, self.out_channels)[1] + + def forward(self, param_feature, input_feature): + """Forward function for `DynamicConv`. + + Args: + param_feature (Tensor): The feature can be used + to generate the parameter, has shape + (num_all_proposals, in_channels). + input_feature (Tensor): Feature that + interact with parameters, has shape + (num_all_proposals, in_channels, H, W). + + Returns: + Tensor: The output feature has shape + (num_all_proposals, out_channels). + """ + input_feature = input_feature.flatten(2).permute(2, 0, 1) + + input_feature = input_feature.permute(1, 0, 2) + parameters = self.dynamic_layer(param_feature) + + param_in = parameters[:, : self.num_params_in].view(-1, self.in_channels, self.feat_channels) + param_out = parameters[:, -self.num_params_out :].view(-1, self.feat_channels, self.out_channels) + + # input_feature has shape (num_all_proposals, H*W, in_channels) + # param_in has shape (num_all_proposals, in_channels, feat_channels) + # feature has shape (num_all_proposals, H*W, feat_channels) + features = torch.bmm(input_feature, param_in) + features = self.norm_in(features) + features = self.activation(features) + + # param_out has shape (batch_size, feat_channels, out_channels) + features = torch.bmm(features, param_out) + features = self.norm_out(features) + features = self.activation(features) + + if self.with_proj: + features = features.flatten(1) + features = self.fc_layer(features) + features = self.fc_norm(features) + features = self.activation(features) + + return features diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/ops/modules/__init__.py b/OpenMidnight/dinov2/eval/segmentation_m2f/ops/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..49aa8fe612fd4c088e294707c5ee16bd1cb5b5e7 --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/ops/modules/__init__.py @@ -0,0 +1,10 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/fundamentalvision/Deformable-DETR/tree/main/models/ops/modules +# https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0 + +from .ms_deform_attn import MSDeformAttn diff --git a/OpenMidnight/dinov2/eval/segmentation_m2f/ops/modules/ms_deform_attn.py b/OpenMidnight/dinov2/eval/segmentation_m2f/ops/modules/ms_deform_attn.py new file mode 100644 index 0000000000000000000000000000000000000000..d8b4fa23712e87d1a2682b57e71ee37fe8524cff --- /dev/null +++ b/OpenMidnight/dinov2/eval/segmentation_m2f/ops/modules/ms_deform_attn.py @@ -0,0 +1,185 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import math +import warnings + +import torch +import torch.nn.functional as F +from torch import nn +from torch.autograd import Function +from torch.cuda.amp import custom_fwd +from torch.nn.init import constant_, xavier_uniform_ + + +class MSDeformAttnFunction(Function): + @staticmethod + @custom_fwd(cast_inputs=torch.float32) + def forward( + ctx, value, value_spatial_shapes, value_level_start_index, sampling_locations, attention_weights, im2col_step + ): + output = ms_deform_attn_core_pytorch( + value, + value_spatial_shapes, + # value_level_start_index, + sampling_locations, + attention_weights, + ) + return output + + +def ms_deform_attn_core_pytorch(value, value_spatial_shapes, sampling_locations, attention_weights): + # for debug and test only, + # need to use cuda version instead + N_, S_, M_, D_ = value.shape + _, Lq_, M_, L_, P_, _ = sampling_locations.shape + value_list = value.split([H_ * W_ for H_, W_ in value_spatial_shapes], dim=1) + sampling_grids = 2 * sampling_locations - 1 + sampling_value_list = [] + for lid_, (H_, W_) in enumerate(value_spatial_shapes): + # N_, H_*W_, M_, D_ -> N_, H_*W_, M_*D_ -> N_, M_*D_, H_*W_ -> N_*M_, D_, H_, W_ + value_l_ = value_list[lid_].flatten(2).transpose(1, 2).reshape(N_ * M_, D_, H_, W_) + # N_, Lq_, M_, P_, 2 -> N_, M_, Lq_, P_, 2 -> N_*M_, Lq_, P_, 2 + sampling_grid_l_ = sampling_grids[:, :, :, lid_].transpose(1, 2).flatten(0, 1) + # N_*M_, D_, Lq_, P_ + sampling_value_l_ = F.grid_sample( + value_l_, sampling_grid_l_, mode="bilinear", padding_mode="zeros", align_corners=False + ) + sampling_value_list.append(sampling_value_l_) + # (N_, Lq_, M_, L_, P_) -> (N_, M_, Lq_, L_, P_) -> (N_, M_, 1, Lq_, L_*P_) + attention_weights = attention_weights.transpose(1, 2).reshape(N_ * M_, 1, Lq_, L_ * P_) + output = (torch.stack(sampling_value_list, dim=-2).flatten(-2) * attention_weights).sum(-1).view(N_, M_ * D_, Lq_) + return output.transpose(1, 2).contiguous() + + +def _is_power_of_2(n): + if (not isinstance(n, int)) or (n < 0): + raise ValueError("invalid input for _is_power_of_2: {} (type: {})".format(n, type(n))) + return (n & (n - 1) == 0) and n != 0 + + +class MSDeformAttn(nn.Module): + def __init__(self, d_model=256, n_levels=4, n_heads=8, n_points=4, ratio=1.0): + """Multi-Scale Deformable Attention Module. + + :param d_model hidden dimension + :param n_levels number of feature levels + :param n_heads number of attention heads + :param n_points number of sampling points per attention head per feature level + """ + super().__init__() + if d_model % n_heads != 0: + raise ValueError("d_model must be divisible by n_heads, " "but got {} and {}".format(d_model, n_heads)) + _d_per_head = d_model // n_heads + # you'd better set _d_per_head to a power of 2 + # which is more efficient in our CUDA implementation + if not _is_power_of_2(_d_per_head): + warnings.warn( + "You'd better set d_model in MSDeformAttn to make " + "the dimension of each attention head a power of 2 " + "which is more efficient in our CUDA implementation." + ) + + self.im2col_step = 64 + + self.d_model = d_model + self.n_levels = n_levels + self.n_heads = n_heads + self.n_points = n_points + self.ratio = ratio + self.sampling_offsets = nn.Linear(d_model, n_heads * n_levels * n_points * 2) + self.attention_weights = nn.Linear(d_model, n_heads * n_levels * n_points) + self.value_proj = nn.Linear(d_model, int(d_model * ratio)) + self.output_proj = nn.Linear(int(d_model * ratio), d_model) + + self._reset_parameters() + + def _reset_parameters(self): + constant_(self.sampling_offsets.weight.data, 0.0) + thetas = torch.arange(self.n_heads, dtype=torch.float32) * (2.0 * math.pi / self.n_heads) + grid_init = torch.stack([thetas.cos(), thetas.sin()], -1) + grid_init = ( + (grid_init / grid_init.abs().max(-1, keepdim=True)[0]) + .view(self.n_heads, 1, 1, 2) + .repeat(1, self.n_levels, self.n_points, 1) + ) + for i in range(self.n_points): + grid_init[:, :, i, :] *= i + 1 + + with torch.no_grad(): + self.sampling_offsets.bias = nn.Parameter(grid_init.view(-1)) + constant_(self.attention_weights.weight.data, 0.0) + constant_(self.attention_weights.bias.data, 0.0) + xavier_uniform_(self.value_proj.weight.data) + constant_(self.value_proj.bias.data, 0.0) + xavier_uniform_(self.output_proj.weight.data) + constant_(self.output_proj.bias.data, 0.0) + + def forward( + self, + query, + reference_points, + input_flatten, + input_spatial_shapes, + input_level_start_index, + input_padding_mask=None, + ): + """ + :param query (N, Length_{query}, C) + :param reference_points (N, Length_{query}, n_levels, 2), range in [0, 1], top-left (0,0), bottom-right (1, 1), including padding area + or (N, Length_{query}, n_levels, 4), add additional (w, h) to form reference boxes + :param input_flatten (N, \\sum_{l=0}^{L-1} H_l \\cdot W_l, C) + :param input_spatial_shapes (n_levels, 2), [(H_0, W_0), (H_1, W_1), ..., (H_{L-1}, W_{L-1})] + :param input_level_start_index (n_levels, ), [0, H_0*W_0, H_0*W_0+H_1*W_1, H_0*W_0+H_1*W_1+H_2*W_2, ..., H_0*W_0+H_1*W_1+...+H_{L-1}*W_{L-1}] + :param input_padding_mask (N, \\sum_{l=0}^{L-1} H_l \\cdot W_l), True for padding elements, False for non-padding elements + + :return output (N, Length_{query}, C) + """ + # print(query.shape) + # print(reference_points.shape) + # print(input_flatten.shape) + # print(input_spatial_shapes.shape) + # print(input_level_start_index.shape) + # print(input_spatial_shapes) + # print(input_level_start_index) + + N, Len_q, _ = query.shape + N, Len_in, _ = input_flatten.shape + assert (input_spatial_shapes[:, 0] * input_spatial_shapes[:, 1]).sum() == Len_in + + value = self.value_proj(input_flatten) + if input_padding_mask is not None: + value = value.masked_fill(input_padding_mask[..., None], float(0)) + + value = value.view(N, Len_in, self.n_heads, int(self.ratio * self.d_model) // self.n_heads) + sampling_offsets = self.sampling_offsets(query).view(N, Len_q, self.n_heads, self.n_levels, self.n_points, 2) + attention_weights = self.attention_weights(query).view(N, Len_q, self.n_heads, self.n_levels * self.n_points) + attention_weights = F.softmax(attention_weights, -1).view(N, Len_q, self.n_heads, self.n_levels, self.n_points) + + if reference_points.shape[-1] == 2: + offset_normalizer = torch.stack([input_spatial_shapes[..., 1], input_spatial_shapes[..., 0]], -1) + sampling_locations = ( + reference_points[:, :, None, :, None, :] + + sampling_offsets / offset_normalizer[None, None, None, :, None, :] + ) + elif reference_points.shape[-1] == 4: + sampling_locations = ( + reference_points[:, :, None, :, None, :2] + + sampling_offsets / self.n_points * reference_points[:, :, None, :, None, 2:] * 0.5 + ) + else: + raise ValueError( + "Last dim of reference_points must be 2 or 4, but get {} instead.".format(reference_points.shape[-1]) + ) + output = MSDeformAttnFunction.apply( + value, + input_spatial_shapes, + input_level_start_index, + sampling_locations, + attention_weights, + self.im2col_step, + ) + output = self.output_proj(output) + return output diff --git a/OpenMidnight/dinov2/eval/setup.py b/OpenMidnight/dinov2/eval/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..959128c0673cc51036dbf17dcc4ee68a037988fb --- /dev/null +++ b/OpenMidnight/dinov2/eval/setup.py @@ -0,0 +1,75 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import argparse +from typing import Any, List, Optional, Tuple + +import torch +import torch.backends.cudnn as cudnn + +from dinov2.models import build_model_from_cfg +from dinov2.utils.config import setup +import dinov2.utils.utils as dinov2_utils + + +def get_args_parser( + description: Optional[str] = None, + parents: Optional[List[argparse.ArgumentParser]] = None, + add_help: bool = True, +): + parser = argparse.ArgumentParser( + description=description, + parents=parents or [], + add_help=add_help, + ) + parser.add_argument( + "--config-file", + type=str, + help="Model configuration file", + ) + parser.add_argument( + "--pretrained-weights", + type=str, + help="Pretrained model weights", + ) + parser.add_argument( + "--output-dir", + default="", + type=str, + help="Output directory to write results and logs", + ) + parser.add_argument( + "--opts", + help="Extra configuration options", + default=[], + nargs="+", + ) + return parser + + +def get_autocast_dtype(config): + teacher_dtype_str = config.compute_precision.teacher.backbone.mixed_precision.param_dtype + if teacher_dtype_str == "fp16": + return torch.half + elif teacher_dtype_str == "bf16": + return torch.bfloat16 + else: + return torch.float + + +def build_model_for_eval(config, pretrained_weights): + model, _ = build_model_from_cfg(config, only_teacher=True) + dinov2_utils.load_pretrained_weights(model, pretrained_weights, "teacher") + model.eval() + model.cuda() + return model + + +def setup_and_build_model(args) -> Tuple[Any, torch.dtype]: + cudnn.benchmark = True + config = setup(args) + model = build_model_for_eval(config, args.pretrained_weights) + autocast_dtype = get_autocast_dtype(config) + return model, autocast_dtype diff --git a/OpenMidnight/dinov2/eval/utils.py b/OpenMidnight/dinov2/eval/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..c50576b1940587ee64b7a422e2e96b475d60fd39 --- /dev/null +++ b/OpenMidnight/dinov2/eval/utils.py @@ -0,0 +1,146 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +from typing import Dict, Optional + +import torch +from torch import nn +from torchmetrics import MetricCollection + +from dinov2.data import DatasetWithEnumeratedTargets, SamplerType, make_data_loader +import dinov2.distributed as distributed +from dinov2.logging import MetricLogger + + +logger = logging.getLogger("dinov2") + + +class ModelWithNormalize(torch.nn.Module): + def __init__(self, model): + super().__init__() + self.model = model + + def forward(self, samples): + return nn.functional.normalize(self.model(samples), dim=1, p=2) + + +class ModelWithIntermediateLayers(nn.Module): + def __init__(self, feature_model, n_last_blocks, autocast_ctx): + super().__init__() + self.feature_model = feature_model + self.feature_model.eval() + self.n_last_blocks = n_last_blocks + self.autocast_ctx = autocast_ctx + + def forward(self, images): + with torch.inference_mode(): + with self.autocast_ctx(): + features = self.feature_model.get_intermediate_layers( + images, self.n_last_blocks, return_class_token=True + ) + return features + + +@torch.inference_mode() +def evaluate( + model: nn.Module, + data_loader, + postprocessors: Dict[str, nn.Module], + metrics: Dict[str, MetricCollection], + device: torch.device, + criterion: Optional[nn.Module] = None, +): + model.eval() + if criterion is not None: + criterion.eval() + + for metric in metrics.values(): + metric = metric.to(device) + + metric_logger = MetricLogger(delimiter=" ") + header = "Test:" + + for samples, targets, *_ in metric_logger.log_every(data_loader, 10, header): + outputs = model(samples.to(device)) + targets = targets.to(device) + + if criterion is not None: + loss = criterion(outputs, targets) + metric_logger.update(loss=loss.item()) + + for k, metric in metrics.items(): + metric_inputs = postprocessors[k](outputs, targets) + metric.update(**metric_inputs) + + metric_logger.synchronize_between_processes() + logger.info(f"Averaged stats: {metric_logger}") + + stats = {k: metric.compute() for k, metric in metrics.items()} + metric_logger_stats = {k: meter.global_avg for k, meter in metric_logger.meters.items()} + return metric_logger_stats, stats + + +def all_gather_and_flatten(tensor_rank): + tensor_all_ranks = torch.empty( + distributed.get_global_size(), + *tensor_rank.shape, + dtype=tensor_rank.dtype, + device=tensor_rank.device, + ) + tensor_list = list(tensor_all_ranks.unbind(0)) + torch.distributed.all_gather(tensor_list, tensor_rank.contiguous()) + return tensor_all_ranks.flatten(end_dim=1) + + +def extract_features(model, dataset, batch_size, num_workers, gather_on_cpu=False): + dataset_with_enumerated_targets = DatasetWithEnumeratedTargets(dataset) + sample_count = len(dataset_with_enumerated_targets) + data_loader = make_data_loader( + dataset=dataset_with_enumerated_targets, + batch_size=batch_size, + num_workers=num_workers, + sampler_type=SamplerType.DISTRIBUTED, + drop_last=False, + shuffle=False, + ) + return extract_features_with_dataloader(model, data_loader, sample_count, gather_on_cpu) + + +@torch.inference_mode() +def extract_features_with_dataloader(model, data_loader, sample_count, gather_on_cpu=False): + gather_device = torch.device("cpu") if gather_on_cpu else torch.device("cuda") + metric_logger = MetricLogger(delimiter=" ") + features, all_labels = None, None + for samples, (index, labels_rank) in metric_logger.log_every(data_loader, 10): + samples = samples.cuda(non_blocking=True) + labels_rank = labels_rank.cuda(non_blocking=True) + index = index.cuda(non_blocking=True) + features_rank = model(samples).float() + + # init storage feature matrix + if features is None: + features = torch.zeros(sample_count, features_rank.shape[-1], device=gather_device) + labels_shape = list(labels_rank.shape) + labels_shape[0] = sample_count + all_labels = torch.full(labels_shape, fill_value=-1, device=gather_device) + logger.info(f"Storing features into tensor of shape {features.shape}") + + # share indexes, features and labels between processes + index_all = all_gather_and_flatten(index).to(gather_device) + features_all_ranks = all_gather_and_flatten(features_rank).to(gather_device) + labels_all_ranks = all_gather_and_flatten(labels_rank).to(gather_device) + + # update storage feature matrix + if len(index_all) > 0: + features.index_copy_(0, index_all, features_all_ranks) + all_labels.index_copy_(0, index_all, labels_all_ranks) + + logger.info(f"Features shape: {tuple(features.shape)}") + logger.info(f"Labels shape: {tuple(all_labels.shape)}") + + assert torch.all(all_labels > -1) + + return features, all_labels diff --git a/OpenMidnight/dinov2/eval_config.yaml b/OpenMidnight/dinov2/eval_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c94649465f9c13763b1c5b08c383f9a4e527cab4 --- /dev/null +++ b/OpenMidnight/dinov2/eval_config.yaml @@ -0,0 +1,115 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 5} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, dino_vits16}/offline/bach} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 12500} + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/MulticlassAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 1250} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationEmbeddingsWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings}/${oc.env:MODEL_NAME, dino_vits16}/bach + dataloader_idx_map: + 0: train + 1: val + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 #facebookresearch/dino:main + model: dinov2_vits14_reg #dino_vits16 + pretrained: false + checkpoint_path: ./output_pretrained_on/eval/training_225000/teacher_checkpoint.pth + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: torch.nn.Linear + init_args: + in_features: ${oc.env:IN_FEATURES, 384} + out_features: &NUM_CLASSES 4 + criterion: torch.nn.CrossEntropyLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.0003} + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.MulticlassClassificationMetrics + init_args: + num_classes: *NUM_CLASSES +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.EmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + val: + class_path: eva.datasets.EmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: val + predict: + - class_path: eva.vision.datasets.BACH + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, ./data/bach} + split: train + download: ${oc.env:DOWNLOAD_DATA, false} + # Set `download: true` to download the dataset from https://zenodo.org/records/3632035 + # The BACH dataset is distributed under the following license + # Attribution-NonCommercial-NoDerivs 4.0 International license + # (see: https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode) + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} #Flagged for maybe needs fixing + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.BACH + init_args: + <<: *PREDICT_DATASET_ARGS + split: val + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 256} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS diff --git a/OpenMidnight/dinov2/eval_dinov3.yaml b/OpenMidnight/dinov2/eval_dinov3.yaml new file mode 100644 index 0000000000000000000000000000000000000000..910f91b9c5bc31cc39d0e5dbad29f6c32ee096b6 --- /dev/null +++ b/OpenMidnight/dinov2/eval_dinov3.yaml @@ -0,0 +1,117 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 5} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, dino_vits16}/offline/bach} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 6000} #usually 12500 + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/MulticlassAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 1250} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationEmbeddingsWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings}/${oc.env:MODEL_NAME, dino_vits16}/bach + dataloader_idx_map: + 0: train + 1: val + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 + model: dinov2_vitg14_reg #dino_vits16 + pretrained: true + #checkpoint_path: ./dinov3_vits16_pretrain_lvd1689m-08c60483.pth + #checkpoint_path: ./old/output_pretrained_on/eval/training_12500/teacher_checkpoint.pth + + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: torch.nn.Linear + init_args: + in_features: ${oc.env:IN_FEATURES, 257280} #MODIFY ME + out_features: &NUM_CLASSES 4 + criterion: torch.nn.CrossEntropyLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.0001} + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.MulticlassClassificationMetrics + init_args: + num_classes: *NUM_CLASSES +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.EmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + val: + class_path: eva.datasets.EmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: val + predict: + - class_path: eva.vision.datasets.BACH + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, ./data/bach} + split: train + download: ${oc.env:DOWNLOAD_DATA, false} + # Set `download: true` to download the dataset from https://zenodo.org/records/3632035 + # The BACH dataset is distributed under the following license + # Attribution-NonCommercial-NoDerivs 4.0 International license + # (see: https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode) + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} #Flagged for maybe needs fixing + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.BACH + init_args: + <<: *PREDICT_DATASET_ARGS + split: val + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 256} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS diff --git a/OpenMidnight/dinov2/eval_dinov3_custom.yaml b/OpenMidnight/dinov2/eval_dinov3_custom.yaml new file mode 100644 index 0000000000000000000000000000000000000000..6feebf5720448a468984c5121d782f348de54047 --- /dev/null +++ b/OpenMidnight/dinov2/eval_dinov3_custom.yaml @@ -0,0 +1,117 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 5} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, dino_vits16}/offline/bach} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 6000} #usually 12500 + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/MulticlassAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 1250} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationEmbeddingsWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings}/${oc.env:MODEL_NAME, dino_vits16}/bach + dataloader_idx_map: + 0: train + 1: val + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 + model: dinov2_vitg14_reg #dino_vits16 + pretrained: true + #checkpoint_path: ./dinov3_vits16_pretrain_lvd1689m-08c60483.pth + #checkpoint_path: ./old/output_pretrained_on/eval/training_12500/teacher_checkpoint.pth + + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: pathologyDino.batch_linear.batch_linear + init_args: + in_features: ${oc.env:IN_FEATURES, 257280} #MODIFY ME + out_features: &NUM_CLASSES 4 + criterion: torch.nn.CrossEntropyLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.0001} + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.MulticlassClassificationMetrics + init_args: + num_classes: *NUM_CLASSES +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.EmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + val: + class_path: eva.datasets.EmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: val + predict: + - class_path: eva.vision.datasets.BACH + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, ./data/bach} + split: train + download: ${oc.env:DOWNLOAD_DATA, false} + # Set `download: true` to download the dataset from https://zenodo.org/records/3632035 + # The BACH dataset is distributed under the following license + # Attribution-NonCommercial-NoDerivs 4.0 International license + # (see: https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode) + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} #Flagged for maybe needs fixing + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.BACH + init_args: + <<: *PREDICT_DATASET_ARGS + split: val + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 256} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS diff --git a/OpenMidnight/dinov2/fsdp/__init__.py b/OpenMidnight/dinov2/fsdp/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ec25c75764a85c1cb2e3e3fd92e9a1e494855029 --- /dev/null +++ b/OpenMidnight/dinov2/fsdp/__init__.py @@ -0,0 +1,156 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import os +from typing import Any + +import torch +import dinov2.distributed as distributed +from functools import partial +from fvcore.common.checkpoint import Checkpointer +from torch.distributed.fsdp import FullyShardedDataParallel as FSDP +from torch.distributed.fsdp import ShardingStrategy +from torch.distributed.fsdp import MixedPrecision +from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler +from torch.distributed.fsdp.wrap import ModuleWrapPolicy +from torch.distributed.fsdp._runtime_utils import _reshard + + +def get_fsdp_wrapper(model_cfg, modules_to_wrap=set()): + sharding_strategy_dict = { + "NO_SHARD": ShardingStrategy.NO_SHARD, + "SHARD_GRAD_OP": ShardingStrategy.SHARD_GRAD_OP, + "FULL_SHARD": ShardingStrategy.FULL_SHARD, + } + + dtype_dict = { + "fp32": torch.float32, + "fp16": torch.float16, + "bf16": torch.bfloat16, + } + + mixed_precision_config = MixedPrecision( + param_dtype=dtype_dict[model_cfg.mixed_precision.param_dtype], + reduce_dtype=dtype_dict[model_cfg.mixed_precision.reduce_dtype], + buffer_dtype=dtype_dict[model_cfg.mixed_precision.buffer_dtype], + ) + + sharding_strategy_config = sharding_strategy_dict[model_cfg.sharding_strategy] + + local_rank = distributed.get_local_rank() + + fsdp_wrapper = partial( + FSDP, + sharding_strategy=sharding_strategy_config, + mixed_precision=mixed_precision_config, + device_id=local_rank, + sync_module_states=True, + use_orig_params=True, + auto_wrap_policy=ModuleWrapPolicy(modules_to_wrap), + ) + return fsdp_wrapper + + +def is_fsdp(x): + return isinstance(x, FSDP) + + +def is_sharded_fsdp(x): + return is_fsdp(x) and x.sharding_strategy is not ShardingStrategy.NO_SHARD + + +def free_if_fsdp(x): + if is_sharded_fsdp(x): + handle = x._handle + _reshard(x, handle, True) + + +def get_fsdp_modules(x): + return FSDP.fsdp_modules(x) + + +def reshard_fsdp_model(x): + for m in get_fsdp_modules(x): + free_if_fsdp(m) + + +def rankstr(): + return f"rank_{distributed.get_global_rank()}" + + +class FSDPCheckpointer(Checkpointer): + def _load_file(self, f: str): + return torch.load(f, map_location=torch.device("cpu"), weights_only=False) + + def save(self, name: str, **kwargs: Any) -> None: + """ + Dump model and checkpointables to a file. + + Args: + name (str): name of the file. + kwargs (dict): extra arbitrary data to save. + """ + if not self.save_dir or not self.save_to_disk: + return + + data = {} + data["model"] = self.model.state_dict() + + # data["model"] = self.model.state_dict() + for key, obj in self.checkpointables.items(): + data[key] = obj.state_dict() + data.update(kwargs) + + basename = f"{name}.{rankstr()}.pth" + save_file = os.path.join(self.save_dir, basename) + assert os.path.basename(save_file) == basename, basename + self.logger.info("Saving checkpoint to {}".format(save_file)) + with self.path_manager.open(save_file, "wb") as f: + torch.save(data, f) + self.tag_last_checkpoint(basename) + + def load(self, *args, **kwargs): + return super().load(*args, **kwargs) + + def has_checkpoint(self) -> bool: + """ + Returns: + bool: whether a checkpoint exists in the target directory. + """ + save_file = os.path.join(self.save_dir, f"last_checkpoint.{rankstr()}") + return self.path_manager.exists(save_file) + + def get_checkpoint_file(self) -> str: + """ + Returns: + str: The latest checkpoint file in target directory. + """ + save_file = os.path.join(self.save_dir, f"last_checkpoint.{rankstr()}") + try: + with self.path_manager.open(save_file, "r") as f: + last_saved = f.read().strip() + except IOError: + # if file doesn't exist, maybe because it has just been + # deleted by a separate process + return "" + # pyre-fixme[6]: For 2nd param expected `Union[PathLike[str], str]` but got + # `Union[bytes, str]`. + return os.path.join(self.save_dir, last_saved) + + def tag_last_checkpoint(self, last_filename_basename: str) -> None: + """ + Tag the last checkpoint. + + Args: + last_filename_basename (str): the basename of the last filename. + """ + if distributed.is_enabled(): + torch.distributed.barrier() + save_file = os.path.join(self.save_dir, f"last_checkpoint.{rankstr()}") + with self.path_manager.open(save_file, "w") as f: + f.write(last_filename_basename) # pyre-ignore + + +ShardedGradScaler = ShardedGradScaler diff --git a/OpenMidnight/dinov2/hub/__init__.py b/OpenMidnight/dinov2/hub/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b88da6bf80be92af00b72dfdb0a806fa64a7a2d9 --- /dev/null +++ b/OpenMidnight/dinov2/hub/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/OpenMidnight/dinov2/hub/backbones.py b/OpenMidnight/dinov2/hub/backbones.py new file mode 100644 index 0000000000000000000000000000000000000000..3a83e022ece48858a2d85ab6820cd1f68c306b78 --- /dev/null +++ b/OpenMidnight/dinov2/hub/backbones.py @@ -0,0 +1,174 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from enum import Enum +from pathlib import Path +from typing import Optional, Union +from urllib.parse import urlparse + +import torch + +from .utils import _DINOV2_BASE_URL, _make_dinov2_model_name + + +class Weights(Enum): + LVD142M = "LVD142M" + XRAY_DINO = "XRay-DINO" + + +def is_url(path: str) -> bool: + parsed = urlparse(path) + return parsed.scheme in ("https", "file") + + +def convert_path_or_url_to_url(path: str) -> str: + if is_url(path): + return path + return Path(path).expanduser().resolve().as_uri() + + +def _make_dinov2_model( + *, + arch_name: str = "vit_large", + img_size: int = 518, + patch_size: int = 14, + init_values: float = 1.0, + ffn_layer: str = "mlp", + block_chunks: int = 0, + num_register_tokens: int = 0, + interpolate_antialias: bool = False, + interpolate_offset: float = 0.1, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.LVD142M, + hash: Optional[str] = None, + check_hash: bool = False, + **kwargs, +): + from ..models import vision_transformer as vits + + model_base_name = _make_dinov2_model_name(arch_name, patch_size) + vit_kwargs = dict( + img_size=img_size, + patch_size=patch_size, + init_values=init_values, + ffn_layer=ffn_layer, + block_chunks=block_chunks, + num_register_tokens=num_register_tokens, + interpolate_antialias=interpolate_antialias, + interpolate_offset=interpolate_offset, + ) + vit_kwargs.update(**kwargs) + model = vits.__dict__[arch_name](**vit_kwargs) + + if pretrained: + if type(weights) is Weights and weights not in { + Weights.LVD142M, + Weights.XRAY_DINO, + }: + raise ValueError(f"Unsupported weights for the backbone: {weights}") + elif type(weights) is Weights: + model_full_name = _make_dinov2_model_name(arch_name, patch_size, num_register_tokens) + url = _DINOV2_BASE_URL + f"/{model_base_name}/{model_full_name}_pretrain.pth" + else: + url = convert_path_or_url_to_url(weights) + state_dict = torch.hub.load_state_dict_from_url(url, map_location="cpu", check_hash=check_hash) + model.load_state_dict(state_dict, strict=True) + + return model + + +def dinov2_vits14(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-S/14 model (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model(arch_name="vit_small", pretrained=pretrained, weights=weights, **kwargs) + + +def dinov2_vitb14(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-B/14 model (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model(arch_name="vit_base", pretrained=pretrained, weights=weights, **kwargs) + + +def dinov2_vitl14(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-L/14 model (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model(arch_name="vit_large", pretrained=pretrained, weights=weights, **kwargs) + + +def dinov2_vitg14(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-g/14 model (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model( + arch_name="vit_giant2", + ffn_layer="swiglufused", + weights=weights, + pretrained=pretrained, + **kwargs, + ) + + +def dinov2_vits14_reg(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-S/14 model with registers (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model( + arch_name="vit_small", + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) + + +def dinov2_vitb14_reg(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-B/14 model with registers (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model( + arch_name="vit_base", + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) + + +def dinov2_vitl14_reg(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-L/14 model with registers (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model( + arch_name="vit_large", + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) + + +def dinov2_vitg14_reg(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs): + """ + DINOv2 ViT-g/14 model with registers (optionally) pretrained on the LVD-142M dataset. + """ + return _make_dinov2_model( + arch_name="vit_giant2", + ffn_layer="swiglufused", + weights=weights, + pretrained=pretrained, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) \ No newline at end of file diff --git a/OpenMidnight/dinov2/hub/cell_dino/backbones.py b/OpenMidnight/dinov2/hub/cell_dino/backbones.py new file mode 100644 index 0000000000000000000000000000000000000000..329589c4b7afcf8715453ed2cd8ec60675dce6df --- /dev/null +++ b/OpenMidnight/dinov2/hub/cell_dino/backbones.py @@ -0,0 +1,182 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the CC-by-NC licence, +# found in the LICENSE_CELL_DINO_CODE file in the root directory of this source tree. + +from enum import Enum +from typing import Optional, Union + +import torch + + +class Weights(Enum): + CELL_DINO = "CELL-DINO" + + +def _make_cell_dino_model( + *, + arch_name: str = "vit_large", + img_size: int = 518, + patch_size: int = 14, + init_values: float = 1.0, + ffn_layer: str = "mlp", + block_chunks: int = 0, + num_register_tokens: int = 0, + interpolate_antialias: bool = False, + interpolate_offset: float = 0.1, + pretrained: bool = True, + channel_adaptive: bool = False, + weights: Union[Weights, str] = Weights.CELL_DINO, + pretrained_url: Optional[str] = None, + pretrained_path: Optional[str] = None, + **kwargs, +): + from ...models import vision_transformer as vits + + if isinstance(weights, str): + try: + weights = Weights[weights] + except KeyError: + raise AssertionError(f"Unsupported weights: {weights}") + + vit_kwargs = dict( + img_size=img_size, + patch_size=patch_size, + init_values=init_values, + ffn_layer=ffn_layer, + block_chunks=block_chunks, + num_register_tokens=num_register_tokens, + interpolate_antialias=interpolate_antialias, + interpolate_offset=interpolate_offset, + channel_adaptive=channel_adaptive, + ) + vit_kwargs.update(**kwargs) + model = vits.__dict__[arch_name](**vit_kwargs) + + if pretrained: + if pretrained_path is not None: + state_dict = torch.load(pretrained_path, map_location="cpu") + else: + pretrained_url is not None + state_dict = torch.hub.load_state_dict_from_url(pretrained_url, map_location="cpu") + model.load_state_dict(state_dict, strict=True) + + return model + + +def cell_dino_hpa_vitl16( + *, + pretrained_url: Optional[str] = None, + pretrained_path: Optional[str] = None, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.CELL_DINO, + in_channels: int = 4, + **kwargs, +): + """ + Cell-DINO ViT-L/16 model dataset pretrained on HPA dataset. + """ + return _make_cell_dino_model( + arch_name="vit_large", + patch_size=16, + img_size=224, + num_register_tokens=0, + interpolate_antialias=False, + interpolate_offset=0.1, + block_chunks=4, + pretrained_url=pretrained_url, + pretrained_path=pretrained_path, + pretrained=pretrained, + weights=weights, + in_chans=in_channels, + **kwargs, + ) + + +def cell_dino_hpa_vitl14( + *, + pretrained_url: Optional[str] = None, + pretrained_path: Optional[str] = None, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.CELL_DINO, + in_channels: int = 4, + **kwargs, +): + """ + Cell-DINO ViT-L/14 model dataset pretrained on LVD, then on HPA dataset. + """ + return _make_cell_dino_model( + arch_name="vit_large", + patch_size=14, + img_size=518, + num_register_tokens=0, + interpolate_antialias=False, + interpolate_offset=0.1, + block_chunks=4, + pretrained_url=pretrained_url, + pretrained_path=pretrained_path, + pretrained=pretrained, + weights=weights, + in_chans=in_channels, + **kwargs, + ) + + +def cell_dino_cp_vits8( + *, + pretrained_url: Optional[str] = None, + pretrained_path: Optional[str] = None, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.CELL_DINO, + in_channels: int = 5, + **kwargs, +): + """ + Cell-DINO ViT-S/8 model dataset pretrained on the combined cell painting dataset. + """ + return _make_cell_dino_model( + arch_name="vit_small", + patch_size=8, + img_size=128, + num_register_tokens=0, + interpolate_antialias=False, + interpolate_offset=0.1, + block_chunks=4, + pretrained_url=pretrained_url, + pretrained_path=pretrained_path, + pretrained=pretrained, + weights=weights, + in_chans=in_channels, + **kwargs, + ) + + +def channel_adaptive_dino_vitl16( + *, + pretrained_url: Optional[str] = None, + pretrained_path: Optional[str] = None, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.CELL_DINO, + in_channels: int = 1, + channel_adaptive: bool = True, + **kwargs, +): + """ + Cell-DINO ViT-L/16 model dataset pretrained on HPA dataset. + """ + return _make_cell_dino_model( + arch_name="vit_large", + patch_size=16, + img_size=224, + num_register_tokens=0, + interpolate_antialias=False, + interpolate_offset=0.1, + block_chunks=4, + pretrained_url=pretrained_url, + pretrained_path=pretrained_path, + pretrained=pretrained, + weights=weights, + in_chans=in_channels, + channel_adaptive=channel_adaptive, + **kwargs, + ) \ No newline at end of file diff --git a/OpenMidnight/dinov2/hub/classifiers.py b/OpenMidnight/dinov2/hub/classifiers.py new file mode 100644 index 0000000000000000000000000000000000000000..3f0841efa80ab3d564cd320d61da254af182606b --- /dev/null +++ b/OpenMidnight/dinov2/hub/classifiers.py @@ -0,0 +1,268 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from enum import Enum +from typing import Union + +import torch +import torch.nn as nn + +from .backbones import _make_dinov2_model +from .utils import _DINOV2_BASE_URL, _make_dinov2_model_name + + +class Weights(Enum): + IMAGENET1K = "IMAGENET1K" + + +def _make_dinov2_linear_classification_head( + *, + arch_name: str = "vit_large", + patch_size: int = 14, + embed_dim: int = 1024, + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.IMAGENET1K, + num_register_tokens: int = 0, + **kwargs, +): + if layers not in (1, 4): + raise AssertionError(f"Unsupported number of layers: {layers}") + if isinstance(weights, str): + try: + weights = Weights[weights] + except KeyError: + raise AssertionError(f"Unsupported weights: {weights}") + + linear_head = nn.Linear((1 + layers) * embed_dim, 1_000) + + if pretrained: + model_base_name = _make_dinov2_model_name(arch_name, patch_size) + model_full_name = _make_dinov2_model_name(arch_name, patch_size, num_register_tokens) + layers_str = str(layers) if layers == 4 else "" + url = _DINOV2_BASE_URL + f"/{model_base_name}/{model_full_name}_linear{layers_str}_head.pth" + state_dict = torch.hub.load_state_dict_from_url(url, map_location="cpu") + linear_head.load_state_dict(state_dict, strict=True) + + return linear_head + + +class _LinearClassifierWrapper(nn.Module): + def __init__(self, *, backbone: nn.Module, linear_head: nn.Module, layers: int = 4): + super().__init__() + self.backbone = backbone + self.linear_head = linear_head + self.layers = layers + + def forward(self, x): + if self.layers == 1: + x = self.backbone.forward_features(x) + cls_token = x["x_norm_clstoken"] + patch_tokens = x["x_norm_patchtokens"] + # fmt: off + linear_input = torch.cat([ + cls_token, + patch_tokens.mean(dim=1), + ], dim=1) + # fmt: on + elif self.layers == 4: + x = self.backbone.get_intermediate_layers(x, n=4, return_class_token=True) + # fmt: off + linear_input = torch.cat([ + x[0][1], + x[1][1], + x[2][1], + x[3][1], + x[3][0].mean(dim=1), + ], dim=1) + # fmt: on + else: + assert False, f"Unsupported number of layers: {self.layers}" + return self.linear_head(linear_input) + + +def _make_dinov2_linear_classifier( + *, + arch_name: str = "vit_large", + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.IMAGENET1K, + num_register_tokens: int = 0, + interpolate_antialias: bool = False, + interpolate_offset: float = 0.1, + **kwargs, +): + backbone = _make_dinov2_model( + arch_name=arch_name, + pretrained=pretrained, + num_register_tokens=num_register_tokens, + interpolate_antialias=interpolate_antialias, + interpolate_offset=interpolate_offset, + **kwargs, + ) + + embed_dim = backbone.embed_dim + patch_size = backbone.patch_size + linear_head = _make_dinov2_linear_classification_head( + arch_name=arch_name, + patch_size=patch_size, + embed_dim=embed_dim, + layers=layers, + pretrained=pretrained, + weights=weights, + num_register_tokens=num_register_tokens, + ) + + return _LinearClassifierWrapper(backbone=backbone, linear_head=linear_head, layers=layers) + + +def dinov2_vits14_lc( + *, + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.IMAGENET1K, + **kwargs, +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-S/14 backbone (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_small", + layers=layers, + pretrained=pretrained, + weights=weights, + **kwargs, + ) + + +def dinov2_vitb14_lc( + *, + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.IMAGENET1K, + **kwargs, +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-B/14 backbone (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_base", + layers=layers, + pretrained=pretrained, + weights=weights, + **kwargs, + ) + + +def dinov2_vitl14_lc( + *, + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.IMAGENET1K, + **kwargs, +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-L/14 backbone (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_large", + layers=layers, + pretrained=pretrained, + weights=weights, + **kwargs, + ) + + +def dinov2_vitg14_lc( + *, + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.IMAGENET1K, + **kwargs, +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-g/14 backbone (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_giant2", + layers=layers, + ffn_layer="swiglufused", + pretrained=pretrained, + weights=weights, + **kwargs, + ) + + +def dinov2_vits14_reg_lc( + *, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.IMAGENET1K, **kwargs +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-S/14 backbone with registers (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_small", + layers=layers, + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) + + +def dinov2_vitb14_reg_lc( + *, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.IMAGENET1K, **kwargs +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-B/14 backbone with registers (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_base", + layers=layers, + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) + + +def dinov2_vitl14_reg_lc( + *, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.IMAGENET1K, **kwargs +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-L/14 backbone with registers (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_large", + layers=layers, + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) + + +def dinov2_vitg14_reg_lc( + *, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.IMAGENET1K, **kwargs +): + """ + Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-g/14 backbone with registers (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k. + """ + return _make_dinov2_linear_classifier( + arch_name="vit_giant2", + layers=layers, + ffn_layer="swiglufused", + pretrained=pretrained, + weights=weights, + num_register_tokens=4, + interpolate_antialias=True, + interpolate_offset=0.0, + **kwargs, + ) diff --git a/OpenMidnight/dinov2/hub/depth/__init__.py b/OpenMidnight/dinov2/hub/depth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..91716e58ab6158d814df8c653644d9af4c7be65c --- /dev/null +++ b/OpenMidnight/dinov2/hub/depth/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .decode_heads import BNHead, DPTHead +from .encoder_decoder import DepthEncoderDecoder diff --git a/OpenMidnight/dinov2/hub/depth/decode_heads.py b/OpenMidnight/dinov2/hub/depth/decode_heads.py new file mode 100644 index 0000000000000000000000000000000000000000..f455accad38fec6ecdd53460233a564c34f434da --- /dev/null +++ b/OpenMidnight/dinov2/hub/depth/decode_heads.py @@ -0,0 +1,747 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import copy +from functools import partial +import math +import warnings + +import torch +import torch.nn as nn + +from .ops import resize + + +# XXX: (Untested) replacement for mmcv.imdenormalize() +def _imdenormalize(img, mean, std, to_bgr=True): + import numpy as np + + mean = mean.reshape(1, -1).astype(np.float64) + std = std.reshape(1, -1).astype(np.float64) + img = (img * std) + mean + if to_bgr: + img = img[::-1] + return img + + +class DepthBaseDecodeHead(nn.Module): + """Base class for BaseDecodeHead. + + Args: + in_channels (List): Input channels. + channels (int): Channels after modules, before conv_depth. + conv_layer (nn.Module): Conv layers. Default: None. + act_layer (nn.Module): Activation layers. Default: nn.ReLU. + loss_decode (dict): Config of decode loss. + Default: (). + sampler (dict|None): The config of depth map sampler. + Default: None. + align_corners (bool): align_corners argument of F.interpolate. + Default: False. + min_depth (int): Min depth in dataset setting. + Default: 1e-3. + max_depth (int): Max depth in dataset setting. + Default: None. + norm_layer (dict|None): Norm layers. + Default: None. + classify (bool): Whether predict depth in a cls.-reg. manner. + Default: False. + n_bins (int): The number of bins used in cls. step. + Default: 256. + bins_strategy (str): The discrete strategy used in cls. step. + Default: 'UD'. + norm_strategy (str): The norm strategy on cls. probability + distribution. Default: 'linear' + scale_up (str): Whether predict depth in a scale-up manner. + Default: False. + """ + + def __init__( + self, + in_channels, + conv_layer=None, + act_layer=nn.ReLU, + channels=96, + loss_decode=(), + sampler=None, + align_corners=False, + min_depth=1e-3, + max_depth=None, + norm_layer=None, + classify=False, + n_bins=256, + bins_strategy="UD", + norm_strategy="linear", + scale_up=False, + ): + super(DepthBaseDecodeHead, self).__init__() + + self.in_channels = in_channels + self.channels = channels + self.conf_layer = conv_layer + self.act_layer = act_layer + self.loss_decode = loss_decode + self.align_corners = align_corners + self.min_depth = min_depth + self.max_depth = max_depth + self.norm_layer = norm_layer + self.classify = classify + self.n_bins = n_bins + self.scale_up = scale_up + + if self.classify: + assert bins_strategy in ["UD", "SID"], "Support bins_strategy: UD, SID" + assert norm_strategy in ["linear", "softmax", "sigmoid"], "Support norm_strategy: linear, softmax, sigmoid" + + self.bins_strategy = bins_strategy + self.norm_strategy = norm_strategy + self.softmax = nn.Softmax(dim=1) + self.conv_depth = nn.Conv2d(channels, n_bins, kernel_size=3, padding=1, stride=1) + else: + self.conv_depth = nn.Conv2d(channels, 1, kernel_size=3, padding=1, stride=1) + + self.relu = nn.ReLU() + self.sigmoid = nn.Sigmoid() + + def forward(self, inputs, img_metas): + """Placeholder of forward function.""" + pass + + def forward_train(self, img, inputs, img_metas, depth_gt): + """Forward function for training. + Args: + inputs (list[Tensor]): List of multi-level img features. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + depth_gt (Tensor): GT depth + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + depth_pred = self.forward(inputs, img_metas) + losses = self.losses(depth_pred, depth_gt) + + log_imgs = self.log_images(img[0], depth_pred[0], depth_gt[0], img_metas[0]) + losses.update(**log_imgs) + + return losses + + def forward_test(self, inputs, img_metas): + """Forward function for testing. + Args: + inputs (list[Tensor]): List of multi-level img features. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + + Returns: + Tensor: Output depth map. + """ + return self.forward(inputs, img_metas) + + def depth_pred(self, feat): + """Prediction each pixel.""" + if self.classify: + logit = self.conv_depth(feat) + + if self.bins_strategy == "UD": + bins = torch.linspace(self.min_depth, self.max_depth, self.n_bins, device=feat.device) + elif self.bins_strategy == "SID": + bins = torch.logspace(self.min_depth, self.max_depth, self.n_bins, device=feat.device) + + # following Adabins, default linear + if self.norm_strategy == "linear": + logit = torch.relu(logit) + eps = 0.1 + logit = logit + eps + logit = logit / logit.sum(dim=1, keepdim=True) + elif self.norm_strategy == "softmax": + logit = torch.softmax(logit, dim=1) + elif self.norm_strategy == "sigmoid": + logit = torch.sigmoid(logit) + logit = logit / logit.sum(dim=1, keepdim=True) + + output = torch.einsum("ikmn,k->imn", [logit, bins]).unsqueeze(dim=1) + + else: + if self.scale_up: + output = self.sigmoid(self.conv_depth(feat)) * self.max_depth + else: + output = self.relu(self.conv_depth(feat)) + self.min_depth + return output + + def losses(self, depth_pred, depth_gt): + """Compute depth loss.""" + loss = dict() + depth_pred = resize( + input=depth_pred, size=depth_gt.shape[2:], mode="bilinear", align_corners=self.align_corners, warning=False + ) + if not isinstance(self.loss_decode, nn.ModuleList): + losses_decode = [self.loss_decode] + else: + losses_decode = self.loss_decode + for loss_decode in losses_decode: + if loss_decode.loss_name not in loss: + loss[loss_decode.loss_name] = loss_decode(depth_pred, depth_gt) + else: + loss[loss_decode.loss_name] += loss_decode(depth_pred, depth_gt) + return loss + + def log_images(self, img_path, depth_pred, depth_gt, img_meta): + import numpy as np + + show_img = copy.deepcopy(img_path.detach().cpu().permute(1, 2, 0)) + show_img = show_img.numpy().astype(np.float32) + show_img = _imdenormalize( + show_img, + img_meta["img_norm_cfg"]["mean"], + img_meta["img_norm_cfg"]["std"], + img_meta["img_norm_cfg"]["to_rgb"], + ) + show_img = np.clip(show_img, 0, 255) + show_img = show_img.astype(np.uint8) + show_img = show_img[:, :, ::-1] + show_img = show_img.transpose(0, 2, 1) + show_img = show_img.transpose(1, 0, 2) + + depth_pred = depth_pred / torch.max(depth_pred) + depth_gt = depth_gt / torch.max(depth_gt) + + depth_pred_color = copy.deepcopy(depth_pred.detach().cpu()) + depth_gt_color = copy.deepcopy(depth_gt.detach().cpu()) + + return {"img_rgb": show_img, "img_depth_pred": depth_pred_color, "img_depth_gt": depth_gt_color} + + +class BNHead(DepthBaseDecodeHead): + """Just a batchnorm.""" + + def __init__(self, input_transform="resize_concat", in_index=(0, 1, 2, 3), upsample=1, **kwargs): + super().__init__(**kwargs) + self.input_transform = input_transform + self.in_index = in_index + self.upsample = upsample + # self.bn = nn.SyncBatchNorm(self.in_channels) + if self.classify: + self.conv_depth = nn.Conv2d(self.channels, self.n_bins, kernel_size=1, padding=0, stride=1) + else: + self.conv_depth = nn.Conv2d(self.channels, 1, kernel_size=1, padding=0, stride=1) + + def _transform_inputs(self, inputs): + """Transform inputs for decoder. + Args: + inputs (list[Tensor]): List of multi-level img features. + Returns: + Tensor: The transformed inputs + """ + + if "concat" in self.input_transform: + inputs = [inputs[i] for i in self.in_index] + if "resize" in self.input_transform: + inputs = [ + resize( + input=x, + size=[s * self.upsample for s in inputs[0].shape[2:]], + mode="bilinear", + align_corners=self.align_corners, + ) + for x in inputs + ] + inputs = torch.cat(inputs, dim=1) + elif self.input_transform == "multiple_select": + inputs = [inputs[i] for i in self.in_index] + else: + inputs = inputs[self.in_index] + + return inputs + + def _forward_feature(self, inputs, img_metas=None, **kwargs): + """Forward function for feature maps before classifying each pixel with + ``self.cls_seg`` fc. + Args: + inputs (list[Tensor]): List of multi-level img features. + Returns: + feats (Tensor): A tensor of shape (batch_size, self.channels, + H, W) which is feature map for last layer of decoder head. + """ + # accept lists (for cls token) + inputs = list(inputs) + for i, x in enumerate(inputs): + if len(x) == 2: + x, cls_token = x[0], x[1] + if len(x.shape) == 2: + x = x[:, :, None, None] + cls_token = cls_token[:, :, None, None].expand_as(x) + inputs[i] = torch.cat((x, cls_token), 1) + else: + x = x[0] + if len(x.shape) == 2: + x = x[:, :, None, None] + inputs[i] = x + x = self._transform_inputs(inputs) + # feats = self.bn(x) + return x + + def forward(self, inputs, img_metas=None, **kwargs): + """Forward function.""" + output = self._forward_feature(inputs, img_metas=img_metas, **kwargs) + output = self.depth_pred(output) + return output + + +class ConvModule(nn.Module): + """A conv block that bundles conv/norm/activation layers. + + This block simplifies the usage of convolution layers, which are commonly + used with a norm layer (e.g., BatchNorm) and activation layer (e.g., ReLU). + It is based upon three build methods: `build_conv_layer()`, + `build_norm_layer()` and `build_activation_layer()`. + + Besides, we add some additional features in this module. + 1. Automatically set `bias` of the conv layer. + 2. Spectral norm is supported. + 3. More padding modes are supported. Before PyTorch 1.5, nn.Conv2d only + supports zero and circular padding, and we add "reflect" padding mode. + + Args: + in_channels (int): Number of channels in the input feature map. + Same as that in ``nn._ConvNd``. + out_channels (int): Number of channels produced by the convolution. + Same as that in ``nn._ConvNd``. + kernel_size (int | tuple[int]): Size of the convolving kernel. + Same as that in ``nn._ConvNd``. + stride (int | tuple[int]): Stride of the convolution. + Same as that in ``nn._ConvNd``. + padding (int | tuple[int]): Zero-padding added to both sides of + the input. Same as that in ``nn._ConvNd``. + dilation (int | tuple[int]): Spacing between kernel elements. + Same as that in ``nn._ConvNd``. + groups (int): Number of blocked connections from input channels to + output channels. Same as that in ``nn._ConvNd``. + bias (bool | str): If specified as `auto`, it will be decided by the + norm_layer. Bias will be set as True if `norm_layer` is None, otherwise + False. Default: "auto". + conv_layer (nn.Module): Convolution layer. Default: None, + which means using conv2d. + norm_layer (nn.Module): Normalization layer. Default: None. + act_layer (nn.Module): Activation layer. Default: nn.ReLU. + inplace (bool): Whether to use inplace mode for activation. + Default: True. + with_spectral_norm (bool): Whether use spectral norm in conv module. + Default: False. + padding_mode (str): If the `padding_mode` has not been supported by + current `Conv2d` in PyTorch, we will use our own padding layer + instead. Currently, we support ['zeros', 'circular'] with official + implementation and ['reflect'] with our own implementation. + Default: 'zeros'. + order (tuple[str]): The order of conv/norm/activation layers. It is a + sequence of "conv", "norm" and "act". Common examples are + ("conv", "norm", "act") and ("act", "conv", "norm"). + Default: ('conv', 'norm', 'act'). + """ + + _abbr_ = "conv_block" + + def __init__( + self, + in_channels, + out_channels, + kernel_size, + stride=1, + padding=0, + dilation=1, + groups=1, + bias="auto", + conv_layer=nn.Conv2d, + norm_layer=None, + act_layer=nn.ReLU, + inplace=True, + with_spectral_norm=False, + padding_mode="zeros", + order=("conv", "norm", "act"), + ): + super(ConvModule, self).__init__() + official_padding_mode = ["zeros", "circular"] + self.conv_layer = conv_layer + self.norm_layer = norm_layer + self.act_layer = act_layer + self.inplace = inplace + self.with_spectral_norm = with_spectral_norm + self.with_explicit_padding = padding_mode not in official_padding_mode + self.order = order + assert isinstance(self.order, tuple) and len(self.order) == 3 + assert set(order) == set(["conv", "norm", "act"]) + + self.with_norm = norm_layer is not None + self.with_activation = act_layer is not None + # if the conv layer is before a norm layer, bias is unnecessary. + if bias == "auto": + bias = not self.with_norm + self.with_bias = bias + + if self.with_explicit_padding: + if padding_mode == "zeros": + padding_layer = nn.ZeroPad2d + else: + raise AssertionError(f"Unsupported padding mode: {padding_mode}") + self.pad = padding_layer(padding) + + # reset padding to 0 for conv module + conv_padding = 0 if self.with_explicit_padding else padding + # build convolution layer + self.conv = self.conv_layer( + in_channels, + out_channels, + kernel_size, + stride=stride, + padding=conv_padding, + dilation=dilation, + groups=groups, + bias=bias, + ) + # export the attributes of self.conv to a higher level for convenience + self.in_channels = self.conv.in_channels + self.out_channels = self.conv.out_channels + self.kernel_size = self.conv.kernel_size + self.stride = self.conv.stride + self.padding = padding + self.dilation = self.conv.dilation + self.transposed = self.conv.transposed + self.output_padding = self.conv.output_padding + self.groups = self.conv.groups + + if self.with_spectral_norm: + self.conv = nn.utils.spectral_norm(self.conv) + + # build normalization layers + if self.with_norm: + # norm layer is after conv layer + if order.index("norm") > order.index("conv"): + norm_channels = out_channels + else: + norm_channels = in_channels + norm = partial(norm_layer, num_features=norm_channels) + self.add_module("norm", norm) + if self.with_bias: + from torch.nnModules.batchnorm import _BatchNorm + from torch.nnModules.instancenorm import _InstanceNorm + + if isinstance(norm, (_BatchNorm, _InstanceNorm)): + warnings.warn("Unnecessary conv bias before batch/instance norm") + else: + self.norm_name = None + + # build activation layer + if self.with_activation: + # nn.Tanh has no 'inplace' argument + # (nn.Tanh, nn.PReLU, nn.Sigmoid, nn.HSigmoid, nn.Swish, nn.GELU) + if not isinstance(act_layer, (nn.Tanh, nn.PReLU, nn.Sigmoid, nn.GELU)): + act_layer = partial(act_layer, inplace=inplace) + self.activate = act_layer() + + # Use msra init by default + self.init_weights() + + @property + def norm(self): + if self.norm_name: + return getattr(self, self.norm_name) + else: + return None + + def init_weights(self): + # 1. It is mainly for customized conv layers with their own + # initialization manners by calling their own ``init_weights()``, + # and we do not want ConvModule to override the initialization. + # 2. For customized conv layers without their own initialization + # manners (that is, they don't have their own ``init_weights()``) + # and PyTorch's conv layers, they will be initialized by + # this method with default ``kaiming_init``. + # Note: For PyTorch's conv layers, they will be overwritten by our + # initialization implementation using default ``kaiming_init``. + if not hasattr(self.conv, "init_weights"): + if self.with_activation and isinstance(self.act_layer, nn.LeakyReLU): + nonlinearity = "leaky_relu" + a = 0.01 # XXX: default negative_slope + else: + nonlinearity = "relu" + a = 0 + if hasattr(self.conv, "weight") and self.conv.weight is not None: + nn.init.kaiming_normal_(self.conv.weight, a=a, mode="fan_out", nonlinearity=nonlinearity) + if hasattr(self.conv, "bias") and self.conv.bias is not None: + nn.init.constant_(self.conv.bias, 0) + if self.with_norm: + if hasattr(self.norm, "weight") and self.norm.weight is not None: + nn.init.constant_(self.norm.weight, 1) + if hasattr(self.norm, "bias") and self.norm.bias is not None: + nn.init.constant_(self.norm.bias, 0) + + def forward(self, x, activate=True, norm=True): + for layer in self.order: + if layer == "conv": + if self.with_explicit_padding: + x = self.pad(x) + x = self.conv(x) + elif layer == "norm" and norm and self.with_norm: + x = self.norm(x) + elif layer == "act" and activate and self.with_activation: + x = self.activate(x) + return x + + +class Interpolate(nn.Module): + def __init__(self, scale_factor, mode, align_corners=False): + super(Interpolate, self).__init__() + self.interp = nn.functional.interpolate + self.scale_factor = scale_factor + self.mode = mode + self.align_corners = align_corners + + def forward(self, x): + x = self.interp(x, scale_factor=self.scale_factor, mode=self.mode, align_corners=self.align_corners) + return x + + +class HeadDepth(nn.Module): + def __init__(self, features): + super(HeadDepth, self).__init__() + self.head = nn.Sequential( + nn.Conv2d(features, features // 2, kernel_size=3, stride=1, padding=1), + Interpolate(scale_factor=2, mode="bilinear", align_corners=True), + nn.Conv2d(features // 2, 32, kernel_size=3, stride=1, padding=1), + nn.ReLU(), + nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0), + ) + + def forward(self, x): + x = self.head(x) + return x + + +class ReassembleBlocks(nn.Module): + """ViTPostProcessBlock, process cls_token in ViT backbone output and + rearrange the feature vector to feature map. + Args: + in_channels (int): ViT feature channels. Default: 768. + out_channels (List): output channels of each stage. + Default: [96, 192, 384, 768]. + readout_type (str): Type of readout operation. Default: 'ignore'. + patch_size (int): The patch size. Default: 16. + """ + + def __init__(self, in_channels=768, out_channels=[96, 192, 384, 768], readout_type="ignore", patch_size=16): + super(ReassembleBlocks, self).__init__() + + assert readout_type in ["ignore", "add", "project"] + self.readout_type = readout_type + self.patch_size = patch_size + + self.projects = nn.ModuleList( + [ + ConvModule( + in_channels=in_channels, + out_channels=out_channel, + kernel_size=1, + act_layer=None, + ) + for out_channel in out_channels + ] + ) + + self.resize_layers = nn.ModuleList( + [ + nn.ConvTranspose2d( + in_channels=out_channels[0], out_channels=out_channels[0], kernel_size=4, stride=4, padding=0 + ), + nn.ConvTranspose2d( + in_channels=out_channels[1], out_channels=out_channels[1], kernel_size=2, stride=2, padding=0 + ), + nn.Identity(), + nn.Conv2d( + in_channels=out_channels[3], out_channels=out_channels[3], kernel_size=3, stride=2, padding=1 + ), + ] + ) + if self.readout_type == "project": + self.readout_projects = nn.ModuleList() + for _ in range(len(self.projects)): + self.readout_projects.append(nn.Sequential(nn.Linear(2 * in_channels, in_channels), nn.GELU())) + + def forward(self, inputs): + assert isinstance(inputs, list) + out = [] + for i, x in enumerate(inputs): + assert len(x) == 2 + x, cls_token = x[0], x[1] + feature_shape = x.shape + if self.readout_type == "project": + x = x.flatten(2).permute((0, 2, 1)) + readout = cls_token.unsqueeze(1).expand_as(x) + x = self.readout_projects[i](torch.cat((x, readout), -1)) + x = x.permute(0, 2, 1).reshape(feature_shape) + elif self.readout_type == "add": + x = x.flatten(2) + cls_token.unsqueeze(-1) + x = x.reshape(feature_shape) + else: + pass + x = self.projects[i](x) + x = self.resize_layers[i](x) + out.append(x) + return out + + +class PreActResidualConvUnit(nn.Module): + """ResidualConvUnit, pre-activate residual unit. + Args: + in_channels (int): number of channels in the input feature map. + act_layer (nn.Module): activation layer. + norm_layer (nn.Module): norm layer. + stride (int): stride of the first block. Default: 1 + dilation (int): dilation rate for convs layers. Default: 1. + """ + + def __init__(self, in_channels, act_layer, norm_layer, stride=1, dilation=1): + super(PreActResidualConvUnit, self).__init__() + + self.conv1 = ConvModule( + in_channels, + in_channels, + 3, + stride=stride, + padding=dilation, + dilation=dilation, + norm_layer=norm_layer, + act_layer=act_layer, + bias=False, + order=("act", "conv", "norm"), + ) + + self.conv2 = ConvModule( + in_channels, + in_channels, + 3, + padding=1, + norm_layer=norm_layer, + act_layer=act_layer, + bias=False, + order=("act", "conv", "norm"), + ) + + def forward(self, inputs): + inputs_ = inputs.clone() + x = self.conv1(inputs) + x = self.conv2(x) + return x + inputs_ + + +class FeatureFusionBlock(nn.Module): + """FeatureFusionBlock, merge feature map from different stages. + Args: + in_channels (int): Input channels. + act_layer (nn.Module): activation layer for ResidualConvUnit. + norm_layer (nn.Module): normalization layer. + expand (bool): Whether expand the channels in post process block. + Default: False. + align_corners (bool): align_corner setting for bilinear upsample. + Default: True. + """ + + def __init__(self, in_channels, act_layer, norm_layer, expand=False, align_corners=True): + super(FeatureFusionBlock, self).__init__() + + self.in_channels = in_channels + self.expand = expand + self.align_corners = align_corners + + self.out_channels = in_channels + if self.expand: + self.out_channels = in_channels // 2 + + self.project = ConvModule(self.in_channels, self.out_channels, kernel_size=1, act_layer=None, bias=True) + + self.res_conv_unit1 = PreActResidualConvUnit( + in_channels=self.in_channels, act_layer=act_layer, norm_layer=norm_layer + ) + self.res_conv_unit2 = PreActResidualConvUnit( + in_channels=self.in_channels, act_layer=act_layer, norm_layer=norm_layer + ) + + def forward(self, *inputs): + x = inputs[0] + if len(inputs) == 2: + if x.shape != inputs[1].shape: + res = resize(inputs[1], size=(x.shape[2], x.shape[3]), mode="bilinear", align_corners=False) + else: + res = inputs[1] + x = x + self.res_conv_unit1(res) + x = self.res_conv_unit2(x) + x = resize(x, scale_factor=2, mode="bilinear", align_corners=self.align_corners) + x = self.project(x) + return x + + +class DPTHead(DepthBaseDecodeHead): + """Vision Transformers for Dense Prediction. + This head is implemented of `DPT `_. + Args: + embed_dims (int): The embed dimension of the ViT backbone. + Default: 768. + post_process_channels (List): Out channels of post process conv + layers. Default: [96, 192, 384, 768]. + readout_type (str): Type of readout operation. Default: 'ignore'. + patch_size (int): The patch size. Default: 16. + expand_channels (bool): Whether expand the channels in post process + block. Default: False. + """ + + def __init__( + self, + embed_dims=768, + post_process_channels=[96, 192, 384, 768], + readout_type="ignore", + patch_size=16, + expand_channels=False, + **kwargs, + ): + super(DPTHead, self).__init__(**kwargs) + + self.in_channels = self.in_channels + self.expand_channels = expand_channels + self.reassemble_blocks = ReassembleBlocks(embed_dims, post_process_channels, readout_type, patch_size) + + self.post_process_channels = [ + channel * math.pow(2, i) if expand_channels else channel for i, channel in enumerate(post_process_channels) + ] + self.convs = nn.ModuleList() + for channel in self.post_process_channels: + self.convs.append(ConvModule(channel, self.channels, kernel_size=3, padding=1, act_layer=None, bias=False)) + self.fusion_blocks = nn.ModuleList() + for _ in range(len(self.convs)): + self.fusion_blocks.append(FeatureFusionBlock(self.channels, self.act_layer, self.norm_layer)) + self.fusion_blocks[0].res_conv_unit1 = None + self.project = ConvModule(self.channels, self.channels, kernel_size=3, padding=1, norm_layer=self.norm_layer) + self.num_fusion_blocks = len(self.fusion_blocks) + self.num_reassemble_blocks = len(self.reassemble_blocks.resize_layers) + self.num_post_process_channels = len(self.post_process_channels) + assert self.num_fusion_blocks == self.num_reassemble_blocks + assert self.num_reassemble_blocks == self.num_post_process_channels + self.conv_depth = HeadDepth(self.channels) + + def forward(self, inputs, img_metas): + assert len(inputs) == self.num_reassemble_blocks + x = [inp for inp in inputs] + x = self.reassemble_blocks(x) + x = [self.convs[i](feature) for i, feature in enumerate(x)] + out = self.fusion_blocks[0](x[-1]) + for i in range(1, len(self.fusion_blocks)): + out = self.fusion_blocks[i](out, x[-(i + 1)]) + out = self.project(out) + out = self.depth_pred(out) + return out diff --git a/OpenMidnight/dinov2/hub/depth/encoder_decoder.py b/OpenMidnight/dinov2/hub/depth/encoder_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..eb29ced67957a336e763b0e7c90c0eeaea36fea8 --- /dev/null +++ b/OpenMidnight/dinov2/hub/depth/encoder_decoder.py @@ -0,0 +1,351 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from collections import OrderedDict + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .ops import resize + + +def add_prefix(inputs, prefix): + """Add prefix for dict. + + Args: + inputs (dict): The input dict with str keys. + prefix (str): The prefix to add. + + Returns: + + dict: The dict with keys updated with ``prefix``. + """ + + outputs = dict() + for name, value in inputs.items(): + outputs[f"{prefix}.{name}"] = value + + return outputs + + +class DepthEncoderDecoder(nn.Module): + """Encoder Decoder depther. + + EncoderDecoder typically consists of backbone and decode_head. + """ + + def __init__(self, backbone, decode_head): + super(DepthEncoderDecoder, self).__init__() + + self.backbone = backbone + self.decode_head = decode_head + self.align_corners = self.decode_head.align_corners + + def extract_feat(self, img): + """Extract features from images.""" + return self.backbone(img) + + def encode_decode(self, img, img_metas, rescale=True, size=None): + """Encode images with backbone and decode into a depth estimation + map of the same size as input.""" + x = self.extract_feat(img) + out = self._decode_head_forward_test(x, img_metas) + # crop the pred depth to the certain range. + out = torch.clamp(out, min=self.decode_head.min_depth, max=self.decode_head.max_depth) + if rescale: + if size is None: + if img_metas is not None: + size = img_metas[0]["ori_shape"][:2] + else: + size = img.shape[2:] + out = resize(input=out, size=size, mode="bilinear", align_corners=self.align_corners) + return out + + def _decode_head_forward_train(self, img, x, img_metas, depth_gt, **kwargs): + """Run forward function and calculate loss for decode head in + training.""" + losses = dict() + loss_decode = self.decode_head.forward_train(img, x, img_metas, depth_gt, **kwargs) + losses.update(add_prefix(loss_decode, "decode")) + return losses + + def _decode_head_forward_test(self, x, img_metas): + """Run forward function and calculate loss for decode head in + inference.""" + depth_pred = self.decode_head.forward_test(x, img_metas) + return depth_pred + + def forward_dummy(self, img): + """Dummy forward function.""" + depth = self.encode_decode(img, None) + + return depth + + def forward_train(self, img, img_metas, depth_gt, **kwargs): + """Forward function for training. + + Args: + img (Tensor): Input images. + img_metas (list[dict]): List of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + depth_gt (Tensor): Depth gt + used if the architecture supports depth estimation task. + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + + x = self.extract_feat(img) + + losses = dict() + + # the last of x saves the info from neck + loss_decode = self._decode_head_forward_train(img, x, img_metas, depth_gt, **kwargs) + + losses.update(loss_decode) + + return losses + + def whole_inference(self, img, img_meta, rescale, size=None): + """Inference with full image.""" + return self.encode_decode(img, img_meta, rescale, size=size) + + def slide_inference(self, img, img_meta, rescale, stride, crop_size): + """Inference by sliding-window with overlap. + + If h_crop > h_img or w_crop > w_img, the small patch will be used to + decode without padding. + """ + + h_stride, w_stride = stride + h_crop, w_crop = crop_size + batch_size, _, h_img, w_img = img.size() + h_grids = max(h_img - h_crop + h_stride - 1, 0) // h_stride + 1 + w_grids = max(w_img - w_crop + w_stride - 1, 0) // w_stride + 1 + preds = img.new_zeros((batch_size, 1, h_img, w_img)) + count_mat = img.new_zeros((batch_size, 1, h_img, w_img)) + for h_idx in range(h_grids): + for w_idx in range(w_grids): + y1 = h_idx * h_stride + x1 = w_idx * w_stride + y2 = min(y1 + h_crop, h_img) + x2 = min(x1 + w_crop, w_img) + y1 = max(y2 - h_crop, 0) + x1 = max(x2 - w_crop, 0) + crop_img = img[:, :, y1:y2, x1:x2] + depth_pred = self.encode_decode(crop_img, img_meta, rescale) + preds += F.pad(depth_pred, (int(x1), int(preds.shape[3] - x2), int(y1), int(preds.shape[2] - y2))) + + count_mat[:, :, y1:y2, x1:x2] += 1 + assert (count_mat == 0).sum() == 0 + if torch.onnx.is_in_onnx_export(): + # cast count_mat to constant while exporting to ONNX + count_mat = torch.from_numpy(count_mat.cpu().detach().numpy()).to(device=img.device) + preds = preds / count_mat + return preds + + def inference(self, img, img_meta, rescale, size=None, mode="whole"): + """Inference with slide/whole style. + + Args: + img (Tensor): The input image of shape (N, 3, H, W). + img_meta (dict): Image info dict where each dict has: 'img_shape', + 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `depth/datasets/pipelines/formatting.py:Collect`. + rescale (bool): Whether rescale back to original shape. + + Returns: + Tensor: The output depth map. + """ + + assert mode in ["slide", "whole"] + ori_shape = img_meta[0]["ori_shape"] + assert all(_["ori_shape"] == ori_shape for _ in img_meta) + if mode == "slide": + depth_pred = self.slide_inference(img, img_meta, rescale) + else: + depth_pred = self.whole_inference(img, img_meta, rescale, size=size) + output = depth_pred + flip = img_meta[0]["flip"] + if flip: + flip_direction = img_meta[0]["flip_direction"] + assert flip_direction in ["horizontal", "vertical"] + if flip_direction == "horizontal": + output = output.flip(dims=(3,)) + elif flip_direction == "vertical": + output = output.flip(dims=(2,)) + + return output + + def simple_test(self, img, img_meta, rescale=True): + """Simple test with single image.""" + depth_pred = self.inference(img, img_meta, rescale) + if torch.onnx.is_in_onnx_export(): + # our inference backend only support 4D output + depth_pred = depth_pred.unsqueeze(0) + return depth_pred + depth_pred = depth_pred.cpu().numpy() + # unravel batch dim + depth_pred = list(depth_pred) + return depth_pred + + def aug_test(self, imgs, img_metas, rescale=True): + """Test with augmentations. + + Only rescale=True is supported. + """ + # aug_test rescale all imgs back to ori_shape for now + assert rescale + # to save memory, we get augmented depth logit inplace + depth_pred = self.inference(imgs[0], img_metas[0], rescale) + for i in range(1, len(imgs)): + cur_depth_pred = self.inference(imgs[i], img_metas[i], rescale, size=depth_pred.shape[-2:]) + depth_pred += cur_depth_pred + depth_pred /= len(imgs) + depth_pred = depth_pred.cpu().numpy() + # unravel batch dim + depth_pred = list(depth_pred) + return depth_pred + + def forward_test(self, imgs, img_metas, **kwargs): + """ + Args: + imgs (List[Tensor]): the outer list indicates test-time + augmentations and inner Tensor should have a shape NxCxHxW, + which contains all images in the batch. + img_metas (List[List[dict]]): the outer list indicates test-time + augs (multiscale, flip, etc.) and the inner list indicates + images in a batch. + """ + for var, name in [(imgs, "imgs"), (img_metas, "img_metas")]: + if not isinstance(var, list): + raise TypeError(f"{name} must be a list, but got " f"{type(var)}") + num_augs = len(imgs) + if num_augs != len(img_metas): + raise ValueError(f"num of augmentations ({len(imgs)}) != " f"num of image meta ({len(img_metas)})") + # all images in the same aug batch all of the same ori_shape and pad + # shape + for img_meta in img_metas: + ori_shapes = [_["ori_shape"] for _ in img_meta] + assert all(shape == ori_shapes[0] for shape in ori_shapes) + img_shapes = [_["img_shape"] for _ in img_meta] + assert all(shape == img_shapes[0] for shape in img_shapes) + pad_shapes = [_["pad_shape"] for _ in img_meta] + assert all(shape == pad_shapes[0] for shape in pad_shapes) + + if num_augs == 1: + return self.simple_test(imgs[0], img_metas[0], **kwargs) + else: + return self.aug_test(imgs, img_metas, **kwargs) + + def forward(self, img, img_metas, return_loss=True, **kwargs): + """Calls either :func:`forward_train` or :func:`forward_test` depending + on whether ``return_loss`` is ``True``. + + Note this setting will change the expected inputs. When + ``return_loss=True``, img and img_meta are single-nested (i.e. Tensor + and List[dict]), and when ``resturn_loss=False``, img and img_meta + should be double nested (i.e. List[Tensor], List[List[dict]]), with + the outer list indicating test time augmentations. + """ + if return_loss: + return self.forward_train(img, img_metas, **kwargs) + else: + return self.forward_test(img, img_metas, **kwargs) + + def train_step(self, data_batch, optimizer, **kwargs): + """The iteration step during training. + + This method defines an iteration step during training, except for the + back propagation and optimizer updating, which are done in an optimizer + hook. Note that in some complicated cases or models, the whole process + including back propagation and optimizer updating is also defined in + this method, such as GAN. + + Args: + data (dict): The output of dataloader. + optimizer (:obj:`torch.optim.Optimizer` | dict): The optimizer of + runner is passed to ``train_step()``. This argument is unused + and reserved. + + Returns: + dict: It should contain at least 3 keys: ``loss``, ``log_vars``, + ``num_samples``. + ``loss`` is a tensor for back propagation, which can be a + weighted sum of multiple losses. + ``log_vars`` contains all the variables to be sent to the + logger. + ``num_samples`` indicates the batch size (when the model is + DDP, it means the batch size on each GPU), which is used for + averaging the logs. + """ + losses = self(**data_batch) + + # split losses and images + real_losses = {} + log_imgs = {} + for k, v in losses.items(): + if "img" in k: + log_imgs[k] = v + else: + real_losses[k] = v + + loss, log_vars = self._parse_losses(real_losses) + + outputs = dict(loss=loss, log_vars=log_vars, num_samples=len(data_batch["img_metas"]), log_imgs=log_imgs) + + return outputs + + def val_step(self, data_batch, **kwargs): + """The iteration step during validation. + + This method shares the same signature as :func:`train_step`, but used + during val epochs. Note that the evaluation after training epochs is + not implemented with this method, but an evaluation hook. + """ + output = self(**data_batch, **kwargs) + return output + + @staticmethod + def _parse_losses(losses): + import torch.distributed as dist + + """Parse the raw outputs (losses) of the network. + + Args: + losses (dict): Raw output of the network, which usually contain + losses and other necessary information. + + Returns: + tuple[Tensor, dict]: (loss, log_vars), loss is the loss tensor + which may be a weighted sum of all losses, log_vars contains + all the variables to be sent to the logger. + """ + log_vars = OrderedDict() + for loss_name, loss_value in losses.items(): + if isinstance(loss_value, torch.Tensor): + log_vars[loss_name] = loss_value.mean() + elif isinstance(loss_value, list): + log_vars[loss_name] = sum(_loss.mean() for _loss in loss_value) + else: + raise TypeError(f"{loss_name} is not a tensor or list of tensors") + + loss = sum(_value for _key, _value in log_vars.items() if "loss" in _key) + + log_vars["loss"] = loss + for loss_name, loss_value in log_vars.items(): + # reduce loss when distributed training + if dist.is_available() and dist.is_initialized(): + loss_value = loss_value.data.clone() + dist.all_reduce(loss_value.div_(dist.get_world_size())) + log_vars[loss_name] = loss_value.item() + + return loss, log_vars diff --git a/OpenMidnight/dinov2/hub/depth/ops.py b/OpenMidnight/dinov2/hub/depth/ops.py new file mode 100644 index 0000000000000000000000000000000000000000..15880ee0cb7652d4b41c489b927bf6a156b40e5e --- /dev/null +++ b/OpenMidnight/dinov2/hub/depth/ops.py @@ -0,0 +1,28 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import warnings + +import torch.nn.functional as F + + +def resize(input, size=None, scale_factor=None, mode="nearest", align_corners=None, warning=False): + if warning: + if size is not None and align_corners: + input_h, input_w = tuple(int(x) for x in input.shape[2:]) + output_h, output_w = tuple(int(x) for x in size) + if output_h > input_h or output_w > output_h: + if ( + (output_h > 1 and output_w > 1 and input_h > 1 and input_w > 1) + and (output_h - 1) % (input_h - 1) + and (output_w - 1) % (input_w - 1) + ): + warnings.warn( + f"When align_corners={align_corners}, " + "the output would more aligned if " + f"input size {(input_h, input_w)} is `x+1` and " + f"out size {(output_h, output_w)} is `nx+1`" + ) + return F.interpolate(input, size, scale_factor, mode, align_corners) diff --git a/OpenMidnight/dinov2/hub/depthers.py b/OpenMidnight/dinov2/hub/depthers.py new file mode 100644 index 0000000000000000000000000000000000000000..f88b7e9a41056594e3b3e66107feee98bffab820 --- /dev/null +++ b/OpenMidnight/dinov2/hub/depthers.py @@ -0,0 +1,246 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from enum import Enum +from functools import partial +from typing import Optional, Tuple, Union + +import torch + +from .backbones import _make_dinov2_model +from .depth import BNHead, DepthEncoderDecoder, DPTHead +from .utils import _DINOV2_BASE_URL, _make_dinov2_model_name, CenterPadding + + +class Weights(Enum): + NYU = "NYU" + KITTI = "KITTI" + + +def _get_depth_range(pretrained: bool, weights: Weights = Weights.NYU) -> Tuple[float, float]: + if not pretrained: # Default + return (0.001, 10.0) + + # Pretrained, set according to the training dataset for the provided weights + if weights == Weights.KITTI: + return (0.001, 80.0) + + if weights == Weights.NYU: + return (0.001, 10.0) + + return (0.001, 10.0) + + +def _make_dinov2_linear_depth_head( + *, + embed_dim: int, + layers: int, + min_depth: float, + max_depth: float, + **kwargs, +): + if layers not in (1, 4): + raise AssertionError(f"Unsupported number of layers: {layers}") + + if layers == 1: + in_index = [0] + else: + assert layers == 4 + in_index = [0, 1, 2, 3] + + return BNHead( + classify=True, + n_bins=256, + bins_strategy="UD", + norm_strategy="linear", + upsample=4, + in_channels=[embed_dim] * len(in_index), + in_index=in_index, + input_transform="resize_concat", + channels=embed_dim * len(in_index) * 2, + align_corners=False, + min_depth=0.001, + max_depth=80, + loss_decode=(), + ) + + +def _make_dinov2_linear_depther( + *, + arch_name: str = "vit_large", + layers: int = 4, + pretrained: bool = True, + weights: Union[Weights, str] = Weights.NYU, + depth_range: Optional[Tuple[float, float]] = None, + **kwargs, +): + if layers not in (1, 4): + raise AssertionError(f"Unsupported number of layers: {layers}") + if isinstance(weights, str): + try: + weights = Weights[weights] + except KeyError: + raise AssertionError(f"Unsupported weights: {weights}") + + if depth_range is None: + depth_range = _get_depth_range(pretrained, weights) + min_depth, max_depth = depth_range + + backbone = _make_dinov2_model(arch_name=arch_name, pretrained=pretrained, **kwargs) + + embed_dim = backbone.embed_dim + patch_size = backbone.patch_size + model_name = _make_dinov2_model_name(arch_name, patch_size) + linear_depth_head = _make_dinov2_linear_depth_head( + embed_dim=embed_dim, + layers=layers, + min_depth=min_depth, + max_depth=max_depth, + ) + + layer_count = { + "vit_small": 12, + "vit_base": 12, + "vit_large": 24, + "vit_giant2": 40, + }[arch_name] + + if layers == 4: + out_index = { + "vit_small": [2, 5, 8, 11], + "vit_base": [2, 5, 8, 11], + "vit_large": [4, 11, 17, 23], + "vit_giant2": [9, 19, 29, 39], + }[arch_name] + else: + assert layers == 1 + out_index = [layer_count - 1] + + model = DepthEncoderDecoder(backbone=backbone, decode_head=linear_depth_head) + model.backbone.forward = partial( + backbone.get_intermediate_layers, + n=out_index, + reshape=True, + return_class_token=True, + norm=False, + ) + model.backbone.register_forward_pre_hook(lambda _, x: CenterPadding(patch_size)(x[0])) + + if pretrained: + layers_str = str(layers) if layers == 4 else "" + weights_str = weights.value.lower() + url = _DINOV2_BASE_URL + f"/{model_name}/{model_name}_{weights_str}_linear{layers_str}_head.pth" + checkpoint = torch.hub.load_state_dict_from_url(url, map_location="cpu") + if "state_dict" in checkpoint: + state_dict = checkpoint["state_dict"] + model.load_state_dict(state_dict, strict=False) + + return model + + +def dinov2_vits14_ld(*, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_linear_depther( + arch_name="vit_small", layers=layers, pretrained=pretrained, weights=weights, **kwargs + ) + + +def dinov2_vitb14_ld(*, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_linear_depther( + arch_name="vit_base", layers=layers, pretrained=pretrained, weights=weights, **kwargs + ) + + +def dinov2_vitl14_ld(*, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_linear_depther( + arch_name="vit_large", layers=layers, pretrained=pretrained, weights=weights, **kwargs + ) + + +def dinov2_vitg14_ld(*, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_linear_depther( + arch_name="vit_giant2", layers=layers, ffn_layer="swiglufused", pretrained=pretrained, weights=weights, **kwargs + ) + + +def _make_dinov2_dpt_depth_head(*, embed_dim: int, min_depth: float, max_depth: float): + return DPTHead( + in_channels=[embed_dim] * 4, + channels=256, + embed_dims=embed_dim, + post_process_channels=[embed_dim // 2 ** (3 - i) for i in range(4)], + readout_type="project", + min_depth=min_depth, + max_depth=max_depth, + loss_decode=(), + ) + + +def _make_dinov2_dpt_depther( + *, + arch_name: str = "vit_large", + pretrained: bool = True, + weights: Union[Weights, str] = Weights.NYU, + depth_range: Optional[Tuple[float, float]] = None, + **kwargs, +): + if isinstance(weights, str): + try: + weights = Weights[weights] + except KeyError: + raise AssertionError(f"Unsupported weights: {weights}") + + if depth_range is None: + depth_range = _get_depth_range(pretrained, weights) + min_depth, max_depth = depth_range + + backbone = _make_dinov2_model(arch_name=arch_name, pretrained=pretrained, **kwargs) + + model_name = _make_dinov2_model_name(arch_name, backbone.patch_size) + dpt_depth_head = _make_dinov2_dpt_depth_head(embed_dim=backbone.embed_dim, min_depth=min_depth, max_depth=max_depth) + + out_index = { + "vit_small": [2, 5, 8, 11], + "vit_base": [2, 5, 8, 11], + "vit_large": [4, 11, 17, 23], + "vit_giant2": [9, 19, 29, 39], + }[arch_name] + + model = DepthEncoderDecoder(backbone=backbone, decode_head=dpt_depth_head) + model.backbone.forward = partial( + backbone.get_intermediate_layers, + n=out_index, + reshape=True, + return_class_token=True, + norm=False, + ) + model.backbone.register_forward_pre_hook(lambda _, x: CenterPadding(backbone.patch_size)(x[0])) + + if pretrained: + weights_str = weights.value.lower() + url = _DINOV2_BASE_URL + f"/{model_name}/{model_name}_{weights_str}_dpt_head.pth" + checkpoint = torch.hub.load_state_dict_from_url(url, map_location="cpu") + if "state_dict" in checkpoint: + state_dict = checkpoint["state_dict"] + model.load_state_dict(state_dict, strict=False) + + return model + + +def dinov2_vits14_dd(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_dpt_depther(arch_name="vit_small", pretrained=pretrained, weights=weights, **kwargs) + + +def dinov2_vitb14_dd(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_dpt_depther(arch_name="vit_base", pretrained=pretrained, weights=weights, **kwargs) + + +def dinov2_vitl14_dd(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_dpt_depther(arch_name="vit_large", pretrained=pretrained, weights=weights, **kwargs) + + +def dinov2_vitg14_dd(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs): + return _make_dinov2_dpt_depther( + arch_name="vit_giant2", ffn_layer="swiglufused", pretrained=pretrained, weights=weights, **kwargs + ) diff --git a/OpenMidnight/dinov2/hub/dinotxt.py b/OpenMidnight/dinov2/hub/dinotxt.py new file mode 100644 index 0000000000000000000000000000000000000000..1a5f159cd3b26b2cb77664f5d85a44a93bb32522 --- /dev/null +++ b/OpenMidnight/dinov2/hub/dinotxt.py @@ -0,0 +1,77 @@ +import torch +import math + +from .backbones import dinov2_vitl14_reg +from .utils import _DINOV2_BASE_URL + + +def dinov2_vitl14_reg4_dinotxt_tet1280d20h24l(): + from .text.dinotxt_model import DinoTxtConfig, DinoTxt + from .text.dinov2_wrapper import DINOv2Wrapper + from .text.text_transformer import TextTransformer + + dinotxt_config = DinoTxtConfig( + embed_dim=2048, + vision_model_freeze_backbone=True, + vision_model_train_img_size=224, + vision_model_use_class_token=True, + vision_model_use_patch_tokens=True, + vision_model_num_head_blocks=2, + vision_model_head_blocks_drop_path=0.3, + vision_model_use_linear_projection=False, + vision_model_patch_tokens_pooler_type="mean", + vision_model_patch_token_layer=1, # which layer to take patch tokens from + # 1 - last layer, 2 - second last layer, etc. + text_model_freeze_backbone=False, + text_model_num_head_blocks=0, + text_model_head_blocks_is_causal=False, + text_model_head_blocks_drop_prob=0.0, + text_model_tokens_pooler_type="argmax", + text_model_use_linear_projection=True, + init_logit_scale=math.log(1 / 0.07), + init_logit_bias=None, + freeze_logit_scale=False, + ) + vision_backbone = DINOv2Wrapper(dinov2_vitl14_reg()) + text_backbone = TextTransformer( + context_length=77, + vocab_size=49408, + dim=1280, + num_heads=20, + num_layers=24, + ffn_ratio=4, + is_causal=True, + ls_init_value=None, + dropout_prob=0.0, + ) + model = DinoTxt(dinotxt_config, vision_backbone, text_backbone) + model.init_weights() + model.visual_model.backbone = vision_backbone + model.eval() + + visual_model_head_state_dict = torch.hub.load_state_dict_from_url( + _DINOV2_BASE_URL + "/dinov2_vitl14/dinov2_vitl14_reg4_dinotxt_tet1280d20h24l_vision_head.pth", + map_location="cpu", + ) + text_model_state_dict = torch.hub.load_state_dict_from_url( + _DINOV2_BASE_URL + "/dinov2_vitl14/dinov2_vitl14_reg4_dinotxt_tet1280d20h24l_text_encoder.pth", + map_location="cpu", + ) + model.visual_model.head.load_state_dict(visual_model_head_state_dict, strict=True) + model.text_model.load_state_dict(text_model_state_dict, strict=True) + return model + + +def get_tokenizer(): + from .text.tokenizer import Tokenizer + import requests + from io import BytesIO + + url = _DINOV2_BASE_URL + "/thirdparty/bpe_simple_vocab_16e6.txt.gz" + try: + response = requests.get(url) + response.raise_for_status() + file_buf = BytesIO(response.content) + return Tokenizer(vocab_path=file_buf) + except Exception as e: + raise FileNotFoundError(f"Failed to download file from url {url} with error last: {e}") diff --git a/OpenMidnight/dinov2/hub/text/dinotxt_model.py b/OpenMidnight/dinov2/hub/text/dinotxt_model.py new file mode 100644 index 0000000000000000000000000000000000000000..38d3ccc0ef887f05151202d7f42437601488d446 --- /dev/null +++ b/OpenMidnight/dinov2/hub/text/dinotxt_model.py @@ -0,0 +1,130 @@ +import math +from dataclasses import dataclass +from typing import Optional, Tuple + +import torch +import torch.nn.functional as F +from torch import nn, Tensor + +from .vision_tower import VisionTower +from .text_tower import TextTower + + +@dataclass +class DinoTxtConfig: + embed_dim: int + vision_model_freeze_backbone: bool = True + vision_model_train_img_size: int = 224 + vision_model_use_class_token: bool = True + vision_model_use_patch_tokens: bool = False + vision_model_num_head_blocks: int = 0 + vision_model_head_blocks_drop_path: float = 0.3 + vision_model_use_linear_projection: bool = False + vision_model_patch_tokens_pooler_type: str = "mean" + vision_model_patch_token_layer: int = 1 # which layer to take patch tokens from + # 1 - last layer, 2 - second last layer, etc. + text_model_freeze_backbone: bool = False + text_model_num_head_blocks: int = 0 + text_model_head_blocks_is_causal: bool = False + text_model_head_blocks_drop_prob: float = 0.0 + text_model_tokens_pooler_type: str = "first" + text_model_use_linear_projection: bool = False + init_logit_scale: float = math.log(1 / 0.07) + init_logit_bias: Optional[float] = None + freeze_logit_scale: bool = False + + +class DinoTxt(nn.Module): + def __init__( + self, + model_config: DinoTxtConfig, + vision_backbone: nn.Module, + text_backbone: nn.Module, + ): + super().__init__() + self.model_config = model_config + self.visual_model = VisionTower( + vision_backbone, + model_config.vision_model_freeze_backbone, + model_config.embed_dim, + model_config.vision_model_num_head_blocks, + model_config.vision_model_head_blocks_drop_path, + model_config.vision_model_use_class_token, + model_config.vision_model_use_patch_tokens, + model_config.vision_model_patch_token_layer, + model_config.vision_model_patch_tokens_pooler_type, + model_config.vision_model_use_linear_projection, + ) + self.text_model = TextTower( + text_backbone, + model_config.text_model_freeze_backbone, + model_config.embed_dim, + model_config.text_model_num_head_blocks, + model_config.text_model_head_blocks_is_causal, + model_config.text_model_head_blocks_drop_prob, + model_config.text_model_tokens_pooler_type, + model_config.text_model_use_linear_projection, + ) + self.logit_scale = nn.Parameter(torch.ones(1) * model_config.init_logit_scale) + if model_config.freeze_logit_scale: + self.logit_scale.requires_grad = False + + def init_weights(self): + self.visual_model.init_weights() + self.text_model.init_weights() + + def get_visual_class_and_patch_tokens(self, image: Tensor) -> Tuple[Tensor, Tensor]: + return self.visual_model.get_class_and_patch_tokens(image) + + def encode_image( + self, + image: Tensor, + normalize: bool = False, + ) -> Tensor: + """ + Encode an image into a vector descriptor containing both global and local features. + + Args: + image (Tensor): Tensor of shape `(batch_size, rgb, height, width)`, normalized using ImageNet mean and std. + normalize (bool, optional): Whether to normalize the output vectors. Default is False. + Image features should always be normalized before comparing them with text features: + Returns: + Tensor: Tensor of shape `(batch_size, embed_dim)` containing the image features. + The first half of the vector corresponds to the global features (class token), + and the second half corresponds to the pooled patch features. + """ + features = self.visual_model(image) + return F.normalize(features, dim=-1) if normalize else features + + def encode_text(self, text: Tensor, normalize: bool = False) -> Tensor: + """ + Encode a text input into a vector descriptor. + + Args: + text (Tensor): Tensor of shape `(batch_size, seq_len)` containing token indices. + normalize (bool, optional): Whether to normalize the output vectors. Default is False. + Text features should be normalized before comparing them with image features: + Returns: + Tensor: Tensor of shape `(batch_size, embed_dim)` containing the text features. + As a consequence of the training procedure, assume that the first half of the tensor corresponds + to global image features and the second half to pooled patch features. + """ + features = self.text_model(text) + return F.normalize(features, dim=-1) if normalize else features + + def get_logits(self, image: Tensor, text: Tensor) -> Tuple[Tensor, Tensor]: + text_features = self.encode_text(text, normalize=True) + image_features = self.encode_image(image, normalize=True) + image_logits = self.logit_scale.exp() * image_features @ text_features.T + text_logits = image_logits.T + return image_logits, text_logits + + def forward( + self, + image: Tensor, + text: Tensor, + ) -> Tuple[Tensor, Tensor, Tensor]: + + text_features = self.encode_text(text, normalize=True) + image_features = self.encode_image(image, normalize=True) + return image_features, text_features, self.logit_scale.exp() diff --git a/OpenMidnight/dinov2/hub/text/dinov2_wrapper.py b/OpenMidnight/dinov2/hub/text/dinov2_wrapper.py new file mode 100644 index 0000000000000000000000000000000000000000..31db29696c8e0b0884020a2612998c3870dfe164 --- /dev/null +++ b/OpenMidnight/dinov2/hub/text/dinov2_wrapper.py @@ -0,0 +1,59 @@ +from typing import Sequence + +import torch + + +class DINOv2Wrapper(torch.nn.Module): + def __init__(self, model): + super().__init__() + self.model = model + self.embed_dim = model.embed_dim + self.num_heads = model.num_heads + self.num_register_tokens = model.num_register_tokens + + # Same as the original forward, but assert is_training and rename x_norm_regtokens -> x_storage_tokens + def forward(self, img, is_training: bool): + assert is_training + H, W = img.shape[-2:] + P = self.model.patch_size + x_dict = self.model(img, is_training=True) + x_dict["h"] = h = H // P + x_dict["w"] = w = W // P + assert x_dict["x_norm_patchtokens"].shape[-2] == h * w + return x_dict + + # Same as the original get_intermediate_layers, but allow returining extra tokens (registers) + def get_intermediate_layers( + self, + x: torch.Tensor, + n: int | Sequence[int] = 1, # Layers or n last layers to take + reshape: bool = False, + return_class_token: bool = False, + return_register_tokens: bool = False, + norm=True, + ) -> tuple[torch.Tensor] | tuple[tuple[torch.Tensor, ...], ...]: + if self.model.chunked_blocks: + outputs = self.model._get_intermediate_layers_chunked(x, n) + else: + outputs = self.model._get_intermediate_layers_not_chunked(x, n) + if norm: + outputs = [self.model.norm(out) for out in outputs] + class_tokens = [out[:, 0] for out in outputs] + register_tokens = [out[:, 1 : 1 + self.model.num_register_tokens] for out in outputs] + outputs = [out[:, 1 + self.model.num_register_tokens :] for out in outputs] + if reshape: + B, _, h, w = x.shape + outputs = [ + out.reshape(B, h // self.model.patch_size, w // self.model.patch_size, -1) + .permute(0, 3, 1, 2) + .contiguous() + for out in outputs + ] + + if not return_class_token and not return_register_tokens: + return tuple(outputs) + if return_class_token and not return_register_tokens: + return tuple(zip(outputs, class_tokens)) + if not return_class_token and return_register_tokens: + return tuple(zip(outputs, register_tokens)) + return tuple(zip(outputs, class_tokens, register_tokens)) diff --git a/OpenMidnight/dinov2/hub/text/text_tower.py b/OpenMidnight/dinov2/hub/text/text_tower.py new file mode 100644 index 0000000000000000000000000000000000000000..15297722e9bf1fa57ac8c44a40fe016b6c3efe17 --- /dev/null +++ b/OpenMidnight/dinov2/hub/text/text_tower.py @@ -0,0 +1,99 @@ +import torch +from torch import nn, Tensor + +from dinov2.layers import ( + CausalAttentionBlock, +) + + +class TextHead(nn.Module): + def __init__( + self, + input_dim: int, + embed_dim: int, + num_heads: int, + num_blocks: int, + block_drop_prob: float, + is_causal: bool, + use_linear_projection: bool, + ): + super().__init__() + block_list = [nn.Identity()] + self.ln_final = nn.Identity() + if num_blocks > 0: + block_list = [ + CausalAttentionBlock( + dim=input_dim, + num_heads=num_heads, + is_causal=is_causal, + dropout_prob=block_drop_prob, + ) + for _ in range(num_blocks) + ] + self.ln_final = nn.LayerNorm(input_dim) + self.block_list = nn.ModuleList(block_list) + self.num_blocks = num_blocks + self.linear_projection = nn.Identity() + if input_dim != embed_dim or use_linear_projection: + self.linear_projection = nn.Linear(input_dim, embed_dim, bias=False) + + def init_weights(self): + if self.num_blocks > 0: + for i in range(self.num_blocks): + self.block_list[i].init_weights() + self.ln_final.reset_parameters() + if isinstance(self.linear_projection, nn.Linear): + nn.init.normal_(self.linear_projection.weight, std=self.linear_projection.in_features**-0.5) + + def forward(self, text_tokens: Tensor) -> Tensor: + for block in self.block_list: + text_tokens = block(text_tokens) + text_tokens = self.ln_final(text_tokens) + return self.linear_projection(text_tokens) + + +class TextTower(nn.Module): + def __init__( + self, + backbone: nn.Module, + freeze_backbone: bool, + embed_dim: int, + num_head_blocks: int, + head_blocks_is_causal: bool, + head_blocks_block_drop_prob: float, + tokens_pooler_type: str, + use_linear_projection: bool, + ): + super().__init__() + self.backbone = backbone + self.freeze_backbone = freeze_backbone + backbone_out_dim = backbone.embed_dim + self.backbone = backbone + self.head = TextHead( + backbone_out_dim, + embed_dim, + self.backbone.num_heads, + num_head_blocks, + head_blocks_block_drop_prob, + head_blocks_is_causal, + use_linear_projection, + ) + self.tokens_pooler_type = tokens_pooler_type + + def init_weights(self): + self.backbone.init_weights() + self.head.init_weights() + + def forward(self, token_indices: Tensor) -> Tensor: + text_tokens = self.backbone(token_indices) + text_tokens = self.head(text_tokens) + if self.tokens_pooler_type == "first": + features = text_tokens[:, 0] + elif self.tokens_pooler_type == "last": + features = text_tokens[:, -1] + elif self.tokens_pooler_type == "argmax": + assert token_indices is not None + features = text_tokens[torch.arange(text_tokens.shape[0]), token_indices.argmax(dim=-1)] + else: + raise ValueError(f"Unknown text tokens pooler type: {self.pooler_type}") + return features diff --git a/OpenMidnight/dinov2/hub/text/text_transformer.py b/OpenMidnight/dinov2/hub/text/text_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..be838de7a8a5b5421b88da5394811330414fc100 --- /dev/null +++ b/OpenMidnight/dinov2/hub/text/text_transformer.py @@ -0,0 +1,67 @@ +from typing import Callable, Optional, Tuple + +import torch +from torch import nn, Tensor + + +from dinov2.layers import CausalAttentionBlock + + +class TextTransformer(nn.Module): + def __init__( + self, + context_length: int, + vocab_size: int, + dim: int, + num_heads: int, + num_layers: int, + ffn_ratio: float, + is_causal: bool, + ls_init_value: Optional[float] = None, + act_layer: Callable = nn.GELU, + norm_layer: Callable = nn.LayerNorm, + dropout_prob: float = 0.0, + ): + super().__init__() + self.vocab_size = vocab_size + self.embed_dim = dim + self.num_heads = num_heads + + self.token_embedding = nn.Embedding(vocab_size, dim) + self.positional_embedding = nn.Parameter(torch.empty(context_length, dim)) + self.dropout = nn.Dropout(dropout_prob) + self.num_layers = num_layers + block_list = [ + CausalAttentionBlock( + dim=dim, + num_heads=num_heads, + ffn_ratio=ffn_ratio, + ls_init_value=ls_init_value, + is_causal=is_causal, + act_layer=act_layer, + norm_layer=norm_layer, + dropout_prob=dropout_prob, + ) + for _ in range(num_layers) + ] + self.blocks = nn.ModuleList(block_list) + self.ln_final = norm_layer(dim) + + def init_weights(self): + nn.init.normal_(self.token_embedding.weight, std=0.02) + nn.init.normal_(self.positional_embedding, std=0.01) + init_attn_std = self.embed_dim**-0.5 + init_proj_std = (self.embed_dim**-0.5) * ((2 * self.num_layers) ** -0.5) + init_fc_std = (2 * self.embed_dim) ** -0.5 + for block in self.blocks: + block.init_weights(init_attn_std, init_proj_std, init_fc_std) + self.ln_final.reset_parameters() + + def forward(self, token_indices: Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + _, N = token_indices.size() + x = self.token_embedding(token_indices) + self.positional_embedding[:N] + x = self.dropout(x) + for block in self.blocks: + x = block(x) + x = self.ln_final(x) + return x diff --git a/OpenMidnight/dinov2/hub/text/tokenizer.py b/OpenMidnight/dinov2/hub/text/tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..5a75026fefafa389e46b9b7c9a7ad2c32fca18a2 --- /dev/null +++ b/OpenMidnight/dinov2/hub/text/tokenizer.py @@ -0,0 +1,40 @@ +import torch +from typing import List, Union + + +from dinov2.thirdparty.CLIP.clip.simple_tokenizer import SimpleTokenizer + + +class Tokenizer(SimpleTokenizer): + def __init__(self, vocab_path: str): + SimpleTokenizer.__init__(self, bpe_path=vocab_path) + + def tokenize(self, texts: Union[str, List[str]], context_length: int = 77) -> torch.LongTensor: + """ + Returns the tokenized representation of given input string(s) + + Parameters + ---------- + texts : Union[str, List[str]] + An input string or a list of input strings to tokenize + context_length : int + The context length to use; all CLIP models use 77 as the context length + + Returns + ------- + A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length] + """ + if isinstance(texts, str): + texts = [texts] + sot_token = self.encoder["<|startoftext|>"] + eot_token = self.encoder["<|endoftext|>"] + all_tokens = [[sot_token] + self.encode(text) + [eot_token] for text in texts] + result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + + for i, tokens in enumerate(all_tokens): + if len(tokens) > context_length: + tokens = tokens[:context_length] # Truncate + tokens[-1] = eot_token + result[i, : len(tokens)] = torch.tensor(tokens) + + return result diff --git a/OpenMidnight/dinov2/hub/text/vision_tower.py b/OpenMidnight/dinov2/hub/text/vision_tower.py new file mode 100644 index 0000000000000000000000000000000000000000..27fc310c8a5f6ee15f6653a6b7bbe5c28f9c0af0 --- /dev/null +++ b/OpenMidnight/dinov2/hub/text/vision_tower.py @@ -0,0 +1,174 @@ +from functools import partial +from typing import Callable, Tuple + +import torch +from torch import nn, Tensor + +from dinov2.layers import ( + LayerScale, + NestedTensorBlock as AttentionBlock, + SwiGLUFFNAligned as SwiGLUFFN, +) + + +def init_weights_vit_timm(module: nn.Module, name: str = ""): + """ViT weight initialization, original timm impl (for reproducibility)""" + if isinstance(module, nn.Linear): + nn.init.trunc_normal_(module.weight, std=0.02) + if module.bias is not None: + nn.init.zeros_(module.bias) + if isinstance(module, nn.LayerNorm): + module.reset_parameters() + if isinstance(module, LayerScale): + module.reset_parameters() + if isinstance(module, nn.Conv2d): + module.reset_parameters() + + +def named_apply(fn: Callable, module: nn.Module, name="", depth_first=True, include_root=False) -> nn.Module: + if not depth_first and include_root: + fn(module=module, name=name) + for child_name, child_module in module.named_children(): + child_name = ".".join((name, child_name)) if name else child_name + named_apply( + fn=fn, + module=child_module, + name=child_name, + depth_first=depth_first, + include_root=True, + ) + if depth_first and include_root: + fn(module=module, name=name) + return module + + +class VisionHead(nn.Module): + def __init__( + self, + input_dim: int, + embed_dim: int, + num_heads: int, + num_blocks: int, + blocks_drop_path: float, + use_class_token: bool, + use_patch_tokens: bool, + use_linear_projection: bool, + ): + super().__init__() + block_list = [nn.Identity()] + self.ln_final = nn.Identity() + if num_blocks > 0: + block_list = [ + AttentionBlock( + input_dim, + num_heads, + ffn_layer=partial(SwiGLUFFN, align_to=64), + init_values=1e-5, + drop_path=blocks_drop_path, + ) + for _ in range(num_blocks) + ] + self.ln_final = nn.LayerNorm(input_dim) + self.block_list = nn.ModuleList(block_list) + self.num_blocks = num_blocks + multiplier = 2 if use_class_token and use_patch_tokens else 1 + self.linear_projection = nn.Identity() + if multiplier * input_dim != embed_dim or use_linear_projection: + assert embed_dim % multiplier == 0, f"Expects {embed_dim} to be divisible by {multiplier}" + self.linear_projection = nn.Linear(input_dim, embed_dim // multiplier, bias=False) + + def init_weights(self): + if self.num_blocks > 0: + for i in range(self.num_blocks): + block = self.block_list[i] + named_apply(init_weights_vit_timm, block) + self.ln_final.reset_parameters() + if isinstance(self.linear_projection, nn.Linear): + nn.init.normal_(self.linear_projection.weight, std=self.linear_projection.in_features**-0.5) + + def forward(self, image_tokens: Tensor) -> Tensor: + for block in self.block_list: + image_tokens = block(image_tokens) + image_tokens = self.ln_final(image_tokens) + return self.linear_projection(image_tokens) + + +class VisionTower(nn.Module): + def __init__( + self, + backbone: nn.Module, + freeze_backbone: bool, + embed_dim: int, + num_head_blocks: int, + head_blocks_block_drop_path: float, + use_class_token: bool, + use_patch_tokens: bool, + patch_token_layer: int, + patch_tokens_pooler_type: str, + use_linear_projection: bool, + ): + super().__init__() + self.backbone = backbone + self.freeze_backbone = freeze_backbone + self.use_class_token = use_class_token + self.use_patch_tokens = use_patch_tokens + self.patch_token_layer = patch_token_layer + self.patch_tokens_pooler_type = patch_tokens_pooler_type + self.num_register_tokens = 0 + if hasattr(self.backbone, "num_register_tokens"): + self.num_register_tokens = self.backbone.num_register_tokens + elif hasattr(self.backbone, "n_storage_tokens"): + self.num_register_tokens = self.backbone.n_storage_tokens + backbone_out_dim = self.backbone.embed_dim + self.head = VisionHead( + backbone_out_dim, + embed_dim, + self.backbone.num_heads, + num_head_blocks, + head_blocks_block_drop_path, + use_class_token, + use_patch_tokens, + use_linear_projection, + ) + + def init_weights(self): + if not self.freeze_backbone: + self.backbone.init_weights() + self.head.init_weights() + + def get_backbone_features(self, images: Tensor) -> Tuple[Tensor, Tensor, Tensor]: + tokens = self.backbone.get_intermediate_layers( + images, + n=self.patch_token_layer, + return_class_token=True, + return_register_tokens=True, + ) + class_token = tokens[-1][1] + patch_tokens = tokens[0][0] + register_tokens = tokens[0][2] + return class_token, patch_tokens, register_tokens + + def get_class_and_patch_tokens(self, images: Tensor) -> Tuple[Tensor, Tensor]: + class_token, patch_tokens, register_tokens = self.get_backbone_features(images) + image_tokens = self.head(torch.cat([class_token.unsqueeze(1), register_tokens, patch_tokens], dim=1)) + class_token, patch_tokens = image_tokens[:, 0], image_tokens[:, self.num_register_tokens + 1 :] + return class_token, patch_tokens + + def forward(self, images: Tensor) -> Tensor: + class_token, patch_tokens = self.get_class_and_patch_tokens(images) + features = [] + if self.use_class_token: + features.append(class_token) + if self.use_patch_tokens: + if self.patch_tokens_pooler_type == "mean": + features.append(torch.mean(patch_tokens, dim=1)) + elif self.patch_tokens_pooler_type == "max": + features.append(torch.max(patch_tokens, dim=1).values) + elif self.patch_tokens_pooler_type == "gem": + power = 3 + eps = 1e-6 + patch_tokens_power = patch_tokens.clamp(min=eps).pow(power) + features.append(torch.mean(patch_tokens_power, dim=1).pow(1 / power)) + else: + raise ValueError(f"Unknown patch tokens pooler type: {self.patch_tokens_pooler_type}") + return torch.cat(features, dim=-1) diff --git a/OpenMidnight/dinov2/hub/utils.py b/OpenMidnight/dinov2/hub/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..9c6641404093652d5a2f19b4cf283d976ec39e64 --- /dev/null +++ b/OpenMidnight/dinov2/hub/utils.py @@ -0,0 +1,39 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import itertools +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +_DINOV2_BASE_URL = "https://dl.fbaipublicfiles.com/dinov2" + + +def _make_dinov2_model_name(arch_name: str, patch_size: int, num_register_tokens: int = 0) -> str: + compact_arch_name = arch_name.replace("_", "")[:4] + registers_suffix = f"_reg{num_register_tokens}" if num_register_tokens else "" + return f"dinov2_{compact_arch_name}{patch_size}{registers_suffix}" + + +class CenterPadding(nn.Module): + def __init__(self, multiple): + super().__init__() + self.multiple = multiple + + def _get_pad(self, size): + new_size = math.ceil(size / self.multiple) * self.multiple + pad_size = new_size - size + pad_size_left = pad_size // 2 + pad_size_right = pad_size - pad_size_left + return pad_size_left, pad_size_right + + @torch.inference_mode() + def forward(self, x): + pads = list(itertools.chain.from_iterable(self._get_pad(m) for m in x.shape[:1:-1])) + output = F.pad(x, pads) + return output diff --git a/OpenMidnight/dinov2/hub/xray_dino/backbones.py b/OpenMidnight/dinov2/hub/xray_dino/backbones.py new file mode 100644 index 0000000000000000000000000000000000000000..8bf01819f742aead42804729503be2150e2f7f34 --- /dev/null +++ b/OpenMidnight/dinov2/hub/xray_dino/backbones.py @@ -0,0 +1,28 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the licence +# found in the LICENSE_XRAY_DINO_MODEL file in the root directory of this source tree. + +from typing import Union + +from ..backbones import Weights, _make_dinov2_model + + +def xray_dino_vitl16(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.XRAY_DINO, **kwargs): + """ + XRay-DINO ViT-L/16 model (optionally) pretrained on the XRay-DINO dataset. + """ + return _make_dinov2_model( + arch_name="vit_large", + patch_size=16, + img_size=512, + num_register_tokens=0, + interpolate_antialias=False, + interpolate_offset=0.1, + block_chunks=4, + pretrained=pretrained, + weights=weights, + hash="ad31c2b0", + check_hash=True, + **kwargs, + ) \ No newline at end of file diff --git a/OpenMidnight/dinov2/layers/__init__.py b/OpenMidnight/dinov2/layers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d640d145fbfb8993d6e7ceec4eb22b5b0a3e62fa --- /dev/null +++ b/OpenMidnight/dinov2/layers/__init__.py @@ -0,0 +1,12 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .dino_head import DINOHead +from .layer_scale import LayerScale +from .mlp import Mlp +from .patch_embed import PatchEmbed +from .swiglu_ffn import SwiGLUFFN, SwiGLUFFNFused, SwiGLUFFNAligned +from .block import NestedTensorBlock, CausalAttentionBlock +from .attention import Attention, MemEffAttention diff --git a/OpenMidnight/dinov2/layers/attention.py b/OpenMidnight/dinov2/layers/attention.py new file mode 100644 index 0000000000000000000000000000000000000000..f1d3dabf14ffbd5eb68c3c16edc56d0da19b1265 --- /dev/null +++ b/OpenMidnight/dinov2/layers/attention.py @@ -0,0 +1,99 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/models/vision_transformer.py + +import logging +import os +import warnings + +import torch +from torch import nn, Tensor + + +logger = logging.getLogger("dinov2") + + +XFORMERS_ENABLED = os.environ.get("XFORMERS_DISABLED") is None +try: + if XFORMERS_ENABLED: + from xformers.ops import memory_efficient_attention, unbind + + XFORMERS_AVAILABLE = True + warnings.warn("xFormers is available (Attention)") + else: + warnings.warn("xFormers is disabled (Attention)") + raise ImportError +except ImportError: + XFORMERS_AVAILABLE = False + warnings.warn("xFormers is not available (Attention)") + + +class Attention(nn.Module): + def __init__( + self, + dim: int, + num_heads: int = 8, + qkv_bias: bool = False, + proj_bias: bool = True, + attn_drop: float = 0.0, + proj_drop: float = 0.0, + ) -> None: + super().__init__() + self.dim = dim + self.num_heads = num_heads + head_dim = dim // num_heads + self.scale = head_dim**-0.5 + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = attn_drop + self.proj = nn.Linear(dim, dim, bias=proj_bias) + self.proj_drop = nn.Dropout(proj_drop) + + def init_weights( + self, init_attn_std: float | None = None, init_proj_std: float | None = None, factor: float = 1.0 + ) -> None: + init_attn_std = init_attn_std or (self.dim**-0.5) + init_proj_std = init_proj_std or init_attn_std * factor + nn.init.normal_(self.qkv.weight, std=init_attn_std) + nn.init.normal_(self.proj.weight, std=init_proj_std) + if self.qkv.bias is not None: + nn.init.zeros_(self.qkv.bias) + if self.proj.bias is not None: + nn.init.zeros_(self.proj.bias) + + def forward(self, x: Tensor, is_causal: bool = False) -> Tensor: + B, N, C = x.shape + qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads) + q, k, v = torch.unbind(qkv, 2) + q, k, v = [t.transpose(1, 2) for t in [q, k, v]] + x = nn.functional.scaled_dot_product_attention( + q, k, v, attn_mask=None, dropout_p=self.attn_drop if self.training else 0, is_causal=is_causal + ) + x = x.transpose(1, 2).contiguous().view(B, N, C) + x = self.proj_drop(self.proj(x)) + return x + + +class MemEffAttention(Attention): + def forward(self, x: Tensor, attn_bias=None) -> Tensor: + if not XFORMERS_AVAILABLE: + if attn_bias is not None: + raise AssertionError("xFormers is required for using nested tensors") + return super().forward(x) + + B, N, C = x.shape + qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads) + + q, k, v = unbind(qkv, 2) + + x = memory_efficient_attention(q, k, v, attn_bias=attn_bias) + x = x.reshape([B, N, C]) + + x = self.proj(x) + x = self.proj_drop(x) + return x diff --git a/OpenMidnight/dinov2/layers/block.py b/OpenMidnight/dinov2/layers/block.py new file mode 100644 index 0000000000000000000000000000000000000000..7e83b71ccb428ca099d2d1d49933dc837faeecfa --- /dev/null +++ b/OpenMidnight/dinov2/layers/block.py @@ -0,0 +1,316 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/patch_embed.py + +import logging +import os +from typing import Callable, List, Any, Tuple, Dict, Optional +import warnings + +import torch +from torch import nn, Tensor + +from .attention import Attention, MemEffAttention +from .drop_path import DropPath +from .layer_scale import LayerScale +from .mlp import Mlp + + +logger = logging.getLogger("dinov2") + + +XFORMERS_ENABLED = os.environ.get("XFORMERS_DISABLED") is None +try: + if XFORMERS_ENABLED: + from xformers.ops import fmha, scaled_index_add, index_select_cat + + XFORMERS_AVAILABLE = True + warnings.warn("xFormers is available (Block)") + else: + warnings.warn("xFormers is disabled (Block)") + raise ImportError +except ImportError: + XFORMERS_AVAILABLE = False + + warnings.warn("xFormers is not available (Block)") + + +class Block(nn.Module): + def __init__( + self, + dim: int, + num_heads: int, + mlp_ratio: float = 4.0, + qkv_bias: bool = False, + proj_bias: bool = True, + ffn_bias: bool = True, + drop: float = 0.0, + attn_drop: float = 0.0, + init_values=None, + drop_path: float = 0.0, + act_layer: Callable[..., nn.Module] = nn.GELU, + norm_layer: Callable[..., nn.Module] = nn.LayerNorm, + attn_class: Callable[..., nn.Module] = Attention, + ffn_layer: Callable[..., nn.Module] = Mlp, + ) -> None: + super().__init__() + # print(f"biases: qkv: {qkv_bias}, proj: {proj_bias}, ffn: {ffn_bias}") + self.norm1 = norm_layer(dim) + self.attn = attn_class( + dim, + num_heads=num_heads, + qkv_bias=qkv_bias, + proj_bias=proj_bias, + attn_drop=attn_drop, + proj_drop=drop, + ) + self.ls1 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity() + self.drop_path1 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + + self.norm2 = norm_layer(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = ffn_layer( + in_features=dim, + hidden_features=mlp_hidden_dim, + act_layer=act_layer, + drop=drop, + bias=ffn_bias, + ) + self.ls2 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity() + self.drop_path2 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + + self.sample_drop_ratio = drop_path + + def forward(self, x: Tensor) -> Tensor: + def attn_residual_func(x: Tensor) -> Tensor: + return self.ls1(self.attn(self.norm1(x))) + + def ffn_residual_func(x: Tensor) -> Tensor: + return self.ls2(self.mlp(self.norm2(x))) + + if self.training and self.sample_drop_ratio > 0.1: + # the overhead is compensated only for a drop path rate larger than 0.1 + x = drop_add_residual_stochastic_depth( + x, + residual_func=attn_residual_func, + sample_drop_ratio=self.sample_drop_ratio, + ) + x = drop_add_residual_stochastic_depth( + x, + residual_func=ffn_residual_func, + sample_drop_ratio=self.sample_drop_ratio, + ) + elif self.training and self.sample_drop_ratio > 0.0: + x = x + self.drop_path1(attn_residual_func(x)) + x = x + self.drop_path1(ffn_residual_func(x)) # FIXME: drop_path2 + else: + x = x + attn_residual_func(x) + x = x + ffn_residual_func(x) + return x + + +class CausalAttentionBlock(nn.Module): + def __init__( + self, + dim: int, + num_heads: int, + ffn_ratio: float = 4.0, + ls_init_value: Optional[float] = None, + is_causal: bool = True, + act_layer: Callable = nn.GELU, + norm_layer: Callable = nn.LayerNorm, + dropout_prob: float = 0.0, + ): + super().__init__() + + self.dim = dim + self.is_causal = is_causal + self.ls1 = LayerScale(dim, init_values=ls_init_value) if ls_init_value else nn.Identity() + self.attention_norm = norm_layer(dim) + self.attention = Attention(dim, num_heads, attn_drop=dropout_prob, proj_drop=dropout_prob) + + self.ffn_norm = norm_layer(dim) + ffn_hidden_dim = int(dim * ffn_ratio) + self.feed_forward = Mlp( + in_features=dim, + hidden_features=ffn_hidden_dim, + drop=dropout_prob, + act_layer=act_layer, + ) + + self.ls2 = LayerScale(dim, init_values=ls_init_value) if ls_init_value else nn.Identity() + + def init_weights( + self, + init_attn_std: float | None = None, + init_proj_std: float | None = None, + init_fc_std: float | None = None, + factor: float = 1.0, + ) -> None: + init_attn_std = init_attn_std or (self.dim**-0.5) + init_proj_std = init_proj_std or init_attn_std * factor + init_fc_std = init_fc_std or (2 * self.dim) ** -0.5 + self.attention.init_weights(init_attn_std, init_proj_std) + self.attention_norm.reset_parameters() + nn.init.normal_(self.feed_forward.fc1.weight, std=init_fc_std) + nn.init.normal_(self.feed_forward.fc2.weight, std=init_proj_std) + self.ffn_norm.reset_parameters() + + def forward( + self, + x: torch.Tensor, + ): + x_attn = x + self.ls1(self.attention(self.attention_norm(x), self.is_causal)) + x_ffn = x_attn + self.ls2(self.feed_forward(self.ffn_norm(x_attn))) + return x_ffn + + +def drop_add_residual_stochastic_depth( + x: Tensor, + residual_func: Callable[[Tensor], Tensor], + sample_drop_ratio: float = 0.0, +) -> Tensor: + # 1) extract subset using permutation + b, n, d = x.shape + sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1) + brange = (torch.randperm(b, device=x.device))[:sample_subset_size] + x_subset = x[brange] + + # 2) apply residual_func to get residual + residual = residual_func(x_subset) + + x_flat = x.flatten(1) + residual = residual.flatten(1) + + residual_scale_factor = b / sample_subset_size + + # 3) add the residual + x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor) + return x_plus_residual.view_as(x) + + +def get_branges_scales(x, sample_drop_ratio=0.0): + b, n, d = x.shape + sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1) + brange = (torch.randperm(b, device=x.device))[:sample_subset_size] + residual_scale_factor = b / sample_subset_size + return brange, residual_scale_factor + + +def add_residual(x, brange, residual, residual_scale_factor, scaling_vector=None): + if scaling_vector is None: + x_flat = x.flatten(1) + residual = residual.flatten(1) + x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor) + else: + x_plus_residual = scaled_index_add( + x, brange, residual.to(dtype=x.dtype), scaling=scaling_vector, alpha=residual_scale_factor + ) + return x_plus_residual + + +attn_bias_cache: Dict[Tuple, Any] = {} + + +def get_attn_bias_and_cat(x_list, branges=None): + """ + this will perform the index select, cat the tensors, and provide the attn_bias from cache + """ + batch_sizes = [b.shape[0] for b in branges] if branges is not None else [x.shape[0] for x in x_list] + all_shapes = tuple((b, x.shape[1]) for b, x in zip(batch_sizes, x_list)) + if all_shapes not in attn_bias_cache.keys(): + seqlens = [] + for b, x in zip(batch_sizes, x_list): + for _ in range(b): + seqlens.append(x.shape[1]) + attn_bias = fmha.BlockDiagonalMask.from_seqlens(seqlens) + attn_bias._batch_sizes = batch_sizes + attn_bias_cache[all_shapes] = attn_bias + + if branges is not None: + cat_tensors = index_select_cat([x.flatten(1) for x in x_list], branges).view(1, -1, x_list[0].shape[-1]) + else: + tensors_bs1 = tuple(x.reshape([1, -1, *x.shape[2:]]) for x in x_list) + cat_tensors = torch.cat(tensors_bs1, dim=1) + + return attn_bias_cache[all_shapes], cat_tensors + + +def drop_add_residual_stochastic_depth_list( + x_list: List[Tensor], + residual_func: Callable[[Tensor, Any], Tensor], + sample_drop_ratio: float = 0.0, + scaling_vector=None, +) -> Tensor: + # 1) generate random set of indices for dropping samples in the batch + branges_scales = [get_branges_scales(x, sample_drop_ratio=sample_drop_ratio) for x in x_list] + branges = [s[0] for s in branges_scales] + residual_scale_factors = [s[1] for s in branges_scales] + + # 2) get attention bias and index+concat the tensors + attn_bias, x_cat = get_attn_bias_and_cat(x_list, branges) + + # 3) apply residual_func to get residual, and split the result + residual_list = attn_bias.split(residual_func(x_cat, attn_bias=attn_bias)) # type: ignore + + outputs = [] + for x, brange, residual, residual_scale_factor in zip(x_list, branges, residual_list, residual_scale_factors): + outputs.append(add_residual(x, brange, residual, residual_scale_factor, scaling_vector).view_as(x)) + return outputs + + +class NestedTensorBlock(Block): + def forward_nested(self, x_list: List[Tensor]) -> List[Tensor]: + """ + x_list contains a list of tensors to nest together and run + """ + assert isinstance(self.attn, MemEffAttention) + + if self.training and self.sample_drop_ratio > 0.0: + + def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor: + return self.attn(self.norm1(x), attn_bias=attn_bias) + + def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor: + return self.mlp(self.norm2(x)) + + x_list = drop_add_residual_stochastic_depth_list( + x_list, + residual_func=attn_residual_func, + sample_drop_ratio=self.sample_drop_ratio, + scaling_vector=self.ls1.gamma if isinstance(self.ls1, LayerScale) else None, + ) + x_list = drop_add_residual_stochastic_depth_list( + x_list, + residual_func=ffn_residual_func, + sample_drop_ratio=self.sample_drop_ratio, + scaling_vector=self.ls2.gamma if isinstance(self.ls1, LayerScale) else None, + ) + return x_list + else: + + def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor: + return self.ls1(self.attn(self.norm1(x), attn_bias=attn_bias)) + + def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor: + return self.ls2(self.mlp(self.norm2(x))) + + attn_bias, x = get_attn_bias_and_cat(x_list) + x = x + attn_residual_func(x, attn_bias=attn_bias) + x = x + ffn_residual_func(x) + return attn_bias.split(x) + + def forward(self, x_or_x_list): + if isinstance(x_or_x_list, Tensor): + return super().forward(x_or_x_list) + elif isinstance(x_or_x_list, list): + if not XFORMERS_AVAILABLE: + raise AssertionError("xFormers is required for using nested tensors") + return self.forward_nested(x_or_x_list) + else: + raise AssertionError diff --git a/OpenMidnight/dinov2/layers/dino_head.py b/OpenMidnight/dinov2/layers/dino_head.py new file mode 100644 index 0000000000000000000000000000000000000000..0ace8ffd6297a1dd480b19db407b662a6ea0f565 --- /dev/null +++ b/OpenMidnight/dinov2/layers/dino_head.py @@ -0,0 +1,58 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +from torch.nn.init import trunc_normal_ +from torch.nn.utils import weight_norm + + +class DINOHead(nn.Module): + def __init__( + self, + in_dim, + out_dim, + use_bn=False, + nlayers=3, + hidden_dim=2048, + bottleneck_dim=256, + mlp_bias=True, + ): + super().__init__() + nlayers = max(nlayers, 1) + self.mlp = _build_mlp(nlayers, in_dim, bottleneck_dim, hidden_dim=hidden_dim, use_bn=use_bn, bias=mlp_bias) + self.apply(self._init_weights) + self.last_layer = weight_norm(nn.Linear(bottleneck_dim, out_dim, bias=False)) + self.last_layer.weight_g.data.fill_(1) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=0.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + + def forward(self, x): + x = self.mlp(x) + eps = 1e-6 if x.dtype == torch.float16 else 1e-12 + x = nn.functional.normalize(x, dim=-1, p=2, eps=eps) + x = self.last_layer(x) + return x + + +def _build_mlp(nlayers, in_dim, bottleneck_dim, hidden_dim=None, use_bn=False, bias=True): + if nlayers == 1: + return nn.Linear(in_dim, bottleneck_dim, bias=bias) + else: + layers = [nn.Linear(in_dim, hidden_dim, bias=bias)] + if use_bn: + layers.append(nn.BatchNorm1d(hidden_dim)) + layers.append(nn.GELU()) + for _ in range(nlayers - 2): + layers.append(nn.Linear(hidden_dim, hidden_dim, bias=bias)) + if use_bn: + layers.append(nn.BatchNorm1d(hidden_dim)) + layers.append(nn.GELU()) + layers.append(nn.Linear(hidden_dim, bottleneck_dim, bias=bias)) + return nn.Sequential(*layers) diff --git a/OpenMidnight/dinov2/layers/drop_path.py b/OpenMidnight/dinov2/layers/drop_path.py new file mode 100644 index 0000000000000000000000000000000000000000..1d640e0b969b8dcba96260243473700b4e5b24b5 --- /dev/null +++ b/OpenMidnight/dinov2/layers/drop_path.py @@ -0,0 +1,34 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/drop.py + + +from torch import nn + + +def drop_path(x, drop_prob: float = 0.0, training: bool = False): + if drop_prob == 0.0 or not training: + return x + keep_prob = 1 - drop_prob + shape = (x.shape[0],) + (1,) * (x.ndim - 1) # work with diff dim tensors, not just 2D ConvNets + random_tensor = x.new_empty(shape).bernoulli_(keep_prob) + if keep_prob > 0.0: + random_tensor.div_(keep_prob) + output = x * random_tensor + return output + + +class DropPath(nn.Module): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).""" + + def __init__(self, drop_prob=None): + super(DropPath, self).__init__() + self.drop_prob = drop_prob + + def forward(self, x): + return drop_path(x, self.drop_prob, self.training) diff --git a/OpenMidnight/dinov2/layers/layer_scale.py b/OpenMidnight/dinov2/layers/layer_scale.py new file mode 100644 index 0000000000000000000000000000000000000000..0b38971302b3c8fb3d4c05a5f0912fafe0e80816 --- /dev/null +++ b/OpenMidnight/dinov2/layers/layer_scale.py @@ -0,0 +1,34 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# Modified from: https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/vision_transformer.py#L103-L110 + +from typing import Optional, Union + +import torch +from torch import Tensor +from torch import nn + + +class LayerScale(nn.Module): + def __init__( + self, + dim: int, + init_values: Union[float, Tensor] = 1e-5, + inplace: bool = False, + device: Optional[torch.device] = None, + dtype: Optional[torch.dtype] = None, + ) -> None: + super().__init__() + self.inplace = inplace + self.init_values = init_values + self.gamma = nn.Parameter(torch.empty(dim, device=device, dtype=dtype)) + self.reset_parameters() + + def reset_parameters(self): + nn.init.constant_(self.gamma, self.init_values) + + def forward(self, x: Tensor) -> Tensor: + return x.mul_(self.gamma) if self.inplace else x * self.gamma diff --git a/OpenMidnight/dinov2/layers/mlp.py b/OpenMidnight/dinov2/layers/mlp.py new file mode 100644 index 0000000000000000000000000000000000000000..bbf9432aae9258612caeae910a7bde17999e328e --- /dev/null +++ b/OpenMidnight/dinov2/layers/mlp.py @@ -0,0 +1,40 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/mlp.py + + +from typing import Callable, Optional + +from torch import Tensor, nn + + +class Mlp(nn.Module): + def __init__( + self, + in_features: int, + hidden_features: Optional[int] = None, + out_features: Optional[int] = None, + act_layer: Callable[..., nn.Module] = nn.GELU, + drop: float = 0.0, + bias: bool = True, + ) -> None: + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features, bias=bias) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features, bias=bias) + self.drop = nn.Dropout(drop) + + def forward(self, x: Tensor) -> Tensor: + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x diff --git a/OpenMidnight/dinov2/layers/patch_embed.py b/OpenMidnight/dinov2/layers/patch_embed.py new file mode 100644 index 0000000000000000000000000000000000000000..8b7c0804784a42cf80c0297d110dcc68cc85b339 --- /dev/null +++ b/OpenMidnight/dinov2/layers/patch_embed.py @@ -0,0 +1,88 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/patch_embed.py + +from typing import Callable, Optional, Tuple, Union + +from torch import Tensor +import torch.nn as nn + + +def make_2tuple(x): + if isinstance(x, tuple): + assert len(x) == 2 + return x + + assert isinstance(x, int) + return (x, x) + + +class PatchEmbed(nn.Module): + """ + 2D image to patch embedding: (B,C,H,W) -> (B,N,D) + + Args: + img_size: Image size. + patch_size: Patch token size. + in_chans: Number of input image channels. + embed_dim: Number of linear projection output channels. + norm_layer: Normalization layer. + """ + + def __init__( + self, + img_size: Union[int, Tuple[int, int]] = 224, + patch_size: Union[int, Tuple[int, int]] = 16, + in_chans: int = 3, + embed_dim: int = 768, + norm_layer: Optional[Callable] = None, + flatten_embedding: bool = True, + ) -> None: + super().__init__() + + image_HW = make_2tuple(img_size) + patch_HW = make_2tuple(patch_size) + patch_grid_size = ( + image_HW[0] // patch_HW[0], + image_HW[1] // patch_HW[1], + ) + + self.img_size = image_HW + self.patch_size = patch_HW + self.patches_resolution = patch_grid_size + self.num_patches = patch_grid_size[0] * patch_grid_size[1] + + self.in_chans = in_chans + self.embed_dim = embed_dim + + self.flatten_embedding = flatten_embedding + + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_HW, stride=patch_HW) + self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity() + + def forward(self, x: Tensor) -> Tensor: + _, _, H, W = x.shape + patch_H, patch_W = self.patch_size + + assert H % patch_H == 0, f"Input image height {H} is not a multiple of patch height {patch_H}" + assert W % patch_W == 0, f"Input image width {W} is not a multiple of patch width: {patch_W}" + + x = self.proj(x) # B C H W + H, W = x.size(2), x.size(3) + x = x.flatten(2).transpose(1, 2) # B HW C + x = self.norm(x) + if not self.flatten_embedding: + x = x.reshape(-1, H, W, self.embed_dim) # B H W C + return x + + def flops(self) -> float: + Ho, Wo = self.patches_resolution + flops = Ho * Wo * self.embed_dim * self.in_chans * (self.patch_size[0] * self.patch_size[1]) + if self.norm is not None: + flops += Ho * Wo * self.embed_dim + return flops diff --git a/OpenMidnight/dinov2/layers/swiglu_ffn.py b/OpenMidnight/dinov2/layers/swiglu_ffn.py new file mode 100644 index 0000000000000000000000000000000000000000..340cee356cb4ad7cb3c8bbefa121f39f7c4e5c6f --- /dev/null +++ b/OpenMidnight/dinov2/layers/swiglu_ffn.py @@ -0,0 +1,100 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import os +from typing import Callable, Optional +import warnings + +from torch import Tensor, nn +import torch.nn.functional as F + + +class SwiGLUFFN(nn.Module): + def __init__( + self, + in_features: int, + hidden_features: Optional[int] = None, + out_features: Optional[int] = None, + act_layer: Callable[..., nn.Module] = None, + drop: float = 0.0, + bias: bool = True, + ) -> None: + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.w12 = nn.Linear(in_features, 2 * hidden_features, bias=bias) + self.w3 = nn.Linear(hidden_features, out_features, bias=bias) + + def forward(self, x: Tensor) -> Tensor: + x12 = self.w12(x) + x1, x2 = x12.chunk(2, dim=-1) + hidden = F.silu(x1) * x2 + return self.w3(hidden) + + +XFORMERS_ENABLED = os.environ.get("XFORMERS_DISABLED") is None +try: + if XFORMERS_ENABLED: + from xformers.ops import SwiGLU + + XFORMERS_AVAILABLE = True + warnings.warn("xFormers is available (SwiGLU)") + else: + warnings.warn("xFormers is disabled (SwiGLU)") + raise ImportError +except ImportError: + SwiGLU = SwiGLUFFN + XFORMERS_AVAILABLE = False + + warnings.warn("xFormers is not available (SwiGLU)") + + +class SwiGLUFFNFused(SwiGLU): + def __init__( + self, + in_features: int, + hidden_features: Optional[int] = None, + out_features: Optional[int] = None, + act_layer: Callable[..., nn.Module] = None, + drop: float = 0.0, + bias: bool = True, + ) -> None: + out_features = out_features or in_features + hidden_features = hidden_features or in_features + hidden_features = (int(hidden_features * 2 / 3) + 7) // 8 * 8 + super().__init__( + in_features=in_features, + hidden_features=hidden_features, + out_features=out_features, + bias=bias, + ) + + +class SwiGLUFFNAligned(nn.Module): + def __init__( + self, + in_features: int, + hidden_features: Optional[int] = None, + out_features: Optional[int] = None, + act_layer: Callable[..., nn.Module] = nn.GELU, + drop: float = 0.0, + bias: bool = True, + align_to: int = 8, + device=None, + ) -> None: + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + d = int(hidden_features * 2 / 3) + swiglu_hidden_features = d + (-d % align_to) + self.w1 = nn.Linear(in_features, swiglu_hidden_features, bias=bias, device=device) + self.w2 = nn.Linear(in_features, swiglu_hidden_features, bias=bias, device=device) + self.w3 = nn.Linear(swiglu_hidden_features, out_features, bias=bias, device=device) + + def forward(self, x: Tensor) -> Tensor: + x1 = self.w1(x) + x2 = self.w2(x) + hidden = F.silu(x1) * x2 + return self.w3(hidden) diff --git a/OpenMidnight/dinov2/logging/__init__.py b/OpenMidnight/dinov2/logging/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..04a7f02204316d4d1ef38bf6080dae3d66241c25 --- /dev/null +++ b/OpenMidnight/dinov2/logging/__init__.py @@ -0,0 +1,102 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import functools +import logging +import os +import sys +from typing import Optional + +import dinov2.distributed as distributed +from .helpers import MetricLogger, SmoothedValue + + +# So that calling _configure_logger multiple times won't add many handlers +@functools.lru_cache() +def _configure_logger( + name: Optional[str] = None, + *, + level: int = logging.DEBUG, + output: Optional[str] = None, +): + """ + Configure a logger. + + Adapted from Detectron2. + + Args: + name: The name of the logger to configure. + level: The logging level to use. + output: A file name or a directory to save log. If None, will not save log file. + If ends with ".txt" or ".log", assumed to be a file name. + Otherwise, logs will be saved to `output/log.txt`. + + Returns: + The configured logger. + """ + + logger = logging.getLogger(name) + logger.setLevel(level) + logger.propagate = False + + # Loosely match Google glog format: + # [IWEF]yyyymmdd hh:mm:ss.uuuuuu threadid file:line] msg + # but use a shorter timestamp and include the logger name: + # [IWEF]yyyymmdd hh:mm:ss logger threadid file:line] msg + fmt_prefix = "%(levelname).1s%(asctime)s %(process)s %(name)s %(filename)s:%(lineno)s] " + fmt_message = "%(message)s" + fmt = fmt_prefix + fmt_message + datefmt = "%Y%m%d %H:%M:%S" + formatter = logging.Formatter(fmt=fmt, datefmt=datefmt) + + # stdout logging for main worker only + if distributed.is_main_process(): + handler = logging.StreamHandler(stream=sys.stdout) + handler.setLevel(logging.DEBUG) + handler.setFormatter(formatter) + logger.addHandler(handler) + + # file logging for all workers + if output: + if os.path.splitext(output)[-1] in (".txt", ".log"): + filename = output + else: + filename = os.path.join(output, "logs", "log.txt") + + if not distributed.is_main_process(): + global_rank = distributed.get_global_rank() + filename = filename + ".rank{}".format(global_rank) + + os.makedirs(os.path.dirname(filename), exist_ok=True) + + handler = logging.StreamHandler(open(filename, "a")) + handler.setLevel(logging.DEBUG) + handler.setFormatter(formatter) + logger.addHandler(handler) + + return logger + + +def setup_logging( + output: Optional[str] = None, + *, + name: Optional[str] = None, + level: int = logging.DEBUG, + capture_warnings: bool = True, +) -> None: + """ + Setup logging. + + Args: + output: A file name or a directory to save log files. If None, log + files will not be saved. If output ends with ".txt" or ".log", it + is assumed to be a file name. + Otherwise, logs will be saved to `output/log.txt`. + name: The name of the logger to configure, by default the root logger. + level: The logging level to use. + capture_warnings: Whether warnings should be captured as logs. + """ + logging.captureWarnings(capture_warnings) + _configure_logger(name, level=level, output=output) diff --git a/OpenMidnight/dinov2/logging/helpers.py b/OpenMidnight/dinov2/logging/helpers.py new file mode 100644 index 0000000000000000000000000000000000000000..53ba7b33b483c6132825d3e3f7a6811270fe324d --- /dev/null +++ b/OpenMidnight/dinov2/logging/helpers.py @@ -0,0 +1,204 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from collections import defaultdict, deque +import datetime +import json +import logging +import time + +import torch + +import dinov2.distributed as distributed + + +logger = logging.getLogger("dinov2") + + +class MetricLogger(object): + def __init__(self, delimiter="\t", output_file=None): + self.meters = defaultdict(SmoothedValue) + self.delimiter = delimiter + self.output_file = output_file + + def update(self, **kwargs): + for k, v in kwargs.items(): + if isinstance(v, torch.Tensor): + v = v.item() + assert isinstance(v, (float, int)) + self.meters[k].update(v) + + def __getattr__(self, attr): + if attr in self.meters: + return self.meters[attr] + if attr in self.__dict__: + return self.__dict__[attr] + raise AttributeError("'{}' object has no attribute '{}'".format(type(self).__name__, attr)) + + def __str__(self): + loss_str = [] + for name, meter in self.meters.items(): + loss_str.append("{}: {}".format(name, str(meter))) + return self.delimiter.join(loss_str) + + def synchronize_between_processes(self): + for meter in self.meters.values(): + meter.synchronize_between_processes() + + def add_meter(self, name, meter): + self.meters[name] = meter + + def dump_in_output_file(self, iteration, iter_time, data_time): + if self.output_file is None or not distributed.is_main_process(): + return + dict_to_dump = dict( + iteration=iteration, + iter_time=iter_time, + data_time=data_time, + ) + dict_to_dump.update({k: v.median for k, v in self.meters.items()}) + with open(self.output_file, "a") as f: + f.write(json.dumps(dict_to_dump) + "\n") + pass + + def log_every(self, iterable, print_freq, header=None, n_iterations=None, start_iteration=0): + i = start_iteration + if not header: + header = "" + start_time = time.time() + end = time.time() + iter_time = SmoothedValue(fmt="{avg:.6f}") + data_time = SmoothedValue(fmt="{avg:.6f}") + + if n_iterations is None: + n_iterations = len(iterable) + + space_fmt = ":" + str(len(str(n_iterations))) + "d" + + log_list = [ + header, + "[{0" + space_fmt + "}/{1}]", + "eta: {eta}", + "gap: {delta}", + "{meters}", + "time: {time}", + "data: {data}", + ] + if torch.cuda.is_available(): + log_list += ["max mem: {memory:.0f}"] + + log_msg = self.delimiter.join(log_list) + MB = 1024.0 * 1024.0 + last_log_time = None + for obj in iterable: + data_time.update(time.time() - end) + yield obj + iter_time.update(time.time() - end) + if i % print_freq == 0 or i == n_iterations - 1: + current_log_time = time.time() + if last_log_time is None: + delta_ms_str = "N/A" + else: + delta_ms_str = f"{(current_log_time - last_log_time) * 1000.0:.2f} ms" + last_log_time = current_log_time + self.dump_in_output_file(iteration=i, iter_time=iter_time.avg, data_time=data_time.avg) + eta_seconds = iter_time.global_avg * (n_iterations - i) + eta_string = str(datetime.timedelta(seconds=int(eta_seconds))) + if torch.cuda.is_available(): + logger.info( + log_msg.format( + i, + n_iterations, + eta=eta_string, + delta=delta_ms_str, + meters=str(self), + time=str(iter_time), + data=str(data_time), + memory=torch.cuda.max_memory_allocated() / MB, + ) + ) + else: + logger.info( + log_msg.format( + i, + n_iterations, + eta=eta_string, + delta=delta_ms_str, + meters=str(self), + time=str(iter_time), + data=str(data_time), + ) + ) + i += 1 + end = time.time() + if i >= n_iterations: + break + total_time = time.time() - start_time + total_time_str = str(datetime.timedelta(seconds=int(total_time))) + logger.info("{} Total time: {} ({:.6f} s / it)".format(header, total_time_str, total_time / n_iterations)) + + +class SmoothedValue: + """Track a series of values and provide access to smoothed values over a + window or the global series average. + """ + + def __init__(self, window_size=20, fmt=None): + if fmt is None: + fmt = "{median:.4f} ({global_avg:.4f})" + self.deque = deque(maxlen=window_size) + self.total = 0.0 + self.count = 0 + self.fmt = fmt + + def update(self, value, num=1): + self.deque.append(value) + self.count += num + self.total += value * num + + def synchronize_between_processes(self): + """ + Distributed synchronization of the metric + Warning: does not synchronize the deque! + """ + if not distributed.is_enabled(): + return + t = torch.tensor([self.count, self.total], dtype=torch.float64, device="cuda") + torch.distributed.barrier() + torch.distributed.all_reduce(t) + t = t.tolist() + self.count = int(t[0]) + self.total = t[1] + + @property + def median(self): + d = torch.tensor(list(self.deque)) + return d.median().item() + + @property + def avg(self): + d = torch.tensor(list(self.deque), dtype=torch.float32) + return d.mean().item() + + @property + def global_avg(self): + return self.total / self.count + + @property + def max(self): + return max(self.deque) + + @property + def value(self): + return self.deque[-1] + + def __str__(self): + return self.fmt.format( + median=self.median, + avg=self.avg, + global_avg=self.global_avg, + max=self.max, + value=self.value, + ) diff --git a/OpenMidnight/dinov2/loss/__init__.py b/OpenMidnight/dinov2/loss/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a21b2d0ec36ea48cfb8e71ce8e8519e848b5b018 --- /dev/null +++ b/OpenMidnight/dinov2/loss/__init__.py @@ -0,0 +1,10 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .dino_clstoken_loss import DINOLoss +from .ibot_patch_loss import iBOTPatchLoss +from .koleo_loss import KoLeoLoss +from .kde_loss import KDELoss +from .gram_loss import GramLoss diff --git a/OpenMidnight/dinov2/loss/dino_clstoken_loss.py b/OpenMidnight/dinov2/loss/dino_clstoken_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..c31808e36e6c38ee6dae13ba0443bf1946242117 --- /dev/null +++ b/OpenMidnight/dinov2/loss/dino_clstoken_loss.py @@ -0,0 +1,99 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.distributed as dist +import torch.nn.functional as F +from torch import nn + + +class DINOLoss(nn.Module): + def __init__( + self, + out_dim, + student_temp=0.1, + center_momentum=0.9, + ): + super().__init__() + self.student_temp = student_temp + self.center_momentum = center_momentum + self.register_buffer("center", torch.zeros(1, out_dim)) + self.updated = True + self.reduce_handle = None + self.len_teacher_output = None + self.async_batch_center = None + + @torch.no_grad() + def softmax_center_teacher(self, teacher_output, teacher_temp): + self.apply_center_update() + # teacher centering and sharpening + return F.softmax((teacher_output - self.center) / teacher_temp, dim=-1) + + @torch.no_grad() + def sinkhorn_knopp_teacher(self, teacher_output, teacher_temp, n_iterations=3): + teacher_output = teacher_output.float() + world_size = dist.get_world_size() if dist.is_initialized() else 1 + Q = torch.exp(teacher_output / teacher_temp).t() # Q is K-by-B for consistency with notations from our paper + B = Q.shape[1] * world_size # number of samples to assign + K = Q.shape[0] # how many prototypes + + # make the matrix sums to 1 + sum_Q = torch.sum(Q) + if dist.is_initialized(): + dist.all_reduce(sum_Q) + Q /= sum_Q + + for it in range(n_iterations): + # normalize each row: total weight per prototype must be 1/K + sum_of_rows = torch.sum(Q, dim=1, keepdim=True) + if dist.is_initialized(): + dist.all_reduce(sum_of_rows) + Q /= sum_of_rows + Q /= K + + # normalize each column: total weight per sample must be 1/B + Q /= torch.sum(Q, dim=0, keepdim=True) + Q /= B + + Q *= B # the columns must sum to 1 so that Q is an assignment + return Q.t() + + def forward(self, student_output_list, teacher_out_softmaxed_centered_list): + """ + Cross-entropy between softmax outputs of the teacher and student networks. + """ + # TODO: Use cross_entropy_distribution here + total_loss = 0 + for s in student_output_list: + lsm = F.log_softmax(s / self.student_temp, dim=-1) + for t in teacher_out_softmaxed_centered_list: + loss = torch.sum(t * lsm, dim=-1) + total_loss -= loss.mean() + return total_loss + + @torch.no_grad() + def update_center(self, teacher_output): + self.reduce_center_update(teacher_output) + + @torch.no_grad() + def reduce_center_update(self, teacher_output): + self.updated = False + self.len_teacher_output = len(teacher_output) + self.async_batch_center = torch.sum(teacher_output, dim=0, keepdim=True) + if dist.is_initialized(): + self.reduce_handle = dist.all_reduce(self.async_batch_center, async_op=True) + + @torch.no_grad() + def apply_center_update(self): + if self.updated is False: + world_size = dist.get_world_size() if dist.is_initialized() else 1 + + if self.reduce_handle is not None: + self.reduce_handle.wait() + _t = self.async_batch_center / (self.len_teacher_output * world_size) + + self.center = self.center * self.center_momentum + _t * (1 - self.center_momentum) + + self.updated = True diff --git a/OpenMidnight/dinov2/loss/gram_loss.py b/OpenMidnight/dinov2/loss/gram_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..4c2f0ac8726a137b0e963aba2a0f6bb1d19c3e6b --- /dev/null +++ b/OpenMidnight/dinov2/loss/gram_loss.py @@ -0,0 +1,84 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This software may be used and distributed in accordance with +# the terms of the DINOv3 License Agreement. + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class GramLoss(nn.Module): + """Implementation of the gram loss""" + + def __init__( + self, + apply_norm=True, + img_level=True, + remove_neg=True, + remove_only_teacher_neg=False, + ): + super().__init__() + + # Loss + self.mse_loss = torch.nn.MSELoss() + + # Parameters + self.apply_norm = apply_norm + self.remove_neg = remove_neg + self.remove_only_teacher_neg = remove_only_teacher_neg + + if self.remove_neg or self.remove_only_teacher_neg: + assert self.remove_neg != self.remove_only_teacher_neg + + def forward(self, output_feats, target_feats, img_level=True): + """Compute the MSE loss between the gram matrix of the input and target features. + + Args: + output_feats: Pytorch tensor (B, N, dim) or (B*N, dim) if img_level == False + target_feats: Pytorch tensor (B, N, dim) or (B*N, dim) if img_level == False + img_level: bool, if true gram computed at the image level only else over the entire batch + Returns: + loss: scalar + """ + + # Dimensions of the tensor should be (B, N, dim) + if img_level: + assert len(target_feats.shape) == 3 and len(output_feats.shape) == 3 + + # Float casting + output_feats = output_feats.float() + target_feats = target_feats.float() + + # SSL correlation + if self.apply_norm: + target_feats = F.normalize(target_feats, dim=-1) + + if not img_level and len(target_feats.shape) == 3: + # Flatten (B, N, D) into (B*N, D) + target_feats = target_feats.flatten(0, 1) + + # Compute similarities + target_sim = torch.matmul(target_feats, target_feats.transpose(-1, -2)) + + # Patch correlation + if self.apply_norm: + output_feats = F.normalize(output_feats, dim=-1) + + if not img_level and len(output_feats.shape) == 3: + # Flatten (B, N, D) into (B*N, D) + output_feats = output_feats.flatten(0, 1) + + # Compute similarities + student_sim = torch.matmul(output_feats, output_feats.transpose(-1, -2)) + + if self.remove_neg: + target_sim[target_sim < 0] = 0.0 + student_sim[student_sim < 0] = 0.0 + + elif self.remove_only_teacher_neg: + # Remove only the negative sim values of the teacher + target_sim[target_sim < 0] = 0.0 + student_sim[(student_sim < 0) & (target_sim < 0)] = 0.0 + + return self.mse_loss(student_sim, target_sim) diff --git a/OpenMidnight/dinov2/loss/ibot_patch_loss.py b/OpenMidnight/dinov2/loss/ibot_patch_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..6732cda0c311c69f193669ebc950fc8665871442 --- /dev/null +++ b/OpenMidnight/dinov2/loss/ibot_patch_loss.py @@ -0,0 +1,151 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import torch +import torch.distributed as dist +import torch.nn.functional as F +from torch import nn + +import logging + + +logger = logging.getLogger("dinov2") + + +try: + from xformers.ops import cross_entropy + + def lossfunc(t, s, temp): + s = s.float() + t = t.float() + if s.ndim == 2: + return -cross_entropy(s.unsqueeze(0), t.unsqueeze(0), temp, bw_inplace=True).squeeze(0) + elif s.ndim == 3: + return -cross_entropy(s, t, temp, bw_inplace=True) + +except ImportError: + + def lossfunc(t, s, temp): + return torch.sum(t * F.log_softmax(s / temp, dim=-1), dim=-1) + + +class iBOTPatchLoss(nn.Module): + def __init__(self, patch_out_dim, student_temp=0.1, center_momentum=0.9): + super().__init__() + self.student_temp = student_temp + self.center_momentum = center_momentum + self.register_buffer("center", torch.zeros(1, 1, patch_out_dim)) + self.updated = True + self.reduce_handle = None + self.len_teacher_patch_tokens = None + self.async_batch_center = None + + @torch.no_grad() + def softmax_center_teacher(self, teacher_patch_tokens, teacher_temp): + self.apply_center_update() + # teacher centering and sharpening + # + # WARNING: + # as self.center is a float32, everything gets casted to float32 afterwards + # + # teacher_patch_tokens = teacher_patch_tokens.float() + # return F.softmax((teacher_patch_tokens.sub_(self.center.to(teacher_patch_tokens.dtype))).mul_(1 / teacher_temp), dim=-1) + + return F.softmax((teacher_patch_tokens - self.center) / teacher_temp, dim=-1) + + # this is experimental, keep everything in float16 and let's see what happens: + # return F.softmax((teacher_patch_tokens.sub_(self.center)) / teacher_temp, dim=-1) + + @torch.no_grad() + def sinkhorn_knopp_teacher(self, teacher_output, teacher_temp, n_masked_patches_tensor, n_iterations=3): + teacher_output = teacher_output.float() + # world_size = dist.get_world_size() if dist.is_initialized() else 1 + Q = torch.exp(teacher_output / teacher_temp).t() # Q is K-by-B for consistency with notations from our paper + # B = Q.shape[1] * world_size # number of samples to assign + B = n_masked_patches_tensor + dist.all_reduce(B) + K = Q.shape[0] # how many prototypes + + # make the matrix sums to 1 + sum_Q = torch.sum(Q) + if dist.is_initialized(): + dist.all_reduce(sum_Q) + Q /= sum_Q + + for it in range(n_iterations): + # normalize each row: total weight per prototype must be 1/K + sum_of_rows = torch.sum(Q, dim=1, keepdim=True) + if dist.is_initialized(): + dist.all_reduce(sum_of_rows) + Q /= sum_of_rows + Q /= K + + # normalize each column: total weight per sample must be 1/B + Q /= torch.sum(Q, dim=0, keepdim=True) + Q /= B + + Q *= B # the columns must sum to 1 so that Q is an assignment + return Q.t() + + def forward(self, student_patch_tokens, teacher_patch_tokens, student_masks_flat): + """ + Cross-entropy between softmax outputs of the teacher and student networks. + student_patch_tokens: (B, N, D) tensor + teacher_patch_tokens: (B, N, D) tensor + student_masks_flat: (B, N) tensor + """ + t = teacher_patch_tokens + s = student_patch_tokens + loss = torch.sum(t * F.log_softmax(s / self.student_temp, dim=-1), dim=-1) + loss = torch.sum(loss * student_masks_flat.float(), dim=-1) / student_masks_flat.sum(dim=-1).clamp(min=1.0) + return -loss.mean() + + def forward_masked( + self, + student_patch_tokens_masked, + teacher_patch_tokens_masked, + student_masks_flat, + n_masked_patches=None, + masks_weight=None, + ): + t = teacher_patch_tokens_masked + s = student_patch_tokens_masked + # loss = torch.sum(t * F.log_softmax(s / self.student_temp, dim=-1), dim=-1) + loss = lossfunc(t, s, self.student_temp) + if masks_weight is None: + masks_weight = ( + (1 / student_masks_flat.sum(-1).clamp(min=1.0)) + .unsqueeze(-1) + .expand_as(student_masks_flat)[student_masks_flat] + ) + if n_masked_patches is not None: + loss = loss[:n_masked_patches] + loss = loss * masks_weight + return -loss.sum() / student_masks_flat.shape[0] + + @torch.no_grad() + def update_center(self, teacher_patch_tokens): + self.reduce_center_update(teacher_patch_tokens) + + @torch.no_grad() + def reduce_center_update(self, teacher_patch_tokens): + self.updated = False + self.len_teacher_patch_tokens = len(teacher_patch_tokens) + self.async_batch_center = torch.sum(teacher_patch_tokens.mean(1), dim=0, keepdim=True) + if dist.is_initialized(): + self.reduce_handle = dist.all_reduce(self.async_batch_center, async_op=True) + + @torch.no_grad() + def apply_center_update(self): + if self.updated is False: + world_size = dist.get_world_size() if dist.is_initialized() else 1 + + if self.reduce_handle is not None: + self.reduce_handle.wait() + _t = self.async_batch_center / (self.len_teacher_patch_tokens * world_size) + + self.center = self.center * self.center_momentum + _t * (1 - self.center_momentum) + + self.updated = True diff --git a/OpenMidnight/dinov2/loss/kde_loss.py b/OpenMidnight/dinov2/loss/kde_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..2b0724c839c3f90a4f77e393dd9f91f8e946d13c --- /dev/null +++ b/OpenMidnight/dinov2/loss/kde_loss.py @@ -0,0 +1,33 @@ +import logging + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +logging = logging.getLogger("dinov2") +class KDELoss(nn.Module): + + def __init__(self): + super().__init__() + + + def vmF(self, x, y, kappa): + + x_norm = F.normalize(x, p=2, dim=-1) + y_norm = F.normalize(y, p=2, dim=-1) + + sim = x_norm @ y_norm.T#Doesn't follow the formula technically, but shouldn't matter here. + + kernel = torch.exp(kappa * sim) + return kernel + + def forward(self, student_output, eps=1e-8): + + kappa = 5.0 + #Batch size + n = student_output.shape[0] + k = self.vmF(student_output, student_output, kappa) + density_estimates = k.sum(dim=1) # [n] + entropy = -torch.log(density_estimates + 1e-9).mean() + return entropy diff --git a/OpenMidnight/dinov2/loss/koleo_loss.py b/OpenMidnight/dinov2/loss/koleo_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..b5cbcd91e0fc0b857f477b0910f957f02a6c4335 --- /dev/null +++ b/OpenMidnight/dinov2/loss/koleo_loss.py @@ -0,0 +1,48 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging + +import torch +import torch.nn as nn +import torch.nn.functional as F + +# import torch.distributed as dist + + +logger = logging.getLogger("dinov2") + + +class KoLeoLoss(nn.Module): + """Kozachenko-Leonenko entropic loss regularizer from Sablayrolles et al. - 2018 - Spreading vectors for similarity search""" + + def __init__(self): + super().__init__() + self.pdist = nn.PairwiseDistance(2, eps=1e-8) + + def pairwise_NNs_inner(self, x): + """ + Pairwise nearest neighbors for L2-normalized vectors. + Uses Torch rather than Faiss to remain on GPU. + """ + # parwise dot products (= inverse distance) + dots = torch.mm(x, x.t()) + n = x.shape[0] + dots.view(-1)[:: (n + 1)].fill_(-1) # Trick to fill diagonal with -1 + # max inner prod -> min distance + _, I = torch.max(dots, dim=1) # noqa: E741 + return I + + def forward(self, student_output, eps=1e-8): + """ + Args: + student_output (BxD): backbone output of student + """ + with torch.cuda.amp.autocast(enabled=False): + student_output = F.normalize(student_output, eps=eps, p=2, dim=-1) + I = self.pairwise_NNs_inner(student_output) # noqa: E741 + distances = self.pdist(student_output, student_output[I]) # BxD, BxD -> B + loss = -torch.log(distances + eps).mean() + return loss diff --git a/OpenMidnight/dinov2/models/__init__.py b/OpenMidnight/dinov2/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3fdff20badbd5244bf79f16bf18dd2cb73982265 --- /dev/null +++ b/OpenMidnight/dinov2/models/__init__.py @@ -0,0 +1,43 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging + +from . import vision_transformer as vits + + +logger = logging.getLogger("dinov2") + + +def build_model(args, only_teacher=False, img_size=224): + args.arch = args.arch.removesuffix("_memeff") + if "vit" in args.arch: + vit_kwargs = dict( + img_size=img_size, + patch_size=args.patch_size, + init_values=args.layerscale, + ffn_layer=args.ffn_layer, + block_chunks=args.block_chunks, + qkv_bias=args.qkv_bias, + proj_bias=args.proj_bias, + ffn_bias=args.ffn_bias, + num_register_tokens=args.num_register_tokens, + interpolate_offset=args.interpolate_offset, + interpolate_antialias=args.interpolate_antialias, + ) + teacher = vits.__dict__[args.arch](**vit_kwargs) + if only_teacher: + return teacher, teacher.embed_dim + student = vits.__dict__[args.arch]( + **vit_kwargs, + drop_path_rate=args.drop_path_rate, + drop_path_uniform=args.drop_path_uniform, + ) + embed_dim = student.embed_dim + return student, teacher, embed_dim + + +def build_model_from_cfg(cfg, only_teacher=False): + return build_model(cfg.student, only_teacher=only_teacher, img_size=cfg.crops.global_crops_size) diff --git a/OpenMidnight/dinov2/models/vision_transformer.py b/OpenMidnight/dinov2/models/vision_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..74df767eb3f3e45c8012e2637580d4927febd048 --- /dev/null +++ b/OpenMidnight/dinov2/models/vision_transformer.py @@ -0,0 +1,397 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +# References: +# https://github.com/facebookresearch/dino/blob/main/vision_transformer.py +# https://github.com/rwightman/pytorch-image-models/tree/master/timm/models/vision_transformer.py + +from functools import partial +import math +import logging +from typing import Sequence, Tuple, Union, Callable + +import numpy as np +import torch +import torch.nn as nn +import torch.utils.checkpoint +from torch.nn.init import trunc_normal_ + +from dinov2.layers import Mlp, PatchEmbed, SwiGLUFFNFused, MemEffAttention, NestedTensorBlock as Block + + +logger = logging.getLogger("dinov2") + + +def named_apply(fn: Callable, module: nn.Module, name="", depth_first=True, include_root=False) -> nn.Module: + if not depth_first and include_root: + fn(module=module, name=name) + for child_name, child_module in module.named_children(): + child_name = ".".join((name, child_name)) if name else child_name + named_apply(fn=fn, module=child_module, name=child_name, depth_first=depth_first, include_root=True) + if depth_first and include_root: + fn(module=module, name=name) + return module + + +class BlockChunk(nn.ModuleList): + def forward(self, x): + for b in self: + x = b(x) + return x + + +class DinoVisionTransformer(nn.Module): + def __init__( + self, + img_size=224, + patch_size=16, + in_chans=3, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4.0, + qkv_bias=True, + ffn_bias=True, + proj_bias=True, + drop_path_rate=0.0, + drop_path_uniform=False, + init_values=None, # for layerscale: None or 0 => no layerscale + embed_layer=PatchEmbed, + act_layer=nn.GELU, + block_fn=Block, + ffn_layer="mlp", + block_chunks=1, + num_register_tokens=0, + interpolate_antialias=False, + interpolate_offset=0.1, + ): + """ + Args: + img_size (int, tuple): input image size + patch_size (int, tuple): patch size + in_chans (int): number of input channels + embed_dim (int): embedding dimension + depth (int): depth of transformer + num_heads (int): number of attention heads + mlp_ratio (int): ratio of mlp hidden dim to embedding dim + qkv_bias (bool): enable bias for qkv if True + proj_bias (bool): enable bias for proj in attn if True + ffn_bias (bool): enable bias for ffn if True + drop_path_rate (float): stochastic depth rate + drop_path_uniform (bool): apply uniform drop rate across blocks + weight_init (str): weight init scheme + init_values (float): layer-scale init values + embed_layer (nn.Module): patch embedding layer + act_layer (nn.Module): MLP activation layer + block_fn (nn.Module): transformer block class + ffn_layer (str): "mlp", "swiglu", "swiglufused" or "identity" + block_chunks: (int) split block sequence into block_chunks units for FSDP wrap + num_register_tokens: (int) number of extra cls tokens (so-called "registers") + interpolate_antialias: (str) flag to apply anti-aliasing when interpolating positional embeddings + interpolate_offset: (float) work-around offset to apply when interpolating positional embeddings + """ + super().__init__() + norm_layer = partial(nn.LayerNorm, eps=1e-6) + + self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models + self.num_tokens = 1 + self.n_blocks = depth + self.num_heads = num_heads + self.patch_size = patch_size + self.num_register_tokens = num_register_tokens + self.interpolate_antialias = interpolate_antialias + self.interpolate_offset = interpolate_offset + + self.patch_embed = embed_layer(img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim) + num_patches = self.patch_embed.num_patches + + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim)) + assert num_register_tokens >= 0 + self.register_tokens = ( + nn.Parameter(torch.zeros(1, num_register_tokens, embed_dim)) if num_register_tokens else None + ) + + if drop_path_uniform is True: + dpr = [drop_path_rate] * depth + else: + dpr = np.linspace(0, drop_path_rate, depth).tolist() # stochastic depth decay rule + + if ffn_layer == "mlp": + logger.info("using MLP layer as FFN") + ffn_layer = Mlp + elif ffn_layer == "swiglufused" or ffn_layer == "swiglu": + logger.info("using SwiGLU layer as FFN") + ffn_layer = SwiGLUFFNFused + elif ffn_layer == "identity": + logger.info("using Identity layer as FFN") + + def f(*args, **kwargs): + return nn.Identity() + + ffn_layer = f + else: + raise NotImplementedError + + blocks_list = [ + block_fn( + dim=embed_dim, + num_heads=num_heads, + mlp_ratio=mlp_ratio, + qkv_bias=qkv_bias, + proj_bias=proj_bias, + ffn_bias=ffn_bias, + drop_path=dpr[i], + norm_layer=norm_layer, + act_layer=act_layer, + ffn_layer=ffn_layer, + init_values=init_values, + ) + for i in range(depth) + ] + if block_chunks > 0: + self.chunked_blocks = True + chunked_blocks = [] + chunksize = depth // block_chunks + for i in range(0, depth, chunksize): + # this is to keep the block index consistent if we chunk the block list + chunked_blocks.append([nn.Identity()] * i + blocks_list[i : i + chunksize]) + self.blocks = nn.ModuleList([BlockChunk(p) for p in chunked_blocks]) + else: + self.chunked_blocks = False + self.blocks = nn.ModuleList(blocks_list) + + self.norm = norm_layer(embed_dim) + self.head = nn.Identity() + + self.mask_token = nn.Parameter(torch.zeros(1, embed_dim)) + + self.init_weights() + + def init_weights(self): + trunc_normal_(self.pos_embed, std=0.02) + nn.init.normal_(self.cls_token, std=1e-6) + if self.register_tokens is not None: + nn.init.normal_(self.register_tokens, std=1e-6) + named_apply(init_weights_vit_timm, self) + + def interpolate_pos_encoding(self, x, w, h): + previous_dtype = x.dtype + npatch = x.shape[1] - 1 + N = self.pos_embed.shape[1] - 1 + if npatch == N and w == h: + return self.pos_embed + pos_embed = self.pos_embed.float() + class_pos_embed = pos_embed[:, 0] + patch_pos_embed = pos_embed[:, 1:] + dim = x.shape[-1] + w0 = w // self.patch_size + h0 = h // self.patch_size + M = int(math.sqrt(N)) # Recover the number of patches in each dimension + assert N == M * M + kwargs = {} + if self.interpolate_offset: + # Historical kludge: add a small number to avoid floating point error in the interpolation, see https://github.com/facebookresearch/dino/issues/8 + # Note: still needed for backward-compatibility, the underlying operators are using both output size and scale factors + sx = float(w0 + self.interpolate_offset) / M + sy = float(h0 + self.interpolate_offset) / M + kwargs["scale_factor"] = (sx, sy) + else: + # Simply specify an output size instead of a scale factor + kwargs["size"] = (w0, h0) + patch_pos_embed = nn.functional.interpolate( + patch_pos_embed.reshape(1, M, M, dim).permute(0, 3, 1, 2), + mode="bicubic", + antialias=self.interpolate_antialias, + **kwargs, + ) + assert (w0, h0) == patch_pos_embed.shape[-2:] + patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim) + return torch.cat((class_pos_embed.unsqueeze(0), patch_pos_embed), dim=1).to(previous_dtype) + + def prepare_tokens_with_masks(self, x, masks=None): + B, nc, w, h = x.shape + x = self.patch_embed(x) + if masks is not None: + x = torch.where(masks.unsqueeze(-1), self.mask_token.to(x.dtype).unsqueeze(0), x) + + x = torch.cat((self.cls_token.expand(x.shape[0], -1, -1), x), dim=1) + x = x + self.interpolate_pos_encoding(x, w, h) + + if self.register_tokens is not None: + x = torch.cat( + ( + x[:, :1], + self.register_tokens.expand(x.shape[0], -1, -1), + x[:, 1:], + ), + dim=1, + ) + + return x + + def forward_features_list(self, x_list, masks_list): + x = [self.prepare_tokens_with_masks(x, masks) for x, masks in zip(x_list, masks_list)] + for blk in self.blocks: + x = blk(x) + + all_x = x + output = [] + for x, masks in zip(all_x, masks_list): + x_norm = self.norm(x) + output.append( + { + "x_norm_clstoken": x_norm[:, 0], + "x_norm_regtokens": x_norm[:, 1 : self.num_register_tokens + 1], + "x_norm_patchtokens": x_norm[:, self.num_register_tokens + 1 :], + "x_prenorm": x, + "masks": masks, + } + ) + return output + + def forward_features(self, x, masks=None): + if isinstance(x, list): + return self.forward_features_list(x, masks) + + x = self.prepare_tokens_with_masks(x, masks) + + for blk in self.blocks: + x = blk(x) + + x_norm = self.norm(x) + return { + "x_norm_clstoken": x_norm[:, 0], + "x_norm_regtokens": x_norm[:, 1 : self.num_register_tokens + 1], + "x_norm_patchtokens": x_norm[:, self.num_register_tokens + 1 :], + "x_prenorm": x, + "masks": masks, + } + + def _get_intermediate_layers_not_chunked(self, x, n=1): + x = self.prepare_tokens_with_masks(x) + # If n is an int, take the n last blocks. If it's a list, take them + output, total_block_len = [], len(self.blocks) + blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n + for i, blk in enumerate(self.blocks): + x = blk(x) + if i in blocks_to_take: + output.append(x) + assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found" + return output + + def _get_intermediate_layers_chunked(self, x, n=1): + x = self.prepare_tokens_with_masks(x) + output, i, total_block_len = [], 0, len(self.blocks[-1]) + # If n is an int, take the n last blocks. If it's a list, take them + blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n + for block_chunk in self.blocks: + for blk in block_chunk[i:]: # Passing the nn.Identity() + x = blk(x) + if i in blocks_to_take: + output.append(x) + i += 1 + assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found" + return output + + def get_intermediate_layers( + self, + x: torch.Tensor, + n: Union[int, Sequence] = 1, # Layers or n last layers to take + reshape: bool = False, + return_class_token: bool = False, + norm=True, + ) -> Tuple[Union[torch.Tensor, Tuple[torch.Tensor]]]: + if self.chunked_blocks: + outputs = self._get_intermediate_layers_chunked(x, n) + else: + outputs = self._get_intermediate_layers_not_chunked(x, n) + if norm: + outputs = [self.norm(out) for out in outputs] + class_tokens = [out[:, 0] for out in outputs] + outputs = [out[:, 1 + self.num_register_tokens :] for out in outputs] + if reshape: + B, _, w, h = x.shape + outputs = [ + out.reshape(B, w // self.patch_size, h // self.patch_size, -1).permute(0, 3, 1, 2).contiguous() + for out in outputs + ] + if return_class_token: + return tuple(zip(outputs, class_tokens)) + return tuple(outputs) + + def forward(self, *args, is_training=False, **kwargs): + ret = self.forward_features(*args, **kwargs) + if is_training: + return ret + else: + return self.head(ret["x_norm_clstoken"]) + + +def init_weights_vit_timm(module: nn.Module, name: str = ""): + """ViT weight initialization, original timm impl (for reproducibility)""" + if isinstance(module, nn.Linear): + trunc_normal_(module.weight, std=0.02) + if module.bias is not None: + nn.init.zeros_(module.bias) + + +def vit_small(patch_size=16, num_register_tokens=0, **kwargs): + model = DinoVisionTransformer( + patch_size=patch_size, + embed_dim=384, + depth=12, + num_heads=6, + mlp_ratio=4, + block_fn=partial(Block, attn_class=MemEffAttention), + num_register_tokens=num_register_tokens, + **kwargs, + ) + return model + + +def vit_base(patch_size=16, num_register_tokens=0, **kwargs): + model = DinoVisionTransformer( + patch_size=patch_size, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4, + block_fn=partial(Block, attn_class=MemEffAttention), + num_register_tokens=num_register_tokens, + **kwargs, + ) + return model + + +def vit_large(patch_size=16, num_register_tokens=0, **kwargs): + model = DinoVisionTransformer( + patch_size=patch_size, + embed_dim=1024, + depth=24, + num_heads=16, + mlp_ratio=4, + block_fn=partial(Block, attn_class=MemEffAttention), + num_register_tokens=num_register_tokens, + **kwargs, + ) + return model + + +def vit_giant2(patch_size=16, num_register_tokens=0, **kwargs): + """ + Close to ViT-giant, with embed-dim 1536 and 24 heads => embed-dim per head 64 + """ + model = DinoVisionTransformer( + patch_size=patch_size, + embed_dim=1536, + depth=40, + num_heads=24, + mlp_ratio=4, + block_fn=partial(Block, attn_class=MemEffAttention), + num_register_tokens=num_register_tokens, + **kwargs, + ) + return model diff --git a/OpenMidnight/dinov2/run/__init__.py b/OpenMidnight/dinov2/run/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b88da6bf80be92af00b72dfdb0a806fa64a7a2d9 --- /dev/null +++ b/OpenMidnight/dinov2/run/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/OpenMidnight/dinov2/run/eval/knn.py b/OpenMidnight/dinov2/run/eval/knn.py new file mode 100644 index 0000000000000000000000000000000000000000..d11918445cdfe415fe58ac8b3ad0bf29702e3457 --- /dev/null +++ b/OpenMidnight/dinov2/run/eval/knn.py @@ -0,0 +1,59 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +from dinov2.eval.knn import get_args_parser as get_knn_args_parser +from dinov2.logging import setup_logging +from dinov2.run.submit import get_args_parser, submit_jobs + + +logger = logging.getLogger("dinov2") + + +class Evaluator: + def __init__(self, args): + self.args = args + + def __call__(self): + from dinov2.eval.knn import main as knn_main + + self._setup_args() + knn_main(self.args) + + def checkpoint(self): + import submitit + + logger.info(f"Requeuing {self.args}") + empty = type(self)(self.args) + return submitit.helpers.DelayedSubmission(empty) + + def _setup_args(self): + import submitit + + job_env = submitit.JobEnvironment() + self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id)) + logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}") + logger.info(f"Args: {self.args}") + + +def main(): + description = "Submitit launcher for DINOv2 k-NN evaluation" + knn_args_parser = get_knn_args_parser(add_help=False) + parents = [knn_args_parser] + args_parser = get_args_parser(description=description, parents=parents) + args = args_parser.parse_args() + + setup_logging() + + assert os.path.exists(args.config_file), "Configuration file does not exist!" + submit_jobs(Evaluator, args, name="dinov2:knn") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/OpenMidnight/dinov2/run/eval/linear.py b/OpenMidnight/dinov2/run/eval/linear.py new file mode 100644 index 0000000000000000000000000000000000000000..e1dc3293e88512a5cf885ab775dc08e01aed6724 --- /dev/null +++ b/OpenMidnight/dinov2/run/eval/linear.py @@ -0,0 +1,59 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +from dinov2.eval.linear import get_args_parser as get_linear_args_parser +from dinov2.logging import setup_logging +from dinov2.run.submit import get_args_parser, submit_jobs + + +logger = logging.getLogger("dinov2") + + +class Evaluator: + def __init__(self, args): + self.args = args + + def __call__(self): + from dinov2.eval.linear import main as linear_main + + self._setup_args() + linear_main(self.args) + + def checkpoint(self): + import submitit + + logger.info(f"Requeuing {self.args}") + empty = type(self)(self.args) + return submitit.helpers.DelayedSubmission(empty) + + def _setup_args(self): + import submitit + + job_env = submitit.JobEnvironment() + self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id)) + logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}") + logger.info(f"Args: {self.args}") + + +def main(): + description = "Submitit launcher for DINOv2 linear evaluation" + linear_args_parser = get_linear_args_parser(add_help=False) + parents = [linear_args_parser] + args_parser = get_args_parser(description=description, parents=parents) + args = args_parser.parse_args() + + setup_logging() + + assert os.path.exists(args.config_file), "Configuration file does not exist!" + submit_jobs(Evaluator, args, name="dinov2:linear") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/OpenMidnight/dinov2/run/eval/log_regression.py b/OpenMidnight/dinov2/run/eval/log_regression.py new file mode 100644 index 0000000000000000000000000000000000000000..cdf02181122de72cfa463ef38494967219df9cf3 --- /dev/null +++ b/OpenMidnight/dinov2/run/eval/log_regression.py @@ -0,0 +1,59 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +from dinov2.eval.log_regression import get_args_parser as get_log_regression_args_parser +from dinov2.logging import setup_logging +from dinov2.run.submit import get_args_parser, submit_jobs + + +logger = logging.getLogger("dinov2") + + +class Evaluator: + def __init__(self, args): + self.args = args + + def __call__(self): + from dinov2.eval.log_regression import main as log_regression_main + + self._setup_args() + log_regression_main(self.args) + + def checkpoint(self): + import submitit + + logger.info(f"Requeuing {self.args}") + empty = type(self)(self.args) + return submitit.helpers.DelayedSubmission(empty) + + def _setup_args(self): + import submitit + + job_env = submitit.JobEnvironment() + self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id)) + logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}") + logger.info(f"Args: {self.args}") + + +def main(): + description = "Submitit launcher for DINOv2 logistic evaluation" + log_regression_args_parser = get_log_regression_args_parser(add_help=False) + parents = [log_regression_args_parser] + args_parser = get_args_parser(description=description, parents=parents) + args = args_parser.parse_args() + + setup_logging() + + assert os.path.exists(args.config_file), "Configuration file does not exist!" + submit_jobs(Evaluator, args, name="dinov2:logreg") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/OpenMidnight/dinov2/run/submit.py b/OpenMidnight/dinov2/run/submit.py new file mode 100644 index 0000000000000000000000000000000000000000..3f598c29f24a204dd4c3b8cc9834f9342597e93b --- /dev/null +++ b/OpenMidnight/dinov2/run/submit.py @@ -0,0 +1,122 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import argparse +import logging +import os +from pathlib import Path +from typing import List, Optional + +import submitit + +from dinov2.utils.cluster import ( + get_slurm_executor_parameters, + get_slurm_partition, + get_user_checkpoint_path, +) + + +logger = logging.getLogger("dinov2") + + +def get_args_parser( + description: Optional[str] = None, + parents: Optional[List[argparse.ArgumentParser]] = None, + add_help: bool = True, +) -> argparse.ArgumentParser: + parents = parents or [] + slurm_partition = get_slurm_partition() + parser = argparse.ArgumentParser( + description=description, + parents=parents, + add_help=add_help, + ) + parser.add_argument( + "--ngpus", + "--gpus", + "--gpus-per-node", + default=8, + type=int, + help="Number of GPUs to request on each node", + ) + parser.add_argument( + "--nodes", + "--nnodes", + default=1, + type=int, + help="Number of nodes to request", + ) + parser.add_argument( + "--timeout", + default=2800, + type=int, + help="Duration of the job", + ) + parser.add_argument( + "--partition", + default=slurm_partition, + type=str, + help="Partition where to submit", + ) + parser.add_argument( + "--use-volta32", + action="store_true", + help="Request V100-32GB GPUs", + ) + parser.add_argument( + "--comment", + default="", + type=str, + help="Comment to pass to scheduler, e.g. priority message", + ) + parser.add_argument( + "--exclude", + default="", + type=str, + help="Nodes to exclude", + ) + return parser + + +def get_shared_folder() -> Path: + user_checkpoint_path = get_user_checkpoint_path() + if user_checkpoint_path is None: + raise RuntimeError("Path to user checkpoint cannot be determined") + path = user_checkpoint_path / "experiments" + path.mkdir(exist_ok=True) + return path + + +def submit_jobs(task_class, args, name: str): + if not args.output_dir: + args.output_dir = str(get_shared_folder() / "%j") + + Path(args.output_dir).mkdir(parents=True, exist_ok=True) + executor = submitit.AutoExecutor(folder=args.output_dir, slurm_max_num_timeout=30) + + kwargs = {} + if args.use_volta32: + kwargs["slurm_constraint"] = "volta32gb" + if args.comment: + kwargs["slurm_comment"] = args.comment + if args.exclude: + kwargs["slurm_exclude"] = args.exclude + + executor_params = get_slurm_executor_parameters( + nodes=args.nodes, + num_gpus_per_node=1, + timeout_min=args.timeout, # max is 60 * 72 + slurm_signal_delay_s=120, + slurm_partition=args.partition, + **kwargs, + ) + executor.update_parameters(name=name, **executor_params) + + task = task_class(args) + job = executor.submit(task) + + logger.info(f"Submitted job_id: {job.job_id}") + str_output_dir = os.path.abspath(args.output_dir).replace("%j", str(job.job_id)) + logger.info(f"Logs and checkpoints will be saved at: {str_output_dir}") diff --git a/OpenMidnight/dinov2/run/train/train.py b/OpenMidnight/dinov2/run/train/train.py new file mode 100644 index 0000000000000000000000000000000000000000..c2366e9bf79765e6abcd70dda6b43f31cb7093eb --- /dev/null +++ b/OpenMidnight/dinov2/run/train/train.py @@ -0,0 +1,59 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +from dinov2.logging import setup_logging +from dinov2.train import get_args_parser as get_train_args_parser +from dinov2.run.submit import get_args_parser, submit_jobs + + +logger = logging.getLogger("dinov2") + + +class Trainer(object): + def __init__(self, args): + self.args = args + + def __call__(self): + from dinov2.train import main as train_main + + self._setup_args() + train_main(self.args) + + def checkpoint(self): + import submitit + + logger.info(f"Requeuing {self.args}") + empty = type(self)(self.args) + return submitit.helpers.DelayedSubmission(empty) + + def _setup_args(self): + import submitit + + job_env = submitit.JobEnvironment() + self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id)) + logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}") + logger.info(f"Args: {self.args}") + + +def main(): + description = "Submitit launcher for DINOv2 training" + train_args_parser = get_train_args_parser(add_help=False) + parents = [train_args_parser] + args_parser = get_args_parser(description=description, parents=parents) + args = args_parser.parse_args() + + setup_logging() + + assert os.path.exists(args.config_file), "Configuration file does not exist!" + submit_jobs(Trainer, args, name="dinov2:train") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/OpenMidnight/dinov2/thirdparty/CLIP/LICENSE b/OpenMidnight/dinov2/thirdparty/CLIP/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..c123b69334717d178daa674c2d08e3383fe36134 --- /dev/null +++ b/OpenMidnight/dinov2/thirdparty/CLIP/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 OpenAI + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/OpenMidnight/dinov2/thirdparty/CLIP/clip/simple_tokenizer.py b/OpenMidnight/dinov2/thirdparty/CLIP/clip/simple_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..0b1a6b1470840ca66638524fbd541d5bdf67b4f8 --- /dev/null +++ b/OpenMidnight/dinov2/thirdparty/CLIP/clip/simple_tokenizer.py @@ -0,0 +1,135 @@ +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~") + 1)) + list(range(ord("¡"), ord("¬") + 1)) + list(range(ord("®"), ord("ÿ") + 1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8 + n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r"\s+", " ", text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe()): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split("\n") + merges = merges[1 : 49152 - 256 - 2 + 1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v + "" for v in vocab] + for merge in merges: + vocab.append("".join(merge)) + vocab.extend(["<|startoftext|>", "<|endoftext|>"]) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {"<|startoftext|>": "<|startoftext|>", "<|endoftext|>": "<|endoftext|>"} + self.pat = re.compile( + r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", + re.IGNORECASE, + ) + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + (token[-1] + "",) + pairs = get_pairs(word) + + if not pairs: + return token + "" + + while True: + bigram = min(pairs, key=lambda pair: self.bpe_ranks.get(pair, float("inf"))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except Exception: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word) - 1 and word[i + 1] == second: + new_word.append(first + second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = " ".join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = "".join(self.byte_encoder[b] for b in token.encode("utf-8")) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(" ")) + return bpe_tokens + + def decode(self, tokens): + text = "".join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode("utf-8", errors="replace").replace("", " ") + return text diff --git a/OpenMidnight/dinov2/train/__init__.py b/OpenMidnight/dinov2/train/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5f1752922d04fff0112eb7796be28ff6b68c6073 --- /dev/null +++ b/OpenMidnight/dinov2/train/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from .train import get_args_parser, main +from .ssl_meta_arch import SSLMetaArch diff --git a/OpenMidnight/dinov2/train/ssl_meta_arch.py b/OpenMidnight/dinov2/train/ssl_meta_arch.py new file mode 100644 index 0000000000000000000000000000000000000000..4bc28caf34464b22a0cbf5cb0067d1c2d1be45b5 --- /dev/null +++ b/OpenMidnight/dinov2/train/ssl_meta_arch.py @@ -0,0 +1,463 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from functools import partial +import logging + +import torch +from torch import nn + +from dinov2.loss import DINOLoss, iBOTPatchLoss, KoLeoLoss, KDELoss +from dinov2.models import build_model_from_cfg +from dinov2.layers import DINOHead +from dinov2.utils.utils import has_batchnorms +from dinov2.utils.param_groups import get_params_groups_with_decay, fuse_params_groups +from dinov2.fsdp import get_fsdp_wrapper, ShardedGradScaler, get_fsdp_modules, reshard_fsdp_model + +from dinov2.models.vision_transformer import BlockChunk + + +try: + from xformers.ops import fmha +except ImportError: + raise AssertionError("xFormers is required for training") + + +logger = logging.getLogger("dinov2") + + +class SSLMetaArch(nn.Module): + def __init__(self, cfg): + super().__init__() + self.cfg = cfg + self.fp16_scaler = ShardedGradScaler() if cfg.compute_precision.grad_scaler else None + + student_model_dict = dict() + teacher_model_dict = dict() + + student_backbone, teacher_backbone, embed_dim = build_model_from_cfg(cfg) + student_model_dict["backbone"] = student_backbone + teacher_model_dict["backbone"] = teacher_backbone + logger.info(f"OPTIONS -- architecture : embed_dim: {embed_dim}") + + if cfg.student.pretrained_weights: + chkpt = torch.load(cfg.student.pretrained_weights) + logger.info(f"OPTIONS -- pretrained weights: loading from {cfg.student.pretrained_weights}") + student_backbone.load_state_dict(chkpt["model"], strict=False) + + self.embed_dim = embed_dim + self.dino_out_dim = cfg.dino.head_n_prototypes + + self.do_dino = cfg.dino.loss_weight > 0 + self.do_koleo = cfg.dino.koleo_loss_weight > 0 + self.do_kde = cfg.dino.kde_loss_weight > 0 + self.do_ibot = cfg.ibot.loss_weight > 0 + self.ibot_separate_head = cfg.ibot.separate_head + + logger.info("OPTIONS -- DINO") + if self.do_dino: + logger.info(f"OPTIONS -- DINO -- loss_weight: {cfg.dino.loss_weight}") + logger.info(f"OPTIONS -- DINO -- head_n_prototypes: {cfg.dino.head_n_prototypes}") + logger.info(f"OPTIONS -- DINO -- head_bottleneck_dim: {cfg.dino.head_bottleneck_dim}") + logger.info(f"OPTIONS -- DINO -- head_hidden_dim: {cfg.dino.head_hidden_dim}") + self.dino_loss_weight = cfg.dino.loss_weight + dino_head = partial( + DINOHead, + in_dim=embed_dim, + out_dim=cfg.dino.head_n_prototypes, + hidden_dim=cfg.dino.head_hidden_dim, + bottleneck_dim=cfg.dino.head_bottleneck_dim, + nlayers=cfg.dino.head_nlayers, + ) + self.dino_loss = DINOLoss(self.dino_out_dim) + if self.do_koleo: + logger.info("OPTIONS -- DINO -- applying KOLEO regularization") + self.koleo_loss = KoLeoLoss() + if self.do_kde: + logger.info("OPTIONS -- DINO -- apply KDE regularization") + self.kde_loss = KDELoss() + + else: + logger.info("OPTIONS -- DINO -- not using DINO") + + if self.do_dino or self.do_ibot: + student_model_dict["dino_head"] = dino_head() + teacher_model_dict["dino_head"] = dino_head() + + logger.info("OPTIONS -- IBOT") + logger.info(f"OPTIONS -- IBOT -- loss_weight: {cfg.ibot.loss_weight}") + logger.info(f"OPTIONS -- IBOT masking -- ibot_mask_ratio_tuple: {cfg.ibot.mask_ratio_min_max}") + logger.info(f"OPTIONS -- IBOT masking -- ibot_mask_sample_probability: {cfg.ibot.mask_sample_probability}") + if self.do_ibot: + self.ibot_loss_weight = cfg.ibot.loss_weight + assert max(cfg.ibot.mask_ratio_min_max) > 0, "please provide a positive mask ratio tuple for ibot" + assert cfg.ibot.mask_sample_probability > 0, "please provide a positive mask probability for ibot" + self.ibot_out_dim = cfg.ibot.head_n_prototypes if self.ibot_separate_head else cfg.dino.head_n_prototypes + self.ibot_patch_loss = iBOTPatchLoss(self.ibot_out_dim) + if self.ibot_separate_head: + logger.info(f"OPTIONS -- IBOT -- loss_weight: {cfg.ibot.loss_weight}") + logger.info(f"OPTIONS -- IBOT -- head_n_prototypes: {cfg.ibot.head_n_prototypes}") + logger.info(f"OPTIONS -- IBOT -- head_bottleneck_dim: {cfg.ibot.head_bottleneck_dim}") + logger.info(f"OPTIONS -- IBOT -- head_hidden_dim: {cfg.ibot.head_hidden_dim}") + ibot_head = partial( + DINOHead, + in_dim=embed_dim, + out_dim=cfg.ibot.head_n_prototypes, + hidden_dim=cfg.ibot.head_hidden_dim, + bottleneck_dim=cfg.ibot.head_bottleneck_dim, + nlayers=cfg.ibot.head_nlayers, + ) + student_model_dict["ibot_head"] = ibot_head() + teacher_model_dict["ibot_head"] = ibot_head() + else: + logger.info("OPTIONS -- IBOT -- head shared with DINO") + + self.need_to_synchronize_fsdp_streams = True + + self.student = nn.ModuleDict(student_model_dict) + self.teacher = nn.ModuleDict(teacher_model_dict) + + # there is no backpropagation through the teacher, so no need for gradients + for p in self.teacher.parameters(): + p.requires_grad = False + + # ---- Gram anchoring (DINOv3 기법 이식) ---- + # 얼린 앵커(=좋은 peak 체크포인트)의 patch 구조에 student를 붙잡아 학습 후반 degradation 방지. + self.do_gram = bool(getattr(cfg, "gram", None)) and bool(cfg.gram.use_loss) + if self.do_gram: + from dinov2.loss import GramLoss + _, gram_teacher_backbone, _ = build_model_from_cfg(cfg) + self.gram_teacher = nn.ModuleDict({"backbone": gram_teacher_backbone}) + self.gram_teacher.requires_grad_(False) + self.gram_loss = GramLoss( + apply_norm=cfg.gram.get("normalized", True), + remove_neg=cfg.gram.get("remove_neg", True), + ) + self.gram_loss_weight = cfg.gram.loss_weight + self.gram_it_first_update = int(cfg.gram.it_first_update) + self.gram_ckpt = cfg.gram.ckpt + # 앵커 가중치 로드(teacher_checkpoint의 backbone.* 추출) — FSDP 전(plain module)에서. + ck = torch.load(self.gram_ckpt, map_location="cpu", weights_only=False) + t = ck["teacher"] if "teacher" in ck else ck + sd = {k[len("backbone."):]: v for k, v in t.items() if k.startswith("backbone.")} + miss, unexp = self.gram_teacher["backbone"].load_state_dict(sd, strict=False) + logger.info(f"GRAM anchor loaded from {self.gram_ckpt}: missing={len(miss)} unexpected={len(unexp)}, " + f"it_first_update={self.gram_it_first_update} weight={self.gram_loss_weight}") + + logger.info(f"Student and Teacher are built: they are both {cfg.student.arch} network.") + + def forward(self, inputs): + raise NotImplementedError + + def backprop_loss(self, loss): + if self.fp16_scaler is not None: + self.fp16_scaler.scale(loss).backward() + else: + loss.backward() + + def forward_backward(self, images, teacher_temp, gram_weight=0.0): + n_global_crops = 2 + assert n_global_crops == 2 + n_local_crops = self.cfg.crops.local_crops_number + + global_crops = images["collated_global_crops"].cuda(non_blocking=True) + local_crops = images["collated_local_crops"].cuda(non_blocking=True) + + masks = images["collated_masks"].cuda(non_blocking=True) + mask_indices_list = images["mask_indices_list"].cuda(non_blocking=True) + n_masked_patches_tensor = images["n_masked_patches"].cuda(non_blocking=True) + n_masked_patches = mask_indices_list.shape[0] + upperbound = images["upperbound"] + masks_weight = images["masks_weight"].cuda(non_blocking=True) + + n_local_crops_loss_terms = max(n_local_crops * n_global_crops, 1) + n_global_crops_loss_terms = (n_global_crops - 1) * n_global_crops + + do_dino = self.do_dino + do_ibot = self.do_ibot + + # loss scales + ibot_loss_scale = 1.0 / n_global_crops + + # teacher output + @torch.no_grad() + def get_teacher_output(): + x, n_global_crops_teacher = global_crops, n_global_crops + teacher_backbone_output_dict = self.teacher.backbone(x, is_training=True) + teacher_cls_tokens = teacher_backbone_output_dict["x_norm_clstoken"] + teacher_cls_tokens = teacher_cls_tokens.chunk(n_global_crops_teacher) + # watch out: these are chunked and cat'd in reverse so A is matched to B in the global crops dino loss + teacher_cls_tokens = torch.cat((teacher_cls_tokens[1], teacher_cls_tokens[0])) + ibot_teacher_patch_tokens = teacher_backbone_output_dict["x_norm_patchtokens"] + _dim = ibot_teacher_patch_tokens.shape[-1] + n_cls_tokens = teacher_cls_tokens.shape[0] + + if do_ibot and not self.ibot_separate_head: + buffer_tensor_teacher = ibot_teacher_patch_tokens.new_zeros(upperbound + n_cls_tokens, _dim) + buffer_tensor_teacher[:n_cls_tokens].copy_(teacher_cls_tokens) + torch.index_select( + ibot_teacher_patch_tokens.flatten(0, 1), + dim=0, + index=mask_indices_list, + out=buffer_tensor_teacher[n_cls_tokens : n_cls_tokens + n_masked_patches], + ) + tokens_after_head = self.teacher.dino_head(buffer_tensor_teacher) + teacher_cls_tokens_after_head = tokens_after_head[:n_cls_tokens] + masked_teacher_patch_tokens_after_head = tokens_after_head[ + n_cls_tokens : n_cls_tokens + n_masked_patches + ] + elif do_ibot and self.ibot_separate_head: + buffer_tensor_teacher = ibot_teacher_patch_tokens.new_zeros(upperbound, _dim) + torch.index_select( + ibot_teacher_patch_tokens.flatten(0, 1), + dim=0, + index=mask_indices_list, + out=buffer_tensor_teacher[:n_masked_patches], + ) + teacher_cls_tokens_after_head = self.teacher.dino_head(teacher_cls_tokens) + masked_teacher_patch_tokens_after_head = self.teacher.ibot_head(buffer_tensor_teacher)[ + :n_masked_patches + ] + else: + teacher_cls_tokens_after_head = self.teacher.dino_head(teacher_cls_tokens) + masked_teacher_ibot_softmaxed_centered = None + + if self.cfg.train.centering == "centering": + teacher_dino_softmaxed_centered_list = self.dino_loss.softmax_center_teacher( + teacher_cls_tokens_after_head, teacher_temp=teacher_temp + ).view(n_global_crops_teacher, -1, *teacher_cls_tokens_after_head.shape[1:]) + self.dino_loss.update_center(teacher_cls_tokens_after_head) + if do_ibot: + masked_teacher_patch_tokens_after_head = masked_teacher_patch_tokens_after_head.unsqueeze(0) + masked_teacher_ibot_softmaxed_centered = self.ibot_patch_loss.softmax_center_teacher( + masked_teacher_patch_tokens_after_head[:, :n_masked_patches], teacher_temp=teacher_temp + ) + masked_teacher_ibot_softmaxed_centered = masked_teacher_ibot_softmaxed_centered.squeeze(0) + self.ibot_patch_loss.update_center(masked_teacher_patch_tokens_after_head[:n_masked_patches]) + + elif self.cfg.train.centering == "sinkhorn_knopp": + teacher_dino_softmaxed_centered_list = self.dino_loss.sinkhorn_knopp_teacher( + teacher_cls_tokens_after_head, teacher_temp=teacher_temp + ).view(n_global_crops_teacher, -1, *teacher_cls_tokens_after_head.shape[1:]) + + if do_ibot: + masked_teacher_ibot_softmaxed_centered = self.ibot_patch_loss.sinkhorn_knopp_teacher( + masked_teacher_patch_tokens_after_head, + teacher_temp=teacher_temp, + n_masked_patches_tensor=n_masked_patches_tensor, + ) + + else: + raise NotImplementedError + + return teacher_dino_softmaxed_centered_list, masked_teacher_ibot_softmaxed_centered + + teacher_dino_softmaxed_centered_list, masked_teacher_ibot_softmaxed_centered = get_teacher_output() + reshard_fsdp_model(self.teacher) + + loss_dict = {} + + loss_accumulator = 0 # for backprop + student_global_backbone_output_dict, student_local_backbone_output_dict = self.student.backbone( + [global_crops, local_crops], masks=[masks, None], is_training=True + ) + + # ---- Gram anchoring loss (it_first_update 이후 gram_weight>0일 때만) ---- + # global crop의 student patch 구조를 얼린 앵커(peak)와 가깝게 유지 → 후반 degradation 방지. + if self.do_gram and gram_weight > 0: + with torch.no_grad(): + gram_teacher_patch = self.gram_teacher["backbone"](global_crops, is_training=True)["x_norm_patchtokens"] + reshard_fsdp_model(self.gram_teacher) + gram_student_patch = student_global_backbone_output_dict["x_norm_patchtokens"] + gram_loss = self.gram_loss(gram_student_patch, gram_teacher_patch, img_level=True) + loss_dict["gram_loss"] = gram_loss + loss_accumulator = loss_accumulator + gram_weight * gram_loss + + inputs_for_student_head_list = [] + + # 1a: local crops cls tokens + student_local_cls_tokens = student_local_backbone_output_dict["x_norm_clstoken"] + inputs_for_student_head_list.append(student_local_cls_tokens.unsqueeze(0)) + + # 1b: global crops cls tokens + student_global_cls_tokens = student_global_backbone_output_dict["x_norm_clstoken"] + inputs_for_student_head_list.append(student_global_cls_tokens.unsqueeze(0)) + + # 1c: global crops patch tokens + if do_ibot: + _dim = student_global_backbone_output_dict["x_norm_clstoken"].shape[-1] + ibot_student_patch_tokens = student_global_backbone_output_dict["x_norm_patchtokens"] + buffer_tensor_patch_tokens = ibot_student_patch_tokens.new_zeros(upperbound, _dim) + buffer_tensor_patch_tokens[:n_masked_patches].copy_( + torch.index_select(ibot_student_patch_tokens.flatten(0, 1), dim=0, index=mask_indices_list) + ) + if not self.ibot_separate_head: + inputs_for_student_head_list.append(buffer_tensor_patch_tokens.unsqueeze(0)) + else: + student_global_masked_patch_tokens_after_head = self.student.ibot_head(buffer_tensor_patch_tokens)[ + :n_masked_patches + ] + + # 2: run + _attn_bias, cat_inputs = fmha.BlockDiagonalMask.from_tensor_list(inputs_for_student_head_list) + outputs_list = _attn_bias.split(self.student.dino_head(cat_inputs)) + + # 3a: local crops cls tokens + student_local_cls_tokens_after_head = outputs_list.pop(0).squeeze(0) + + # 3b: global crops cls tokens + student_global_cls_tokens_after_head = outputs_list.pop(0).squeeze(0) + + # 3c: global crops patch tokens + if do_ibot and not self.ibot_separate_head: + student_global_masked_patch_tokens_after_head = outputs_list.pop(0).squeeze(0)[:n_masked_patches] + + if n_local_crops > 0: + dino_local_crops_loss = self.dino_loss( + student_output_list=student_local_cls_tokens_after_head.chunk(n_local_crops), + teacher_out_softmaxed_centered_list=teacher_dino_softmaxed_centered_list, + ) / (n_global_crops_loss_terms + n_local_crops_loss_terms) + + # store for display + loss_dict["dino_local_crops_loss"] = dino_local_crops_loss + + # accumulate loss + loss_accumulator += self.dino_loss_weight * dino_local_crops_loss + + # process global crops + loss_scales = 2 # this is here since we process global crops together + + if do_dino: + # compute loss + dino_global_crops_loss = ( + self.dino_loss( + student_output_list=[student_global_cls_tokens_after_head], + teacher_out_softmaxed_centered_list=[ + teacher_dino_softmaxed_centered_list.flatten(0, 1) + ], # these were chunked and stacked in reverse so A is matched to B + ) + * loss_scales + / (n_global_crops_loss_terms + n_local_crops_loss_terms) + ) + + loss_dict["dino_global_crops_loss"] = dino_global_crops_loss + + # accumulate loss + loss_accumulator += self.dino_loss_weight * dino_global_crops_loss + + student_cls_tokens = student_global_cls_tokens + + if self.do_koleo: + print("doing koleo") + koleo_loss = self.cfg.dino.koleo_loss_weight * sum( + self.koleo_loss(p) for p in student_cls_tokens.chunk(2) + ) # we don't apply koleo loss between cls tokens of a same image + loss_accumulator += koleo_loss + loss_dict["koleo_loss"] = ( + koleo_loss / loss_scales + ) # this is to display the same losses as before but we can remove eventually + print(self.cfg.dino.koleo_loss_weight) + + if self.do_kde: + kde_loss = self.cfg.dino.kde_loss_weight * sum( + self.kde_loss(p) for p in student_cls_tokens.chunk(2) + ) # we don't apply koleo loss between cls tokens of a same image + loss_accumulator += kde_loss + loss_dict["kde_loss"] = ( + kde_loss / loss_scales + ) # this is to display the same losses as before but we can remove eventually + + + if do_ibot: + # compute loss + ibot_patch_loss = ( + self.ibot_patch_loss.forward_masked( + student_global_masked_patch_tokens_after_head, + masked_teacher_ibot_softmaxed_centered, + student_masks_flat=masks, + n_masked_patches=n_masked_patches, + masks_weight=masks_weight, + ) + * loss_scales + * ibot_loss_scale + ) + + # store for display + loss_dict["ibot_loss"] = ibot_patch_loss / 2 + + # accumulate loss + loss_accumulator += self.ibot_loss_weight * ibot_patch_loss + + self.backprop_loss(loss_accumulator) + + self.fsdp_synchronize_streams() + + return loss_dict + + def fsdp_synchronize_streams(self): + if self.need_to_synchronize_fsdp_streams: + torch.cuda.synchronize() + for attr in {"_unshard_stream", "_post_backward_stream", "_pre_unshard_stream", "_all_reduce_stream", "_default_stream"}: + stream = getattr(self.teacher.backbone, attr) + setattr(self.student.dino_head, attr, stream) + setattr(self.teacher.dino_head, attr, stream) + setattr(self.student.backbone, attr, stream) + self.need_to_synchronize_fsdp_streams = False + + def update_teacher(self, m): + student_param_list = [] + teacher_param_list = [] + with torch.no_grad(): + for k in self.student.keys(): + for ms, mt in zip(get_fsdp_modules(self.student[k]), get_fsdp_modules(self.teacher[k])): + student_param_list += ms.params + teacher_param_list += mt.params + torch._foreach_mul_(teacher_param_list, m) + torch._foreach_add_(teacher_param_list, student_param_list, alpha=1 - m) + + def train(self): + super().train() + self.teacher.eval() + + def get_maybe_fused_params_for_submodel(self, m): + params_groups = get_params_groups_with_decay( + model=m, + lr_decay_rate=self.cfg.optim.layerwise_decay, + patch_embed_lr_mult=self.cfg.optim.patch_embed_lr_mult, + ) + fused_params_groups = fuse_params_groups(params_groups) + logger.info("fusing param groups") + + for g in fused_params_groups: + g["foreach"] = True + return fused_params_groups + + def get_params_groups(self): + all_params_groups = [] + for m in self.student.values(): + all_params_groups += self.get_maybe_fused_params_for_submodel(m) + return all_params_groups + + def prepare_for_distributed_training(self): + logger.info("DISTRIBUTED FSDP -- preparing model for distributed training") + if has_batchnorms(self.student): + raise NotImplementedError + # below will synchronize all student subnetworks across gpus: + for k, v in self.student.items(): + self.teacher[k].load_state_dict(self.student[k].state_dict()) + student_model_cfg = self.cfg.compute_precision.student[k] + self.student[k] = get_fsdp_wrapper(student_model_cfg, modules_to_wrap={BlockChunk})(self.student[k]) + teacher_model_cfg = self.cfg.compute_precision.teacher[k] + self.teacher[k] = get_fsdp_wrapper(teacher_model_cfg, modules_to_wrap={BlockChunk})(self.teacher[k]) + + # ★ gram_teacher: 앵커 가중치 유지(student 동기화 안 함) + 얼린 채 FSDP wrap. + if self.do_gram: + gram_cfg = self.cfg.compute_precision.teacher["backbone"] + self.gram_teacher["backbone"] = get_fsdp_wrapper(gram_cfg, modules_to_wrap={BlockChunk})( + self.gram_teacher["backbone"] + ) + self.gram_teacher.eval() + for p in self.gram_teacher.parameters(): + p.requires_grad = False diff --git a/OpenMidnight/dinov2/train/train.py b/OpenMidnight/dinov2/train/train.py new file mode 100644 index 0000000000000000000000000000000000000000..a310ce779239d7fac97645e07f9e1b7cfd956ff3 --- /dev/null +++ b/OpenMidnight/dinov2/train/train.py @@ -0,0 +1,1337 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import argparse +import logging +import math +import os +import random +from functools import partial +import itertools +from io import BytesIO +from pathlib import Path +import gc +import contextlib +import glob + +from fvcore.common.checkpoint import PeriodicCheckpointer +import torch + +from dinov2.data import collate_data_and_cast, DataAugmentationDINO, MaskingGenerator +import dinov2.distributed as distributed +from dinov2.fsdp import FSDPCheckpointer +from dinov2.logging import MetricLogger +from dinov2.utils.config import setup +from dinov2.utils.utils import CosineScheduler + +from dinov2.train.ssl_meta_arch import SSLMetaArch +from dinov2.models import build_model_from_cfg +from datasets import IterableDatasetDict, load_dataset, DownloadConfig +from PIL import Image, ImageOps +import h5py +import numpy as np +import torch.utils.data +from torchvision import transforms +from torchvision.datasets import folder +from tqdm import tqdm + +import pyarrow +import pyarrow.dataset +import torch.distributed as dist +import torch.nn.functional as F + +import pyarrow +import pyarrow.dataset +import torch.distributed as dist +from torch.distributed.fsdp import ( + FullyShardedDataParallel as FSDP, + StateDictType, + FullStateDictConfig, +) + +torch.backends.cuda.matmul.allow_tf32 = True # PyTorch 1.12 sets this to False by default +logger = logging.getLogger("dinov2") +import wandb + +RUN_SCRIPT = os.environ.get("DINOV2_RUN_SCRIPT", "") +AUGMENTATION_FILE = Path(__file__).resolve().parents[1] / "data" / "augmentations.py" +VISION_TRANSFORMER_FILE = Path(__file__).resolve().parents[1] / "models" / "vision_transformer.py" +SSL_META_ARCH = Path(__file__).resolve().parents[1] / "train" / "ssl_meta_arch.py" + +def _build_streaming_dataset( + dataset_path: str, + *, + shuffle_buffer: int, + base_seed: int = 0, + fragment_prefetch_limit: int = 4, + fragment_range_size: int = 32 << 20, + epoch: int = 0, +): + # Get current rank/size at call time (safe under elastic restarts) + world_size = dist.get_world_size() if dist.is_available() and dist.is_initialized() else 1 + global_rank = dist.get_rank() if dist.is_available() and dist.is_initialized() else 0 + + fragment_scan_options = pyarrow.dataset.ParquetFragmentScanOptions( + cache_options=pyarrow.CacheOptions( + prefetch_limit=fragment_prefetch_limit, + range_size_limit=fragment_range_size, + ), + ) + + # 로컬 parquet glob(Test B: 다운로드된 TCGA-12K) vs HF repo id 자동 분기 + if "*" in dataset_path or dataset_path.startswith("/"): + ds = load_dataset("parquet", data_files=dataset_path, streaming=True, split="train") + else: + ds = load_dataset( + dataset_path, + streaming=True, + fragment_scan_options=fragment_scan_options, + )["train"] + + # 1) shard first to avoid cross-rank duplication and wasted I/O + if world_size > 1: + ds = ds.shard(num_shards=world_size, index=global_rank) + + # 2) then shuffle; vary by epoch and rank + seed = base_seed + epoch * 1_000_000 + global_rank * 10000 + ds = ds.shuffle(buffer_size=shuffle_buffer, seed=seed) + return ds + +def get_args_parser(add_help: bool = True): + parser = argparse.ArgumentParser("DINOv2 training", add_help=add_help) + parser.add_argument("--config-file", default="", metavar="FILE", help="path to config file") + parser.add_argument( + "--no-resume", + action="store_true", + help="Whether to not attempt to resume from the checkpoint directory. ", + ) + parser.add_argument("--eval-only", action="store_true", help="perform evaluation only") + parser.add_argument("--eval", type=str, default="", help="Eval type to perform") + parser.add_argument( + "opts", + help=""" +Modify config options at the end of the command. For Yacs configs, use +space-separated "PATH.KEY VALUE" pairs. +For python-based LazyConfig, use "path.key=value". + """.strip(), + default=None, + nargs=argparse.REMAINDER, + ) + parser.add_argument( + "--output-dir", + "--output_dir", + default="", + type=str, + help="Output directory to save logs and checkpoints", + ) + + return parser + + +def build_optimizer(cfg, params_groups): + return torch.optim.AdamW(params_groups, betas=(cfg.optim.adamw_beta1, cfg.optim.adamw_beta2)) + + +def build_schedulers(cfg): + OFFICIAL_EPOCH_LENGTH = cfg.train.OFFICIAL_EPOCH_LENGTH + lr = dict( + base_value=cfg.optim["lr"], + final_value=cfg.optim["min_lr"], + total_iters=cfg.optim["epochs"] * OFFICIAL_EPOCH_LENGTH, + warmup_iters=cfg.optim["warmup_epochs"] * OFFICIAL_EPOCH_LENGTH, + start_warmup_value=0, + ) + wd = dict( + base_value=cfg.optim["weight_decay"], + final_value=cfg.optim["weight_decay_end"], + total_iters=cfg.optim["epochs"] * OFFICIAL_EPOCH_LENGTH, + ) + momentum = dict( + base_value=cfg.teacher["momentum_teacher"], + final_value=cfg.teacher["final_momentum_teacher"], + total_iters=cfg.optim["epochs"] * OFFICIAL_EPOCH_LENGTH, + ) + teacher_temp = dict( + base_value=cfg.teacher["teacher_temp"], + final_value=cfg.teacher["teacher_temp"], + total_iters=cfg.teacher["warmup_teacher_temp_epochs"] * OFFICIAL_EPOCH_LENGTH, + warmup_iters=cfg.teacher["warmup_teacher_temp_epochs"] * OFFICIAL_EPOCH_LENGTH, + start_warmup_value=cfg.teacher["warmup_teacher_temp"], + ) + + lr_schedule = CosineScheduler(**lr) + wd_schedule = CosineScheduler(**wd) + momentum_schedule = CosineScheduler(**momentum) + teacher_temp_schedule = CosineScheduler(**teacher_temp) + last_layer_lr_schedule = CosineScheduler(**lr) + + last_layer_lr_schedule.schedule[ + : cfg.optim["freeze_last_layer_epochs"] * OFFICIAL_EPOCH_LENGTH + ] = 0 # mimicking the original schedules + + # ★ Gram anchoring 가중치 스케줄: it_first_update까지 0 → ramp 구간 선형 상승 → 이후 상수. + class _GramWeightSchedule: + def __init__(self, first_update, weight, ramp=5000): + self.first_update = int(first_update); self.weight = float(weight); self.ramp = max(int(ramp), 1) + def __getitem__(self, it): + if not self.first_update or it < self.first_update: + return 0.0 + return self.weight * min(1.0, (it - self.first_update) / self.ramp) + + if getattr(cfg, "gram", None) and cfg.gram.use_loss: + gram_weight_schedule = _GramWeightSchedule( + cfg.gram.it_first_update, cfg.gram.loss_weight, cfg.gram.get("ramp_iters", 5000) + ) + else: + gram_weight_schedule = _GramWeightSchedule(0, 0.0) # 항상 0 + + logger.info("Schedulers ready.") + + return ( + lr_schedule, + wd_schedule, + momentum_schedule, + teacher_temp_schedule, + last_layer_lr_schedule, + gram_weight_schedule, + ) + + +def apply_optim_scheduler(optimizer, lr, wd, last_layer_lr): + for param_group in optimizer.param_groups: + is_last_layer = param_group["is_last_layer"] + lr_multiplier = param_group["lr_multiplier"] + wd_multiplier = param_group["wd_multiplier"] + param_group["weight_decay"] = wd * wd_multiplier + param_group["lr"] = (last_layer_lr if is_last_layer else lr) * lr_multiplier + +_FULL_STATE_DICT_CFG = FullStateDictConfig(offload_to_cpu=True, rank0_only=True) + +_HUB_ARCH_NAMES = { + "vit_small": "vits", + "vit_base": "vitb", + "vit_large": "vitl", + "vit_giant2": "vitg", +} + + +def _resolve_torchhub_name(cfg): + hub_arch = _HUB_ARCH_NAMES.get(cfg.student.arch) + if hub_arch is None: + raise AssertionError(f"Unsupported student arch for pretrained load: {cfg.student.arch}") + if cfg.student.patch_size != 14: + raise AssertionError("Pretrained torch.hub weights are only defined for patch_size=14") + if cfg.student.num_register_tokens not in (0, 4): + raise AssertionError("Pretrained weights only support 0 or 4 register tokens") + reg_suffix = "_reg" if cfg.student.num_register_tokens else "" + return f"dinov2_{hub_arch}{cfg.student.patch_size}{reg_suffix}" + + +def _iter_vit_blocks(backbone): + if backbone.chunked_blocks: + for chunk in backbone.blocks: + for blk in chunk: + if not isinstance(blk, torch.nn.Identity): + yield blk + else: + for blk in backbone.blocks: + yield blk + + +def _load_pretrained_backbone(cfg, model): + def _mlp_kind(block): + if hasattr(block.mlp, "fc1"): + return "mlp" + if hasattr(block.mlp, "w12"): + return "swiglu" + raise AssertionError("Unsupported FFN block type") + + hub_name = _resolve_torchhub_name(cfg) + logger.info("Loading pretrained backbone from torch.hub: %s", hub_name) + model_pretrained = torch.hub.load("facebookresearch/dinov2", hub_name) + device = next(model.parameters()).device + model_pretrained = model_pretrained.to(device) + student_backbone = model.student.backbone + teacher_backbone = model.teacher.backbone + + with torch.no_grad(): + if student_backbone.embed_dim != model_pretrained.embed_dim: + raise AssertionError("Pretrained embed_dim mismatch") + if student_backbone.n_blocks != model_pretrained.n_blocks: + raise AssertionError("Pretrained depth mismatch") + if student_backbone.num_register_tokens != model_pretrained.num_register_tokens: + raise AssertionError("Pretrained register token count mismatch") + + student_backbone.patch_embed.proj.weight.copy_(model_pretrained.patch_embed.proj.weight) + student_backbone.patch_embed.proj.bias.copy_(model_pretrained.patch_embed.proj.bias) + student_backbone.cls_token.copy_(model_pretrained.cls_token) + student_backbone.mask_token.copy_(model_pretrained.mask_token) + if student_backbone.num_register_tokens: + student_backbone.register_tokens.copy_(model_pretrained.register_tokens) + + pos_embed_pretrained = model_pretrained.pos_embed.detach() + n_extra_tokens = 1 + cls_pos_embed = pos_embed_pretrained[:, :n_extra_tokens] + patch_pos_embed = pos_embed_pretrained[:, n_extra_tokens:] + + orig_size = int(patch_pos_embed.shape[1] ** 0.5) + patch_pos_embed = patch_pos_embed.reshape(1, orig_size, orig_size, -1).permute(0, 3, 1, 2) + + target_h, target_w = student_backbone.patch_embed.patches_resolution + resized_patch_pos_embed = F.interpolate( + patch_pos_embed, + size=(target_h, target_w), + mode="bicubic", + align_corners=False, + antialias=model_pretrained.interpolate_antialias, + ) + resized_patch_pos_embed = resized_patch_pos_embed.permute(0, 2, 3, 1).reshape( + 1, target_h * target_w, -1 + ) + new_pos_embed = torch.cat((cls_pos_embed, resized_patch_pos_embed), dim=1) + + student_backbone.pos_embed.copy_(new_pos_embed) + teacher_backbone.pos_embed.copy_(new_pos_embed) + + student_blocks = list(_iter_vit_blocks(student_backbone)) + pretrained_blocks = list(_iter_vit_blocks(model_pretrained)) + if len(student_blocks) != len(pretrained_blocks): + raise AssertionError("Pretrained block count mismatch") + if student_blocks and _mlp_kind(student_blocks[0]) != _mlp_kind(pretrained_blocks[0]): + raise AssertionError( + f"FFN mismatch: cfg.student.ffn_layer builds {_mlp_kind(student_blocks[0])}, " + f"but torch.hub {hub_name} uses {_mlp_kind(pretrained_blocks[0])}" + ) + for dst, src in zip(student_blocks, pretrained_blocks): + dst.load_state_dict(src.state_dict(), strict=True) + + student_backbone.norm.weight.copy_(model_pretrained.norm.weight) + student_backbone.norm.bias.copy_(model_pretrained.norm.bias) + + +def _freeze_student_backbone_except_last_n(cfg, model): + n_unfrozen = cfg.train.unfreeze_last_n_blocks + student_backbone = model.student.backbone + blocks = list(_iter_vit_blocks(student_backbone)) + total_blocks = len(blocks) + if n_unfrozen < 1 or n_unfrozen > total_blocks: + n_unfrozen = total_blocks + print("cfg.train.unfreeze_last_n_blocks not set; setting to total blocks which is {total_blocks}") + freeze_until = total_blocks - n_unfrozen + if freeze_until == 0: + return + for p in student_backbone.parameters(): + p.requires_grad = False + for blk in blocks[freeze_until:]: + for p in blk.parameters(): + p.requires_grad = True + for p in student_backbone.norm.parameters(): + p.requires_grad = True + logger.info("Froze %d/%d student backbone blocks (trainable blocks: %d)", freeze_until, total_blocks, n_unfrozen) + + +def do_test(cfg, model, iteration): # save teacher checkpoint (used for eval only) + # All ranks participate in FSDP state_dict() even with rank0_only=True + is_main = distributed.is_main_process() + iterstring = str(iteration) + eval_dir = os.path.join(cfg.train.output_dir, "eval", iterstring) + if is_main: + os.makedirs(eval_dir, exist_ok=True) + teacher_ckp_path = os.path.join(eval_dir, "teacher_checkpoint.pth") + + if isinstance(model.teacher, FSDP): + state_dict_module = model.teacher + elif isinstance(model, FSDP): + state_dict_module = model + else: + state_dict_module = None + + state_dict_ctx = ( + FSDP.state_dict_type( + state_dict_module, + StateDictType.FULL_STATE_DICT, + state_dict_config=_FULL_STATE_DICT_CFG, + ) + if state_dict_module is not None + else contextlib.nullcontext() + ) + + with torch.no_grad(), state_dict_ctx: + teacher_sd = model.teacher.state_dict() + + if is_main: + torch.save({"teacher": teacher_sd}, teacher_ckp_path) + gc.collect() + if torch.cuda.is_available(): + torch.cuda.empty_cache() + + del teacher_sd + + if dist.is_available() and dist.is_initialized(): + dist.barrier() + + if not is_main: + return + + teacher, _ = build_model_from_cfg(cfg, only_teacher=True) + teacher_state = torch.load(teacher_ckp_path, map_location="cpu")["teacher"] + teacher_state = {k.replace("module.", ""): v for k, v in teacher_state.items()} + teacher_state = {k.replace("backbone.", ""): v for k, v in teacher_state.items() if k.startswith("backbone.")} + load_msg = teacher.load_state_dict(teacher_state, strict=False) + logger.info("Loaded teacher for downstream eval with msg: %s", load_msg) + teacher = teacher.cuda() + teacher.eval() + teacher.requires_grad_(False) + device = next(teacher.parameters()).device + step = iteration if isinstance(iteration, int) else int(str(iteration).split("_")[-1]) + + def _resolve_eval_root(name, root_value): + root_str = "" if root_value is None else str(root_value) + if not root_str: + logger.info("Skipping %s eval because %s_root is not set", name, name.lower()) + return None + root_path = os.path.abspath(os.path.expanduser(root_str)) + if not os.path.isdir(root_path): + logger.info("Skipping %s eval; dataset path missing: %s", name, root_path) + return None + return root_path + + bach_root = _resolve_eval_root("BACH", cfg.evaluation.bach_root) + breakhis_root = _resolve_eval_root("BreakHis", cfg.evaluation.breakhis_root) + pcam_root = _resolve_eval_root("PCam", cfg.evaluation.pcam_root) + + class _ResizeAndCrop(transforms.Compose): + def __init__(self, size=224, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)): + ops = [ + transforms.Resize(size), + transforms.CenterCrop(size), + transforms.ToTensor(), + transforms.Normalize(mean=mean, std=std), + ] + super().__init__(ops) + + transform = _ResizeAndCrop( + size=224, + mean=[0.485, 0.456, 0.406], + std=[0.229, 0.224, 0.225], + ) + + predict_batch_size = 64 + num_workers = 4 + train_batch_size = 256 + + def _compute_embeddings(dataset, *, to_cpu=False): + loader = torch.utils.data.DataLoader( + dataset, + batch_size=predict_batch_size, + shuffle=False, + num_workers=num_workers, + pin_memory=True, + ) + feats = [] + targets = [] + with torch.no_grad(): + for images, labels in loader: + images = images.to(device, non_blocking=True) + out = teacher(images, is_training=True) + cls = out["x_norm_clstoken"].float() + if to_cpu: + feats.append(cls.cpu()) + targets.append(labels.cpu()) + else: + labels = labels.to(device, non_blocking=True) + feats.append(cls) + targets.append(labels) + feats = torch.cat(feats, dim=0) + targets = torch.cat(targets, dim=0) + return feats, targets + + if bach_root is not None: + _BACH_TRAIN_INDEX_RANGES = [ + (0, 41), + (59, 60), + (90, 139), + (169, 240), + (258, 260), + (273, 345), + (368, 400), + ] + _BACH_VAL_INDEX_RANGES = [ + (41, 59), + (60, 90), + (139, 169), + (240, 258), + (260, 273), + (345, 368), + ] + _BACH_CLASS_TO_IDX = {"Benign": 0, "InSitu": 1, "Invasive": 2, "Normal": 3} + + class _BACHDataset(torch.utils.data.Dataset): + def __init__(self, root, split, transform): + self.root = os.path.abspath(os.path.expanduser(root)) + self.split = split + self.transform = transform + dataset_path = os.path.join(self.root, "ICIAR2018_BACH_Challenge", "Photos") + self.samples = folder.make_dataset( + directory=dataset_path, + class_to_idx=_BACH_CLASS_TO_IDX, + extensions=(".tif",), + ) + if len(self.samples) == 0: + raise RuntimeError(f"No BACH images found in {dataset_path}") + if split == "train": + index_ranges = _BACH_TRAIN_INDEX_RANGES + elif split == "val": + index_ranges = _BACH_VAL_INDEX_RANGES + else: + raise ValueError("Invalid BACH split. Use 'train' or 'val'.") + indices = [] + for start, end in index_ranges: + indices.extend(range(start, end)) + self.indices = indices + + def __len__(self): + return len(self.indices) + + def __getitem__(self, idx): + image_path, target = self.samples[self.indices[idx]] + image = Image.open(image_path).convert("RGB") + if self.transform is not None: + image = self.transform(image) + target_tensor = torch.tensor(target, dtype=torch.long) + return image, target_tensor + + train_ds = _BACHDataset(root=bach_root, split="train", transform=transform) + val_ds = _BACHDataset(root=bach_root, split="val", transform=transform) + + train_feats, train_targets = _compute_embeddings(train_ds) + val_feats, val_targets = _compute_embeddings(val_ds) + + in_features = train_feats.shape[-1] + num_classes = 4 + head = torch.nn.Linear(in_features, num_classes, bias=True).to(device) + criterion = torch.nn.CrossEntropyLoss().to(device) + optimizer = torch.optim.AdamW(head.parameters(), lr=3e-4, weight_decay=1e-2) + + train_dataset = torch.utils.data.TensorDataset(train_feats, train_targets) + train_loader = torch.utils.data.DataLoader( + train_dataset, + batch_size=train_batch_size, + shuffle=True, + drop_last=False, + ) + + val_dataset = torch.utils.data.TensorDataset(val_feats, val_targets) + val_loader = torch.utils.data.DataLoader( + val_dataset, + batch_size=train_batch_size, + shuffle=False, + drop_last=False, + ) + + def _eval_head(): + head.eval() + all_preds = [] + all_targets = [] + with torch.no_grad(): + for feats_batch, targets_batch in val_loader: + feats_batch = feats_batch.to(device, non_blocking=True) + logits = head(feats_batch) + preds = logits.argmax(dim=1).cpu() + all_preds.append(preds) + all_targets.append(targets_batch.cpu()) + preds = torch.cat(all_preds, dim=0) + targets = torch.cat(all_targets, dim=0) + plain_acc = float((preds == targets).float().mean().item()) + conf = torch.zeros(num_classes, num_classes, dtype=torch.long) + indices = targets * num_classes + preds + bincount = torch.bincount(indices, minlength=num_classes * num_classes) + conf = bincount.view(num_classes, num_classes) + per_class = conf.diag().float() / conf.sum(dim=1).clamp_min(1) + balanced_acc = float(per_class.mean().item()) + head.train() + return plain_acc, balanced_acc + + max_steps = 12500 # eva uses 12500 steps with patience-based early stopping + eval_every = 250 + patience = 1250 + steps = 0 + best_plain = -1.0 + best_balanced = -1.0 + best_state = None + steps_since_improve = 0 + head.train() + with tqdm(total=max_steps) as pbar: + while steps < max_steps: + for feats_batch, targets_batch in train_loader: + feats_batch = feats_batch.to(device, non_blocking=True) + targets_batch = targets_batch.to(device, non_blocking=True) + logits = head(feats_batch) + loss = criterion(logits, targets_batch) + optimizer.zero_grad(set_to_none=True) + loss.backward() + optimizer.step() + steps += 1 + pbar.update(1) + if steps % eval_every == 0 or steps >= max_steps: + plain_acc, balanced_acc = _eval_head() + if plain_acc > best_plain: + best_plain = plain_acc + best_balanced = balanced_acc + best_state = {k: v.cpu() for k, v in head.state_dict().items()} + steps_since_improve = 0 + else: + steps_since_improve += eval_every + if steps_since_improve >= patience: + steps = max_steps + break + if steps >= max_steps: + break + + if best_state is not None: + head.load_state_dict(best_state) + bach_acc_plain, bach_acc_balanced = best_plain, best_balanced + else: + bach_acc_plain, bach_acc_balanced = _eval_head() + + logger.info( + "BACH val accuracy (linear probe): plain=%.4f balanced=%.4f", + bach_acc_plain, + bach_acc_balanced, + ) + + if wandb.run is not None and distributed.is_main_process(): + wandb.log( + { + "val/BACH_BALANCED_ACCURACY": bach_acc_balanced, + "val/BACH_MULTICLASS_ACCURACY": bach_acc_plain, + }, + step=step, + ) + + if breakhis_root is not None: + _BREAKHIS_VAL_PATIENT_IDS = { + "18842D", + "19979", + "15275", + "15792", + "16875", + "3909", + "5287", + "16716", + "2773", + "5695", + "16184CD", + "23060CD", + "21998CD", + "21998EF", + } + _BREAKHIS_CLASSES = ["TA", "MC", "F", "DC"] + _BREAKHIS_CLASS_TO_IDX = {label: index for index, label in enumerate(_BREAKHIS_CLASSES)} + + class _BreakHisDataset(torch.utils.data.Dataset): + def __init__(self, root, split, transform): + self.root = os.path.abspath(os.path.expanduser(root)) + self.split = split + self.transform = transform + dataset_path = os.path.join(self.root, "BreaKHis_v1", "histology_slides") + pattern = os.path.join(dataset_path, "**", "40X", "*.png") + self.image_files = sorted(glob.glob(pattern, recursive=True)) + if len(self.image_files) == 0: + raise RuntimeError(f"No BreakHis images found in {dataset_path}") + indices = [] + for idx, image_file in enumerate(self.image_files): + class_name = os.path.basename(image_file).split("-")[0].split("_")[-1] + if class_name not in _BREAKHIS_CLASS_TO_IDX: + continue + patient_id = os.path.basename(image_file).split("-")[2] + if split == "train": + if patient_id not in _BREAKHIS_VAL_PATIENT_IDS: + indices.append(idx) + elif split == "val": + if patient_id in _BREAKHIS_VAL_PATIENT_IDS: + indices.append(idx) + else: + raise ValueError("Invalid BreakHis split. Use 'train' or 'val'.") + self.indices = indices + + def __len__(self): + return len(self.indices) + + def __getitem__(self, idx): + image_path = self.image_files[self.indices[idx]] + image = Image.open(image_path).convert("RGB") + if self.transform is not None: + image = self.transform(image) + class_name = os.path.basename(image_path).split("-")[0].split("_")[-1] + target = _BREAKHIS_CLASS_TO_IDX[class_name] + target_tensor = torch.tensor(target, dtype=torch.long) + return image, target_tensor + + train_ds = _BreakHisDataset(root=breakhis_root, split="train", transform=transform) + val_ds = _BreakHisDataset(root=breakhis_root, split="val", transform=transform) + + train_feats, train_targets = _compute_embeddings(train_ds) + val_feats, val_targets = _compute_embeddings(val_ds) + + in_features = train_feats.shape[-1] + num_classes = 4 + head = torch.nn.Linear(in_features, num_classes, bias=True).to(device) + criterion = torch.nn.CrossEntropyLoss().to(device) + optimizer = torch.optim.AdamW(head.parameters(), lr=3e-4, weight_decay=1e-2) + + train_dataset = torch.utils.data.TensorDataset(train_feats, train_targets) + train_loader = torch.utils.data.DataLoader( + train_dataset, + batch_size=train_batch_size, + shuffle=True, + drop_last=False, + ) + + val_dataset = torch.utils.data.TensorDataset(val_feats, val_targets) + val_loader = torch.utils.data.DataLoader( + val_dataset, + batch_size=train_batch_size, + shuffle=False, + drop_last=False, + ) + + def _eval_head(): + head.eval() + all_preds = [] + all_targets = [] + with torch.no_grad(): + for feats_batch, targets_batch in val_loader: + feats_batch = feats_batch.to(device, non_blocking=True) + logits = head(feats_batch) + preds = logits.argmax(dim=1).cpu() + all_preds.append(preds) + all_targets.append(targets_batch.cpu()) + preds = torch.cat(all_preds, dim=0) + targets = torch.cat(all_targets, dim=0) + plain_acc = float((preds == targets).float().mean().item()) + conf = torch.zeros(num_classes, num_classes, dtype=torch.long) + indices = targets * num_classes + preds + bincount = torch.bincount(indices, minlength=num_classes * num_classes) + conf = bincount.view(num_classes, num_classes) + per_class = conf.diag().float() / conf.sum(dim=1).clamp_min(1) + balanced_acc = float(per_class.mean().item()) + head.train() + return plain_acc, balanced_acc + + max_steps = 12500 + eval_every = 250 + patience = 500 + steps = 0 + best_plain = -1.0 + best_balanced = -1.0 + best_state = None + steps_since_improve = 0 + head.train() + while steps < max_steps: + for feats_batch, targets_batch in train_loader: + feats_batch = feats_batch.to(device, non_blocking=True) + targets_batch = targets_batch.to(device, non_blocking=True) + logits = head(feats_batch) + loss = criterion(logits, targets_batch) + optimizer.zero_grad(set_to_none=True) + loss.backward() + optimizer.step() + steps += 1 + if steps % eval_every == 0 or steps >= max_steps: + plain_acc, balanced_acc = _eval_head() + if plain_acc > best_plain: + best_plain = plain_acc + best_balanced = balanced_acc + best_state = {k: v.cpu() for k, v in head.state_dict().items()} + steps_since_improve = 0 + else: + steps_since_improve += eval_every + if steps_since_improve >= patience: + steps = max_steps + break + if steps >= max_steps: + break + + if best_state is not None: + head.load_state_dict(best_state) + breakhis_acc_plain, breakhis_acc_balanced = best_plain, best_balanced + else: + breakhis_acc_plain, breakhis_acc_balanced = _eval_head() + + logger.info( + "BreakHis val accuracy (linear probe): plain=%.4f balanced=%.4f", + breakhis_acc_plain, + breakhis_acc_balanced, + ) + + if wandb.run is not None and distributed.is_main_process(): + wandb.log( + { + "val/BREAKHIS_BALANCED_ACCURACY": breakhis_acc_balanced, + "val/BREAKHIS_MULTICLASS_ACCURACY": breakhis_acc_plain, + }, + step=step, + ) + + if pcam_root is not None: + def _pcam_h5_path(root, split, key): + split_suffix = "valid" if split == "val" else split + filename = f"camelyonpatch_level_2_split_{split_suffix}_{key}.h5" + return os.path.join(root, filename) + + class _PCamDataset(torch.utils.data.Dataset): + def __init__(self, root, split, transform): + self.root = os.path.abspath(os.path.expanduser(root)) + self.split = split + self.transform = transform + self.x_path = _pcam_h5_path(self.root, split, "x") + self.y_path = _pcam_h5_path(self.root, split, "y") + if not os.path.isfile(self.x_path) or not os.path.isfile(self.y_path): + raise RuntimeError(f"Missing PatchCamelyon files for split {split} in {self.root}") + with h5py.File(self.y_path, "r") as file: + self.length = len(file["y"]) + + def __len__(self): + return self.length + + def __getitem__(self, idx): + with h5py.File(self.x_path, "r") as file: + image_array = file["x"][idx] + with h5py.File(self.y_path, "r") as file: + target = file["y"][idx].squeeze() + image = Image.fromarray(image_array) + if image.mode != "RGB": + image = image.convert("RGB") + if self.transform is not None: + image = self.transform(image) + target_tensor = torch.tensor(float(target), dtype=torch.float32) + return image, target_tensor + + train_ds = _PCamDataset(root=pcam_root, split="train", transform=transform) + test_ds = _PCamDataset(root=pcam_root, split="test", transform=transform) + + num_samples_per_class = 10 + with h5py.File(_pcam_h5_path(pcam_root, "train", "y"), "r") as file: + targets = file["y"][:].reshape(-1) + class_indices = {} + for idx, target in enumerate(targets): + class_idx = int(target) + if class_idx not in class_indices: + class_indices[class_idx] = [] + class_indices[class_idx].append(idx) + for class_idx, indices in class_indices.items(): + if len(indices) < num_samples_per_class: + raise ValueError( + f"Class {class_idx} has only {len(indices)} samples, " + f"which is less than the required {num_samples_per_class} samples." + ) + rng = np.random.default_rng(42) + sampled_indices = [] + for class_idx in class_indices: + sampled = rng.choice( + class_indices[class_idx], + size=num_samples_per_class, + replace=False, + ).tolist() + sampled_indices.extend(sampled) + rng.shuffle(sampled_indices) + + train_subset = torch.utils.data.Subset(train_ds, sampled_indices) + + train_feats, train_targets = _compute_embeddings(train_subset, to_cpu=True) + test_feats, test_targets = _compute_embeddings(test_ds, to_cpu=True) + + in_features = train_feats.shape[-1] + head = torch.nn.Linear(in_features, 1, bias=True).to(device) + criterion = torch.nn.BCEWithLogitsLoss().to(device) + optimizer = torch.optim.AdamW(head.parameters(), lr=3e-4, weight_decay=1e-2) + + train_dataset = torch.utils.data.TensorDataset(train_feats, train_targets) + train_loader = torch.utils.data.DataLoader( + train_dataset, + batch_size=train_batch_size, + shuffle=False, + drop_last=False, + ) + + test_dataset = torch.utils.data.TensorDataset(test_feats, test_targets) + test_loader = torch.utils.data.DataLoader( + test_dataset, + batch_size=train_batch_size, + shuffle=False, + drop_last=False, + ) + + def _eval_head(loader): + head.eval() + all_preds = [] + all_targets = [] + with torch.no_grad(): + for feats_batch, targets_batch in loader: + feats_batch = feats_batch.to(device, non_blocking=True) + logits = head(feats_batch).squeeze(1) + preds = (logits >= 0).to(torch.long).cpu() + all_preds.append(preds) + all_targets.append(targets_batch.to(torch.long).cpu()) + preds = torch.cat(all_preds, dim=0) + targets = torch.cat(all_targets, dim=0) + plain_acc = float((preds == targets).float().mean().item()) + num_classes = 2 + indices = targets * num_classes + preds + bincount = torch.bincount(indices, minlength=num_classes * num_classes) + conf = bincount.view(num_classes, num_classes) + per_class = conf.diag().float() / conf.sum(dim=1).clamp_min(1) + balanced_acc = float(per_class.mean().item()) + head.train() + return plain_acc, balanced_acc + + max_steps = 12500 + eval_every_epochs = 10 + patience_evals = 125 + eval_every = eval_every_epochs * len(train_loader) + patience = patience_evals * eval_every + steps = 0 + best_balanced = -1.0 + best_state = None + steps_since_improve = 0 + head.train() + while steps < max_steps: + for feats_batch, targets_batch in train_loader: + feats_batch = feats_batch.to(device, non_blocking=True) + targets_batch = targets_batch.to(device, non_blocking=True) + logits = head(feats_batch).squeeze(1) + loss = criterion(logits, targets_batch) + optimizer.zero_grad(set_to_none=True) + loss.backward() + optimizer.step() + steps += 1 + if steps % eval_every == 0 or steps >= max_steps: + _, balanced_acc = _eval_head(test_loader) + if balanced_acc > best_balanced: + best_balanced = balanced_acc + best_state = {k: v.cpu() for k, v in head.state_dict().items()} + steps_since_improve = 0 + else: + steps_since_improve += eval_every + if steps_since_improve >= patience: + steps = max_steps + break + if steps >= max_steps: + break + + if best_state is not None: + head.load_state_dict(best_state) + test_plain, test_balanced = _eval_head(test_loader) + + logger.info( + "PCam test accuracy (linear probe, 10-shot): plain=%.4f balanced=%.4f", + test_plain, + test_balanced, + ) + + if wandb.run is not None and distributed.is_main_process(): + wandb.log( + { + "val/PCAM_BINARY_ACCURACY": test_plain, + "val/PCAM_BALANCED_ACCURACY": test_balanced, + }, + step=step, + ) + + +def do_train(cfg, model, resume=False): + model.train() + inputs_dtype = torch.half + fp16_scaler = model.fp16_scaler # for mixed precision training + trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad) + total_params = sum(p.numel() for p in model.parameters()) + if cfg.train.skip_checkpointer: + print(f"\n\nSkipping FSDP checkpointer (cfg.train.skip_checkpointer={cfg.train.skip_checkpointer})\n\n") + + # setup optimizer + + optimizer = build_optimizer(cfg, model.get_params_groups()) + ( + lr_schedule, + wd_schedule, + momentum_schedule, + teacher_temp_schedule, + last_layer_lr_schedule, + gram_weight_schedule, + ) = build_schedulers(cfg) + + from omegaconf import OmegaConf + if distributed.is_main_process(): + run_id_path = Path(cfg.train.output_dir) / "wandb_run_id.txt" + if resume and run_id_path.exists(): + run_id = run_id_path.read_text().strip() + resume_mode = "must" + else: + run_id_path.parent.mkdir(parents=True, exist_ok=True) + run_id = wandb.util.generate_id() + run_id_path.write_text(run_id) + resume_mode = "allow" + run = wandb.init( + project="tcga-finetuning", + config=OmegaConf.to_container(cfg), + id=run_id, + resume=resume_mode, + ) + repo_root = Path(__file__).resolve().parents[2] + files_to_save = [ + Path(__file__).resolve(), + AUGMENTATION_FILE, + VISION_TRANSFORMER_FILE, + SSL_META_ARCH, + Path(CONFIG_FILE_PATH), + ] + run_script = os.environ.get("DINOV2_RUN_SCRIPT") + if run_script: + files_to_save.append(Path(run_script).resolve()) + for src in files_to_save: + base_path = repo_root if src.is_relative_to(repo_root) else src.parent + run.save(str(src), base_path=str(base_path), policy="now") + logger.info("Trainable parameters: %s", trainable_params) + logger.info("Total parameters: %s", total_params) + print(f"Trainable parameters: {trainable_params}") + print(f"Total parameters: {total_params}") + + # checkpointer + if not cfg.train.skip_checkpointer: + checkpointer = FSDPCheckpointer(model, cfg.train.output_dir, optimizer=optimizer, save_to_disk=True) + start_iter = checkpointer.resume_or_load(cfg.MODEL.WEIGHTS, resume=resume).get("iteration", -1) + 1 + else: + start_iter = 0 + + OFFICIAL_EPOCH_LENGTH = cfg.train.OFFICIAL_EPOCH_LENGTH + max_iter = cfg.optim.epochs * OFFICIAL_EPOCH_LENGTH + early_stop_iter = cfg.optim.early_stop * OFFICIAL_EPOCH_LENGTH + eta_target_iter = min(max_iter, early_stop_iter) + + if not cfg.train.skip_checkpointer: + periodic_checkpointer = PeriodicCheckpointer( + checkpointer, + period=2 * OFFICIAL_EPOCH_LENGTH, # 2500 (was 5×=6250): 불안정 클러스터 대비 촘촘한 resume 체크포인트 + max_iter=max_iter, + max_to_keep=2, + ) + + # setup data preprocessing + + img_size = cfg.crops.global_crops_size + patch_size = cfg.student.patch_size + n_tokens = (img_size // patch_size) ** 2 + mask_generator = MaskingGenerator( + input_size=(img_size // patch_size, img_size // patch_size), + max_num_patches=0.5 * img_size // patch_size * img_size // patch_size, + ) + + data_transform = DataAugmentationDINO( + cfg.crops.global_crops_scale, + cfg.crops.local_crops_scale, + cfg.crops.local_crops_number, + global_crops_size=cfg.crops.global_crops_size, + local_crops_size=cfg.crops.local_crops_size, + ) + + collate_fn = partial( + collate_data_and_cast, + mask_ratio_tuple=cfg.ibot.mask_ratio_min_max, + mask_probability=cfg.ibot.mask_sample_probability, + n_tokens=n_tokens, + mask_generator=mask_generator, + dtype=inputs_dtype, + ) + + # setup data loader + + if cfg.train.streaming_from_hf: + dataset_builder = partial( + _build_streaming_dataset, + dataset_path=str(cfg.train.streaming_dataset_path), + shuffle_buffer=2000, + base_seed=42, + ) + + def decode_and_transform(item): + image = Image.open(BytesIO(item["image_bytes"])) + image = ImageOps.exif_transpose(image).convert("RGB") + transformed = data_transform(image) + slide_meta = (item["slide_path"], item["x"], item["y"], item["level"]) + return (transformed, None), slide_meta + + class _TransformedStreamingDataset(torch.utils.data.IterableDataset): + def __init__(self, dataset_builder, transform, samples_per_epoch=None, reshuffle_every=0): + self._dataset_builder = dataset_builder + self._transform = transform + self._samples_per_epoch = samples_per_epoch + self._reshuffle_every = reshuffle_every + self._initialized = False + self._epoch_seen = 0 + self._src_iter = None + + def _init_or_reshuffle(self, *, force: bool = False): + if force or (not self._initialized) or ( + self._reshuffle_every and (self._epoch_seen % self._reshuffle_every == 0) + ): + src = self._dataset_builder(epoch=self._epoch_seen if self._reshuffle_every else 0) + worker_info = torch.utils.data.get_worker_info() + if worker_info is not None and worker_info.num_workers > 1: + src = src.shard(num_shards=worker_info.num_workers, index=worker_info.id) + self._src_iter = iter(src) + self._initialized = True + + def __iter__(self): + while True: + self._init_or_reshuffle() + + # Per-RANK quota + rank_quota = self._samples_per_epoch or (1 << 62) + + worker_info = torch.utils.data.get_worker_info() + num_workers = worker_info.num_workers if worker_info is not None else 1 + worker_id = worker_info.id if worker_info is not None else 0 + + # Split quota across workers (nearly even split) + base = rank_quota // num_workers + remainder = rank_quota % num_workers + local_quota = base + (1 if worker_id < remainder else 0) + + produced = 0 + while produced < local_quota: + try: + sample = next(self._src_iter) + except StopIteration: + # Refill the iterator; only reshuffle on epoch boundaries + self._init_or_reshuffle(force=True) + continue + yield self._transform(sample) + produced += 1 + + self._epoch_seen += 1 + + # Define explicit per-epoch sample budget per rank to keep ranks in lock-step + samples_per_epoch = cfg.train.batch_size_per_gpu * cfg.train.OFFICIAL_EPOCH_LENGTH + dataset = _TransformedStreamingDataset( + dataset_builder, + decode_and_transform, + samples_per_epoch=samples_per_epoch, + ) + + def _worker_init(_): + torch.set_num_threads(1) + os.environ.setdefault("OMP_NUM_THREADS", "1") + + data_loader = torch.utils.data.DataLoader( + dataset, + batch_size=cfg.train.batch_size_per_gpu, + num_workers=cfg.train.num_workers, + drop_last=True, + pin_memory=True, + persistent_workers=True, + collate_fn=collate_fn, + prefetch_factor=4, + worker_init_fn=_worker_init, + ) + elif str(cfg.train.sample_list_path).startswith("parquet:"): + # Test B: 로컬 parquet(그들 TCGA-12K)을 우리 빠른 로더로 스트리밍. + from dinov2.data.openpath_wds import make_openpath_parquet_loader + data_loader = make_openpath_parquet_loader( + str(cfg.train.sample_list_path), + batch_size=cfg.train.batch_size_per_gpu, + num_workers=cfg.train.num_workers, + data_transform=data_transform, + collate_fn=collate_fn, + prefetch_factor=cfg.train.prefetch_factor, + ) + elif str(cfg.train.sample_list_path).startswith("openpath:"): + # OpenPath: stream pre-patched WebDataset tar shards (see openpath_wds.py). + from dinov2.data.openpath_wds import make_openpath_loader + data_loader = make_openpath_loader( + str(cfg.train.sample_list_path), + batch_size=cfg.train.batch_size_per_gpu, + num_workers=cfg.train.num_workers, + data_transform=data_transform, + collate_fn=collate_fn, + prefetch_factor=cfg.train.prefetch_factor, + ) + else: + from dinov2.data import SamplerType, make_data_loader, make_dataset + sample_list_path = str(cfg.train.sample_list_path) + if not sample_list_path: + raise ValueError("cfg.train.sample_list_path must be set when streaming_from_hf is False") + dataset_str = f"pathology:root=/data/TCGA/:sample_list_path={sample_list_path}" + dataset = make_dataset( + dataset_str=dataset_str, + transform=data_transform, + target_transform=lambda _: (), + ) + sampler_type = SamplerType.SHARDED_INFINITE + data_loader = make_data_loader( + dataset=dataset, + batch_size=cfg.train.batch_size_per_gpu, + num_workers=cfg.train.num_workers, + shuffle=True, + seed=0, + sampler_type=sampler_type, + sampler_advance=0, # TODO(qas): fix this -- start_iter * cfg.train.batch_size_per_gpu, + drop_last=True, + collate_fn=collate_fn, + persistent_workers=cfg.train.num_workers > 0, + prefetch_factor=cfg.train.prefetch_factor, + ) + + # training loop + + iteration = start_iter + + logger.info("Starting training from iteration {}".format(start_iter)) + metrics_file = os.path.join(cfg.train.output_dir, "training_metrics.json") + metric_logger = MetricLogger(delimiter=" ", output_file=metrics_file) + header = "Training" + + for data in metric_logger.log_every( + data_loader, + 10, + header, + eta_target_iter + 1, + start_iter, + ): + if iteration >= early_stop_iter: + logger.info("Early stopping at iteration {}".format(iteration)) + if cfg.evaluation.eval_period_iterations >= 0: + do_test(cfg, model, f"training_{iteration}") + torch.cuda.synchronize() + if not cfg.train.skip_checkpointer: + checkpointer.save(f"model_{iteration:07d}", iteration=iteration) + break + + #Save instantly + if cfg.evaluation.eval_period_iterations >= 0 and (iteration) % cfg.evaluation.eval_period_iterations == 0: + do_test(cfg, model, f"training_{iteration}") + torch.cuda.synchronize() + if not cfg.train.skip_checkpointer: + periodic_checkpointer.step(iteration) + + current_batch_size = data["collated_global_crops"].shape[0] / 2 + if iteration > max_iter: + return + + nan_mask = torch.isnan(data["collated_global_crops"]) + nan_mask2 = torch.isnan(data["collated_local_crops"]) + if nan_mask.any(): + print("found nan in input data") + print(data[indexes]) + + + # apply schedules + + lr = lr_schedule[iteration] + wd = wd_schedule[iteration] + mom = momentum_schedule[iteration] + teacher_temp = teacher_temp_schedule[iteration] + last_layer_lr = last_layer_lr_schedule[iteration] + gram_weight = gram_weight_schedule[iteration] + apply_optim_scheduler(optimizer, lr, wd, last_layer_lr) + + # compute losses + + optimizer.zero_grad(set_to_none=True) + + loss_dict = model.forward_backward(data, teacher_temp=teacher_temp, gram_weight=gram_weight) + + # clip gradients + + if fp16_scaler is not None: + if cfg.optim.clip_grad: + fp16_scaler.unscale_(optimizer) + for v in model.student.values(): + v.clip_grad_norm_(cfg.optim.clip_grad) + fp16_scaler.step(optimizer) + fp16_scaler.update() + else: + if cfg.optim.clip_grad: + for v in model.student.values(): + v.clip_grad_norm_(cfg.optim.clip_grad) + optimizer.step() + + # perform teacher EMA update + + model.update_teacher(mom) + + # logging + + if distributed.get_global_size() > 1: + for v in loss_dict.values(): + torch.distributed.all_reduce(v) + loss_dict_reduced = {k: v.item() / distributed.get_global_size() for k, v in loss_dict.items()} + + if math.isnan(sum(loss_dict_reduced.values())): + print(sum(loss_dict_reduced.values())) + logger.info("NaN detected") + print(data["indexes"]) + + for name, param in model.named_parameters(): + if torch.isnan(param.data).any(): + print(f"NaNs found in parameter: {name}") + + raise AssertionError + losses_reduced = sum(loss for loss in loss_dict_reduced.values()) + + metric_logger.update(lr=lr) + metric_logger.update(wd=wd) + metric_logger.update(mom=mom) + metric_logger.update(last_layer_lr=last_layer_lr) + metric_logger.update(current_batch_size=current_batch_size) + metric_logger.update(total_loss=losses_reduced, **loss_dict_reduced) + + if distributed.is_main_process(): + scalar_logs = { + "Learning Rate": lr, + "Momentum": mom, + "Last Layer LR": last_layer_lr, + "Total Loss": losses_reduced, + } + wandb.log({**scalar_logs, **loss_dict_reduced}, step=iteration) + + # Synchronize the GPU to ensure all operations are complete before measuring + torch.cuda.synchronize() + + iteration = iteration + 1 + metric_logger.synchronize_between_processes() + return {k: meter.global_avg for k, meter in metric_logger.meters.items()} + + +def main(args): + cfg = setup(args) + print(cfg) + model = SSLMetaArch(cfg).to(torch.device("cuda")) + #Load model here from pretrained. + if cfg.train.use_pretrained: + _load_pretrained_backbone(cfg, model) + _freeze_student_backbone_except_last_n(cfg, model) + + model.prepare_for_distributed_training() + logger.info("Model:\n{}".format(model)) + + if args.eval_only and not cfg.train.skip_checkpointer: + iteration = ( + FSDPCheckpointer(model, save_dir=cfg.train.output_dir) + .resume_or_load(cfg.MODEL.WEIGHTS, resume=not args.no_resume) + .get("iteration", -1) + + 1 + ) + return do_test(cfg, model, f"manual_{iteration}") + + do_train(cfg, model, resume=not args.no_resume) + + +if __name__ == "__main__": + args = get_args_parser(add_help=True).parse_args() + if not args.config_file: + raise ValueError("config file path must be provided") + CONFIG_FILE_PATH = os.path.abspath(args.config_file) + main(args) diff --git a/OpenMidnight/dinov2/utils/__init__.py b/OpenMidnight/dinov2/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b88da6bf80be92af00b72dfdb0a806fa64a7a2d9 --- /dev/null +++ b/OpenMidnight/dinov2/utils/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. diff --git a/OpenMidnight/dinov2/utils/cluster.py b/OpenMidnight/dinov2/utils/cluster.py new file mode 100644 index 0000000000000000000000000000000000000000..3df87dc3e1eb4f0f8a280dc3137cfef031886314 --- /dev/null +++ b/OpenMidnight/dinov2/utils/cluster.py @@ -0,0 +1,95 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from enum import Enum +import os +from pathlib import Path +from typing import Any, Dict, Optional + + +class ClusterType(Enum): + AWS = "aws" + FAIR = "fair" + RSC = "rsc" + + +def _guess_cluster_type() -> ClusterType: + uname = os.uname() + if uname.sysname == "Linux": + if uname.release.endswith("-aws"): + # Linux kernel versions on AWS instances are of the form "5.4.0-1051-aws" + return ClusterType.AWS + elif uname.nodename.startswith("rsc"): + # Linux kernel versions on RSC instances are standard ones but hostnames start with "rsc" + return ClusterType.RSC + + return ClusterType.FAIR + + +def get_cluster_type(cluster_type: Optional[ClusterType] = None) -> Optional[ClusterType]: + if cluster_type is None: + return _guess_cluster_type() + + return cluster_type + + +def get_checkpoint_path(cluster_type: Optional[ClusterType] = None) -> Optional[Path]: + cluster_type = get_cluster_type(cluster_type) + if cluster_type is None: + return None + + CHECKPOINT_DIRNAMES = { + ClusterType.AWS: "checkpoints", + ClusterType.FAIR: "checkpoint", + ClusterType.RSC: "checkpoint/dino", + } + return Path("/") / CHECKPOINT_DIRNAMES[cluster_type] + + +def get_user_checkpoint_path(cluster_type: Optional[ClusterType] = None) -> Optional[Path]: + checkpoint_path = get_checkpoint_path(cluster_type) + if checkpoint_path is None: + return None + + username = os.environ.get("USER") + assert username is not None + return checkpoint_path / username + + +def get_slurm_partition(cluster_type: Optional[ClusterType] = None) -> Optional[str]: + cluster_type = get_cluster_type(cluster_type) + if cluster_type is None: + return None + + SLURM_PARTITIONS = { + ClusterType.AWS: "learnlab", + ClusterType.FAIR: "learnlab", + ClusterType.RSC: "learn", + } + return SLURM_PARTITIONS[cluster_type] + + +def get_slurm_executor_parameters( + nodes: int, num_gpus_per_node: int, cluster_type: Optional[ClusterType] = None, **kwargs +) -> Dict[str, Any]: + # create default parameters + params = { + "mem_gb": 0, # Requests all memory on a node, see https://slurm.schedmd.com/sbatch.html + "gpus_per_node": num_gpus_per_node, + "tasks_per_node": num_gpus_per_node, # one task per GPU + "cpus_per_task": 10, + "nodes": nodes, + "slurm_partition": get_slurm_partition(cluster_type), + } + # apply cluster-specific adjustments + cluster_type = get_cluster_type(cluster_type) + if cluster_type == ClusterType.AWS: + params["cpus_per_task"] = 12 + del params["mem_gb"] + elif cluster_type == ClusterType.RSC: + params["cpus_per_task"] = 12 + # set additional parameters / apply overrides + params.update(kwargs) + return params diff --git a/OpenMidnight/dinov2/utils/config.py b/OpenMidnight/dinov2/utils/config.py new file mode 100644 index 0000000000000000000000000000000000000000..c9de578787bbcb376f8bd5a782206d0eb7ec1f52 --- /dev/null +++ b/OpenMidnight/dinov2/utils/config.py @@ -0,0 +1,72 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import math +import logging +import os + +from omegaconf import OmegaConf + +import dinov2.distributed as distributed +from dinov2.logging import setup_logging +from dinov2.utils import utils +from dinov2.configs import dinov2_default_config + + +logger = logging.getLogger("dinov2") + + +def apply_scaling_rules_to_cfg(cfg): # to fix + if cfg.optim.scaling_rule == "sqrt_wrt_1024": + base_lr = cfg.optim.base_lr + cfg.optim.lr = base_lr + cfg.optim.lr *= math.sqrt(cfg.train.batch_size_per_gpu * distributed.get_global_size() / 1024.0) + logger.info(f"sqrt scaling learning rate; base: {base_lr}, new: {cfg.optim.lr}") + else: + raise NotImplementedError + return cfg + + +def write_config(cfg, output_dir, name="config.yaml"): + logger.info(OmegaConf.to_yaml(cfg)) + saved_cfg_path = os.path.join(output_dir, name) + with open(saved_cfg_path, "w") as f: + OmegaConf.save(config=cfg, f=f) + return saved_cfg_path + + +def get_cfg_from_args(args): + args.output_dir = os.path.abspath(args.output_dir) + args.opts += [f"train.output_dir={args.output_dir}"] + default_cfg = OmegaConf.create(dinov2_default_config) + cfg = OmegaConf.load(args.config_file) + cfg = OmegaConf.merge(default_cfg, cfg, OmegaConf.from_cli(args.opts)) + return cfg + + +def default_setup(args): + distributed.enable(overwrite=True) + seed = getattr(args, "seed", 0) + rank = distributed.get_global_rank() + + global logger + setup_logging(output=args.output_dir, level=logging.INFO) + logger = logging.getLogger("dinov2") + + utils.fix_random_seeds(seed + rank) + logger.info("git:\n {}\n".format(utils.get_sha())) + logger.info("\n".join("%s: %s" % (k, str(v)) for k, v in sorted(dict(vars(args)).items()))) + + +def setup(args): + """ + Create configs and perform basic setups. + """ + cfg = get_cfg_from_args(args) + os.makedirs(args.output_dir, exist_ok=True) + default_setup(args) + apply_scaling_rules_to_cfg(cfg) + write_config(cfg, args.output_dir) + return cfg diff --git a/OpenMidnight/dinov2/utils/dtype.py b/OpenMidnight/dinov2/utils/dtype.py new file mode 100644 index 0000000000000000000000000000000000000000..80f4cd74d99faa2731dbe9f8d3a13d71b3f8e3a8 --- /dev/null +++ b/OpenMidnight/dinov2/utils/dtype.py @@ -0,0 +1,37 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + + +from typing import Dict, Union + +import numpy as np +import torch + + +TypeSpec = Union[str, np.dtype, torch.dtype] + + +_NUMPY_TO_TORCH_DTYPE: Dict[np.dtype, torch.dtype] = { + np.dtype("bool"): torch.bool, + np.dtype("uint8"): torch.uint8, + np.dtype("int8"): torch.int8, + np.dtype("int16"): torch.int16, + np.dtype("int32"): torch.int32, + np.dtype("int64"): torch.int64, + np.dtype("float16"): torch.float16, + np.dtype("float32"): torch.float32, + np.dtype("float64"): torch.float64, + np.dtype("complex64"): torch.complex64, + np.dtype("complex128"): torch.complex128, +} + + +def as_torch_dtype(dtype: TypeSpec) -> torch.dtype: + if isinstance(dtype, torch.dtype): + return dtype + if isinstance(dtype, str): + dtype = np.dtype(dtype) + assert isinstance(dtype, np.dtype), f"Expected an instance of nunpy dtype, got {type(dtype)}" + return _NUMPY_TO_TORCH_DTYPE[dtype] diff --git a/OpenMidnight/dinov2/utils/param_groups.py b/OpenMidnight/dinov2/utils/param_groups.py new file mode 100644 index 0000000000000000000000000000000000000000..9a5d2ff627cddadc222e5f836864ee39c865208f --- /dev/null +++ b/OpenMidnight/dinov2/utils/param_groups.py @@ -0,0 +1,103 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +from collections import defaultdict +import logging + + +logger = logging.getLogger("dinov2") + + +def get_vit_lr_decay_rate(name, lr_decay_rate=1.0, num_layers=12, force_is_backbone=False, chunked_blocks=False): + """ + Calculate lr decay rate for different ViT blocks. + Args: + name (string): parameter name. + lr_decay_rate (float): base lr decay rate. + num_layers (int): number of ViT blocks. + Returns: + lr decay rate for the given parameter. + """ + layer_id = num_layers + 1 + if name.startswith("backbone") or force_is_backbone: + if ( + ".pos_embed" in name + or ".patch_embed" in name + or ".mask_token" in name + or ".cls_token" in name + or ".register_tokens" in name + ): + layer_id = 0 + elif force_is_backbone and ( + "pos_embed" in name + or "patch_embed" in name + or "mask_token" in name + or "cls_token" in name + or "register_tokens" in name + ): + layer_id = 0 + elif ".blocks." in name and ".residual." not in name: + layer_id = int(name[name.find(".blocks.") :].split(".")[2]) + 1 + elif chunked_blocks and "blocks." in name and "residual." not in name: + layer_id = int(name[name.find("blocks.") :].split(".")[2]) + 1 + elif "blocks." in name and "residual." not in name: + layer_id = int(name[name.find("blocks.") :].split(".")[1]) + 1 + + return lr_decay_rate ** (num_layers + 1 - layer_id) + + +def get_params_groups_with_decay(model, lr_decay_rate=1.0, patch_embed_lr_mult=1.0): + chunked_blocks = False + if hasattr(model, "n_blocks"): + logger.info("chunked fsdp") + n_blocks = model.n_blocks + chunked_blocks = model.chunked_blocks + elif hasattr(model, "blocks"): + logger.info("first code branch") + n_blocks = len(model.blocks) + elif hasattr(model, "backbone"): + logger.info("second code branch") + n_blocks = len(model.backbone.blocks) + else: + logger.info("else code branch") + n_blocks = 0 + all_param_groups = [] + + for name, param in model.named_parameters(): + name = name.replace("_fsdp_wrapped_module.", "") + if not param.requires_grad: + continue + decay_rate = get_vit_lr_decay_rate( + name, lr_decay_rate, num_layers=n_blocks, force_is_backbone=n_blocks > 0, chunked_blocks=chunked_blocks + ) + d = {"params": param, "is_last_layer": False, "lr_multiplier": decay_rate, "wd_multiplier": 1.0, "name": name} + + if "last_layer" in name: + d.update({"is_last_layer": True}) + + if name.endswith(".bias") or "norm" in name or "gamma" in name: + d.update({"wd_multiplier": 0.0}) + + if "patch_embed" in name: + d.update({"lr_multiplier": d["lr_multiplier"] * patch_embed_lr_mult}) + + all_param_groups.append(d) + logger.info(f"""{name}: lr_multiplier: {d["lr_multiplier"]}, wd_multiplier: {d["wd_multiplier"]}""") + + return all_param_groups + + +def fuse_params_groups(all_params_groups, keys=("lr_multiplier", "wd_multiplier", "is_last_layer")): + fused_params_groups = defaultdict(lambda: {"params": []}) + for d in all_params_groups: + identifier = "" + for k in keys: + identifier += k + str(d[k]) + "_" + + for k in keys: + fused_params_groups[identifier][k] = d[k] + fused_params_groups[identifier]["params"].append(d["params"]) + + return fused_params_groups.values() diff --git a/OpenMidnight/dinov2/utils/utils.py b/OpenMidnight/dinov2/utils/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..68f8e2c3be5f780bbb7e00359b5ac4fd0ba0785f --- /dev/null +++ b/OpenMidnight/dinov2/utils/utils.py @@ -0,0 +1,95 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the Apache License, Version 2.0 +# found in the LICENSE file in the root directory of this source tree. + +import logging +import os +import random +import subprocess +from urllib.parse import urlparse + +import numpy as np +import torch +from torch import nn + + +logger = logging.getLogger("dinov2") + + +def load_pretrained_weights(model, pretrained_weights, checkpoint_key): + if urlparse(pretrained_weights).scheme: # If it looks like an URL + state_dict = torch.hub.load_state_dict_from_url(pretrained_weights, map_location="cpu") + else: + state_dict = torch.load(pretrained_weights, map_location="cpu") + if checkpoint_key is not None and checkpoint_key in state_dict: + logger.info(f"Take key {checkpoint_key} in provided checkpoint dict") + state_dict = state_dict[checkpoint_key] + # remove `module.` prefix + state_dict = {k.replace("module.", ""): v for k, v in state_dict.items()} + # remove `backbone.` prefix induced by multicrop wrapper + state_dict = {k.replace("backbone.", ""): v for k, v in state_dict.items()} + msg = model.load_state_dict(state_dict, strict=False) + logger.info("Pretrained weights found at {} and loaded with msg: {}".format(pretrained_weights, msg)) + + +def fix_random_seeds(seed=31): + """ + Fix random seeds. + """ + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + np.random.seed(seed) + random.seed(seed) + + +def get_sha(): + cwd = os.path.dirname(os.path.abspath(__file__)) + + def _run(command): + return subprocess.check_output(command, cwd=cwd).decode("ascii").strip() + + sha = "N/A" + diff = "clean" + branch = "N/A" + try: + sha = _run(["git", "rev-parse", "HEAD"]) + subprocess.check_output(["git", "diff"], cwd=cwd) + diff = _run(["git", "diff-index", "HEAD"]) + diff = "has uncommitted changes" if diff else "clean" + branch = _run(["git", "rev-parse", "--abbrev-ref", "HEAD"]) + except Exception: + pass + message = f"sha: {sha}, status: {diff}, branch: {branch}" + return message + + +class CosineScheduler(object): + def __init__(self, base_value, final_value, total_iters, warmup_iters=0, start_warmup_value=0, freeze_iters=0): + super().__init__() + self.final_value = final_value + self.total_iters = total_iters + + freeze_schedule = np.zeros((freeze_iters)) + + warmup_schedule = np.linspace(start_warmup_value, base_value, warmup_iters) + + iters = np.arange(total_iters - warmup_iters - freeze_iters) + schedule = final_value + 0.5 * (base_value - final_value) * (1 + np.cos(np.pi * iters / len(iters))) + self.schedule = np.concatenate((freeze_schedule, warmup_schedule, schedule)) + + assert len(self.schedule) == self.total_iters + + def __getitem__(self, it): + if it >= self.total_iters: + return self.final_value + else: + return self.schedule[it] + + +def has_batchnorms(model): + bn_types = (nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d, nn.SyncBatchNorm) + for name, module in model.named_modules(): + if isinstance(module, bn_types): + return True + return False diff --git a/OpenMidnight/eval_config b/OpenMidnight/eval_config new file mode 100644 index 0000000000000000000000000000000000000000..a899adfabb21edce4beec4ad3f0c5dba146b87f7 --- /dev/null +++ b/OpenMidnight/eval_config @@ -0,0 +1,116 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 5} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, dino_vits16}/offline/bach} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 12500} + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/MulticlassAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 1250} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationEmbeddingsWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings}/${oc.env:MODEL_NAME, dino_vits16}/bach + dataloader_idx_map: + 0: train + 1: val + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 #facebookresearch/dino:main + model: dinov2_vits14_reg #dino_vits16 + pretrained: false + checkpoint_path: ./output2/eval/training_74999/teacher_checkpoint.pth + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: torch.nn.Linear + init_args: + in_features: ${oc.env:IN_FEATURES, 384} + out_features: &NUM_CLASSES 4 + criterion: torch.nn.CrossEntropyLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.0003} + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.MulticlassClassificationMetrics + init_args: + num_classes: *NUM_CLASSES +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.EmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + val: + class_path: eva.datasets.EmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: val + predict: + - class_path: eva.vision.datasets.BACH + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, ./data/bach} + split: train + download: ${oc.env:DOWNLOAD_DATA, false} + # Set `download: true` to download the dataset from https://zenodo.org/records/3632035 + # The BACH dataset is distributed under the following license + # Attribution-NonCommercial-NoDerivs 4.0 International license + # (see: https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode) + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} #Flagged for maybe needs fixing + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.BACH + init_args: + <<: *PREDICT_DATASET_ARGS + split: val + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 256} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS + diff --git a/OpenMidnight/eval_configs/bach.yaml b/OpenMidnight/eval_configs/bach.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8400b7251ecf6f074a55245214a98a56c845e0b9 --- /dev/null +++ b/OpenMidnight/eval_configs/bach.yaml @@ -0,0 +1,117 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 5} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, vitg14_reg}/offline/bach} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 12500} + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + devices: ${oc.env:NUM_DEVICES, 1} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/MulticlassAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 1250} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationEmbeddingsInMemoryWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings}/${oc.env:MODEL_NAME, vitg14_reg}/bach + dataloader_idx_map: + 0: train + 1: val + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 + model: dinov2_vitg14_reg + pretrained: true + checkpoint_path: ${oc.env:CHECKPOINT_PATH, ../checkpoints/teacher_epoch250000.pth} + + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: torch.nn.Linear + init_args: + in_features: ${oc.env:IN_FEATURES, 1536} + out_features: &NUM_CLASSES 4 + criterion: torch.nn.CrossEntropyLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.0003} + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.MulticlassClassificationMetrics + init_args: + num_classes: *NUM_CLASSES +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + val: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: val + predict: + - class_path: eva.vision.datasets.BACH + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, /block/eva-data/bach} + split: train + download: ${oc.env:DOWNLOAD_DATA, false} + # Set `download: true` to download the dataset from https://zenodo.org/records/3632035 + # The BACH dataset is distributed under the following license + # Attribution-NonCommercial-NoDerivs 4.0 International license + # (see: https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode) + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} #Flagged for maybe needs fixing + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.BACH + init_args: + <<: *PREDICT_DATASET_ARGS + split: val + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 256} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS diff --git a/OpenMidnight/eval_configs/bracs.yaml b/OpenMidnight/eval_configs/bracs.yaml new file mode 100644 index 0000000000000000000000000000000000000000..abb3d09cc327218c836dde3dcea9c9b88b8acc53 --- /dev/null +++ b/OpenMidnight/eval_configs/bracs.yaml @@ -0,0 +1,126 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 5} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, vitg14_reg}/offline/bracs} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 12500} + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + accelerator: ${oc.env:ACCELERATOR, auto} + devices: ${oc.env:NUM_DEVICES, 1} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/MulticlassAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 167} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationEmbeddingsInMemoryWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings}/${oc.env:MODEL_NAME, vitg14_reg}/bracs + dataloader_idx_map: + 0: train + 1: val + 2: test + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 + model: dinov2_vitg14_reg + pretrained: true + checkpoint_path: ${oc.env:CHECKPOINT_PATH, ../checkpoints/teacher_epoch250000.pth} + + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: torch.nn.Linear + init_args: + in_features: ${oc.env:IN_FEATURES, 1536} + out_features: &NUM_CLASSES 7 + criterion: torch.nn.CrossEntropyLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.0003} + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.MulticlassClassificationMetrics + init_args: + num_classes: *NUM_CLASSES +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + val: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: val + test: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: test + predict: + - class_path: eva.vision.datasets.BRACS + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, /block/eva-data/bracs} + split: train + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.BRACS + init_args: + <<: *PREDICT_DATASET_ARGS + split: val + - class_path: eva.vision.datasets.BRACS + init_args: + <<: *PREDICT_DATASET_ARGS + split: test + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 256} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + test: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS diff --git a/OpenMidnight/eval_configs/breakhist.yaml b/OpenMidnight/eval_configs/breakhist.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a5d3f23639162d6ddf0e63046d692bf73127d735 --- /dev/null +++ b/OpenMidnight/eval_configs/breakhist.yaml @@ -0,0 +1,117 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 5} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, vitg14_reg}/offline/breakhis} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 12500} + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + devices: ${oc.env:NUM_DEVICES, 1} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/MulticlassAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 500} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationEmbeddingsInMemoryWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings}/${oc.env:MODEL_NAME, vitg14_reg}/breakhis + dataloader_idx_map: + 0: train + 1: val + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 + model: dinov2_vitg14_reg + pretrained: true + checkpoint_path: ${oc.env:CHECKPOINT_PATH, ../checkpoints/teacher_epoch250000.pth} + + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: torch.nn.Linear + init_args: + in_features: ${oc.env:IN_FEATURES, 1536} + out_features: &NUM_CLASSES 4 + criterion: torch.nn.CrossEntropyLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.0003} + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.MulticlassClassificationMetrics + init_args: + num_classes: *NUM_CLASSES +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + val: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: val + predict: + - class_path: eva.vision.datasets.BreaKHis + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, /block/eva-data/breakhis} + split: train + download: True + # Set `download: true` to download the dataset from https://zenodo.org/records/1214456 + # The BreaKHis dataset is distributed under the following license: "CC BY 4.0" + # (see: https://creativecommons.org/licenses/by/4.0/) + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.BreaKHis + init_args: + <<: *PREDICT_DATASET_ARGS + split: val + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 256} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS + diff --git a/OpenMidnight/eval_configs/cam16_small.yaml b/OpenMidnight/eval_configs/cam16_small.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f8f7206d6a61a28b913f2bc65b76fb6e681b2ecf --- /dev/null +++ b/OpenMidnight/eval_configs/cam16_small.yaml @@ -0,0 +1,144 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 20} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, vitg14_reg}/offline/camelyon16} + max_epochs: &MAX_EPOCHS ${oc.env:MAX_EPOCHS, 100} + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + accelerator: ${oc.env:ACCELERATOR, auto} + devices: ${oc.env:NUM_DEVICES, 1} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/BinaryBalancedAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 20} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationMultiEmbeddingsInMemoryWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings/${oc.env:MODEL_NAME, vitg14_reg}/camelyon16} + save_every_n: 10_000 + dataloader_idx_map: + 0: train + 1: val + 2: test + metadata_keys: ["wsi_id"] + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 + model: dinov2_vitg14_reg + pretrained: true + checkpoint_path: ${oc.env:CHECKPOINT_PATH, ../checkpoints/teacher_epoch250000.pth} + + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: eva.vision.models.networks.ABMIL + init_args: + input_size: ${oc.env:IN_FEATURES, 1536} + output_size: &NUM_CLASSES 1 + projected_input_size: 128 + criterion: torch.nn.BCEWithLogitsLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.001} + betas: [0.9, 0.999] + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.BinaryClassificationMetrics +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.InMemoryMultiEmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + embeddings_transforms: + class_path: eva.core.data.transforms.Pad2DTensor + init_args: + pad_size: &N_PATCHES ${oc.env:N_PATCHES, 1000} + target_transforms: + class_path: torchvision.transforms.v2.ToDtype + init_args: + dtype: torch.float32 + val: + class_path: eva.datasets.InMemoryMultiEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: val + test: + class_path: eva.datasets.InMemoryMultiEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: test + predict: + - class_path: eva.vision.datasets.Camelyon16 + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, /block/eva-data/camelyon16} + sampler: + class_path: eva.vision.data.wsi.patching.samplers.ForegroundGridSampler + init_args: + max_samples: *N_PATCHES + width: 224 + height: 224 + target_mpp: 0.25 + split: train + coords_path: ${data.init_args.datasets.train.init_args.root}/coords_${.split}.csv + image_transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.Camelyon16 + init_args: + <<: *PREDICT_DATASET_ARGS + split: val + - class_path: eva.vision.datasets.Camelyon16 + init_args: + <<: *PREDICT_DATASET_ARGS + split: test + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 32} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + test: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS diff --git a/OpenMidnight/eval_configs/consep.yaml b/OpenMidnight/eval_configs/consep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..bfa1530cb983e79608802e709c96345a5494a31d --- /dev/null +++ b/OpenMidnight/eval_configs/consep.yaml @@ -0,0 +1,119 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 5} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, vit_small_patch16_224_dino}/consep} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 2000} + log_every_n_steps: 6 + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + devices: ${oc.env:NUM_DEVICES, 1} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: eva.vision.callbacks.SemanticSegmentationLogger + init_args: + log_every_n_epochs: 1 + mean: &NORMALIZE_MEAN ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} + std: &NORMALIZE_STD ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, 'val/MonaiDiceScore'} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 200} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.vision.models.modules.SemanticSegmentationModule + init_args: + encoder: + class_path: eva.core.models.wrappers.TorchHubModel + init_args: + repo_or_dir: facebookresearch/dinov2 + model_name: dinov2_vitg14_reg + pretrained: true + out_indices: 1 + checkpoint_path: ${oc.env:CHECKPOINT_PATH, ../checkpoints/teacher_epoch250000.pth} + decoder: + class_path: eva.vision.models.networks.decoders.segmentation.ConvDecoderWithImage + init_args: + in_features: ${oc.env:IN_FEATURES, 1536} + num_classes: &NUM_CLASSES 5 + criterion: + class_path: eva.vision.losses.DiceLoss + init_args: + softmax: true + batch: true + lr_multiplier_encoder: 0.0 + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.002} + postprocess: + predictions_transforms: + - class_path: torch.argmax + init_args: + dim: 1 + metrics: + common: + - class_path: eva.metrics.AverageLoss + evaluation: + - class_path: eva.vision.metrics.defaults.MulticlassSegmentationMetrics + init_args: + num_classes: *NUM_CLASSES + - class_path: torchmetrics.ClasswiseWrapper + init_args: + metric: + class_path: eva.vision.metrics.MonaiDiceScore + init_args: + include_background: true + num_classes: *NUM_CLASSES + reduction: none + labels: + - background + - other + - inflammatory + - epithelial + - spindle-shaped +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.vision.datasets.CoNSeP + init_args: &DATASET_ARGS + root: ${oc.env:DATA_ROOT, /block/eva-data/consep} + split: train + sampler: eva.vision.data.wsi.patching.samplers.GridSampler + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: *NORMALIZE_MEAN + std: *NORMALIZE_STD + val: + class_path: eva.vision.datasets.CoNSeP + init_args: + <<: *DATASET_ARGS + split: val + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 64} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS diff --git a/OpenMidnight/eval_configs/crc.yaml b/OpenMidnight/eval_configs/crc.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b7e3150097553998db9fad06c978528006f7f894 --- /dev/null +++ b/OpenMidnight/eval_configs/crc.yaml @@ -0,0 +1,117 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 5} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, vitg14_reg}/offline/crc} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 12500} + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + devices: ${oc.env:NUM_DEVICES, 1} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/MulticlassAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 7} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationEmbeddingsInMemoryWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings}/${oc.env:MODEL_NAME, vitg14_reg}/crc + dataloader_idx_map: + 0: train + 1: val + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 + model: dinov2_vitg14_reg + pretrained: true + checkpoint_path: ${oc.env:CHECKPOINT_PATH, ../checkpoints/teacher_epoch250000.pth} + + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: torch.nn.Linear + init_args: + in_features: ${oc.env:IN_FEATURES, 1536} + out_features: &NUM_CLASSES 9 + criterion: torch.nn.CrossEntropyLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.0003} + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.MulticlassClassificationMetrics + init_args: + num_classes: *NUM_CLASSES +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + val: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: val + predict: + - class_path: eva.vision.datasets.CRC + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, /block/eva-data/crc} + split: train + download: True + # Set `download: true` to download the dataset from https://zenodo.org/records/1214456 + # The CRC dataset is distributed under the following license: "CC BY 4.0 LEGAL CODE" + # (see: https://creativecommons.org/licenses/by/4.0/legalcode) + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.CRC + init_args: + <<: *PREDICT_DATASET_ARGS + split: val + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 256} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS + diff --git a/OpenMidnight/eval_configs/gleason.yaml b/OpenMidnight/eval_configs/gleason.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8786c0861bc590af47f300bd722da781ec29a6d2 --- /dev/null +++ b/OpenMidnight/eval_configs/gleason.yaml @@ -0,0 +1,119 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 5} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, vitg14_reg}/offline/gleason_arvaniti} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 12500} + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + devices: ${oc.env:NUM_DEVICES, 1} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/MulticlassAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 42} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationEmbeddingsInMemoryWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings}/${oc.env:MODEL_NAME, vitg14_reg}/gleason_arvaniti + dataloader_idx_map: + 0: train + 1: val + #backbone: + #class_path: eva.vision.models.ModelFromRegistry + #init_args: + #model_name: ${oc.env:MODEL_NAME, universal/vit_small_patch16_224_dino} + #model_extra_kwargs: ${oc.env:MODEL_EXTRA_KWARGS, null} + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 + model: dinov2_vitg14_reg + pretrained: true + checkpoint_path: ${oc.env:CHECKPOINT_PATH, ../checkpoints/teacher_epoch250000.pth} + + + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: torch.nn.Linear + init_args: + in_features: ${oc.env:IN_FEATURES, 1536} + out_features: &NUM_CLASSES 4 + criterion: torch.nn.CrossEntropyLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.0003} + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.MulticlassClassificationMetrics + init_args: + num_classes: *NUM_CLASSES +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + val: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: val + predict: + - class_path: eva.vision.datasets.GleasonArvaniti + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, /block/eva-data/arvaniti_gleason_patches} + split: train + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.GleasonArvaniti + init_args: + <<: *PREDICT_DATASET_ARGS + split: val + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 256} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS + diff --git a/OpenMidnight/eval_configs/mhist.yaml b/OpenMidnight/eval_configs/mhist.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4a09f43702eb1956107e6a11bb47993753f90bd4 --- /dev/null +++ b/OpenMidnight/eval_configs/mhist.yaml @@ -0,0 +1,113 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 5} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, vitg14_reg}/offline/mhist} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 12500} + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + devices: ${oc.env:NUM_DEVICES, 1} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/BinaryBalancedAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 278} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationEmbeddingsInMemoryWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings}/${oc.env:MODEL_NAME, vitg14_reg}/mhist + dataloader_idx_map: + 0: train + 1: val + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 + model: dinov2_vitg14_reg + pretrained: true + checkpoint_path: ${oc.env:CHECKPOINT_PATH, ../checkpoints/teacher_epoch250000.pth} + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: torch.nn.Linear + init_args: + in_features: ${oc.env:IN_FEATURES, 1536} + out_features: 1 + criterion: torch.nn.BCEWithLogitsLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.0003} + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.BinaryClassificationMetrics +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + target_transforms: + class_path: torchvision.transforms.v2.ToDtype + init_args: + dtype: torch.float32 + val: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: test + predict: + - class_path: eva.vision.datasets.MHIST + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, /block/eva-data/mhist} + split: train + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.MHIST + init_args: + <<: *PREDICT_DATASET_ARGS + split: test + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 256} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS diff --git a/OpenMidnight/eval_configs/monusac.yaml b/OpenMidnight/eval_configs/monusac.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c406125793293f07370c1f994282c4e8a573cc5f --- /dev/null +++ b/OpenMidnight/eval_configs/monusac.yaml @@ -0,0 +1,143 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 5} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, vit_small_patch16_224_dino}/monusac} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 2000} + log_every_n_steps: 6 + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + devices: ${oc.env:NUM_DEVICES, 1} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: eva.vision.callbacks.SemanticSegmentationLogger + init_args: + log_every_n_epochs: 1 + mean: &NORMALIZE_MEAN ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} + std: &NORMALIZE_STD ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, 'val/MonaiDiceScore'} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 100} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.vision.models.modules.SemanticSegmentationModule + init_args: + encoder: + class_path: eva.core.models.wrappers.TorchHubModel + init_args: + repo_or_dir: facebookresearch/dinov2 + model_name: dinov2_vitg14_reg + pretrained: true + out_indices: 1 + checkpoint_path: ${oc.env:CHECKPOINT_PATH, ../checkpoints/teacher_epoch250000.pth} + + decoder: + class_path: eva.vision.models.networks.decoders.segmentation.ConvDecoderWithImage + init_args: + in_features: ${oc.env:IN_FEATURES, 1536} + num_classes: &NUM_CLASSES 5 + criterion: + class_path: eva.vision.losses.DiceLoss + init_args: + softmax: true + batch: true + ignore_index: &IGNORE_INDEX 5 + lr_multiplier_encoder: 0.0 + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.002} + postprocess: + predictions_transforms: + - class_path: torch.argmax + init_args: + dim: 1 + metrics: + common: + - class_path: eva.metrics.AverageLoss + evaluation: + - class_path: eva.vision.metrics.defaults.MulticlassSegmentationMetrics + init_args: + num_classes: 6 + ignore_index: *IGNORE_INDEX + - class_path: torchmetrics.ClasswiseWrapper + init_args: + metric: + class_path: eva.vision.metrics.MonaiDiceScore + init_args: + include_background: true + num_classes: 6 + reduction: none + ignore_index: *IGNORE_INDEX + labels: + - background + - epithelial + - lymphocyte + - neutrophil + - macrophage + - ambiguous +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.vision.datasets.MoNuSAC + init_args: &DATASET_ARGS + root: ${oc.env:DATA_ROOT, /block/eva-data/monusac} + split: train + download: ${oc.env:DOWNLOAD_DATA, false} + # Set `download: true` to download the dataset from https://monusac-2020.grand-challenge.org/Data/ + # The MoNuSAC dataset is distributed under the following license: + # "Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International" + # (see: https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode) + transforms: + class_path: torchvision.transforms.v2.Compose + init_args: + transforms: + - class_path: torchvision.transforms.v2.RandomResizedCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + - class_path: torchvision.transforms.v2.ToDtype + init_args: + dtype: torch.float32 + scale: true + - class_path: torchvision.transforms.v2.Normalize + init_args: + mean: *NORMALIZE_MEAN + std: *NORMALIZE_STD + val: + class_path: eva.vision.datasets.MoNuSAC + init_args: + <<: *DATASET_ARGS + split: test + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: *NORMALIZE_MEAN + std: *NORMALIZE_STD + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 64} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS diff --git a/OpenMidnight/eval_configs/panda_small.yaml b/OpenMidnight/eval_configs/panda_small.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0cb441902aa0c1b5a96e6bae90f9da5337c08712 --- /dev/null +++ b/OpenMidnight/eval_configs/panda_small.yaml @@ -0,0 +1,141 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 20} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, vitg14_reg}/offline/panda} + max_epochs: &MAX_EPOCHS ${oc.env:MAX_EPOCHS, 100} + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + accelerator: ${oc.env:ACCELERATOR, auto} + devices: ${oc.env:NUM_DEVICES, 1} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/MulticlassAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 20} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationMultiEmbeddingsInMemoryWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings/${oc.env:MODEL_NAME, vitg14_reg}/panda} + dataloader_idx_map: + 0: train + 1: val + 2: test + metadata_keys: ["wsi_id"] + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 + model: dinov2_vitg14_reg + pretrained: true + checkpoint_path: ${oc.env:CHECKPOINT_PATH, ../checkpoints/teacher_epoch250000.pth} + + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: eva.vision.models.networks.ABMIL + init_args: + input_size: ${oc.env:IN_FEATURES, 1536} + output_size: &NUM_CLASSES 6 + projected_input_size: 128 + criterion: torch.nn.CrossEntropyLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.001} + betas: [0.9, 0.999] + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.MulticlassClassificationMetrics + init_args: + num_classes: *NUM_CLASSES +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.InMemoryMultiEmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + embeddings_transforms: + class_path: eva.core.data.transforms.Pad2DTensor + init_args: + pad_size: &N_PATCHES ${oc.env:N_PATCHES, 200} + val: + class_path: eva.datasets.InMemoryMultiEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: val + test: + class_path: eva.datasets.InMemoryMultiEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: test + predict: + - class_path: eva.vision.datasets.PANDASmall + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, /block/eva-data/panda/prostate-cancer-grade-assessment} + sampler: + class_path: eva.vision.data.wsi.patching.samplers.ForegroundGridSampler + init_args: + max_samples: *N_PATCHES + width: 224 + height: 224 + target_mpp: 0.5 + split: train + coords_path: ${data.init_args.datasets.train.init_args.root}/coords_${.split}.csv + image_transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.PANDASmall + init_args: + <<: *PREDICT_DATASET_ARGS + split: val + - class_path: eva.vision.datasets.PANDASmall + init_args: + <<: *PREDICT_DATASET_ARGS + split: test + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 32} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + test: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS diff --git a/OpenMidnight/eval_configs/pcam.yaml b/OpenMidnight/eval_configs/pcam.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f48fec7b627aa3c0860e5b7a281e9cb6d57ba659 --- /dev/null +++ b/OpenMidnight/eval_configs/pcam.yaml @@ -0,0 +1,132 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 5} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, vitg14_reg}/offline/patch_camelyon} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 12500} + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + devices: ${oc.env:NUM_DEVICES, 1} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/BinaryBalancedAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0 + patience: ${oc.env:PATIENCE, 3} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationEmbeddingsInMemoryWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings}/${oc.env:MODEL_NAME, vitg14_reg}/patch_camelyon + dataloader_idx_map: + 0: train + 1: val + 2: test + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 + model: dinov2_vitg14_reg + pretrained: true + checkpoint_path: ${oc.env:CHECKPOINT_PATH, ../checkpoints/teacher_epoch250000.pth} + + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: torch.nn.Linear + init_args: + in_features: ${oc.env:IN_FEATURES, 1536} + out_features: 1 + criterion: torch.nn.BCEWithLogitsLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.0003} + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.BinaryClassificationMetrics +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + target_transforms: + class_path: torchvision.transforms.v2.ToDtype + init_args: + dtype: torch.float32 + val: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: val + test: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: test + predict: + - class_path: eva.vision.datasets.PatchCamelyon + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, /block/eva-data/patch_camelyon} + split: train + download: ${oc.env:DOWNLOAD_DATA, false} + # Set `download: true` to download the dataset from https://zenodo.org/records/1494286 + # The PatchCamelyon dataset is distributed under the following license: + # "Creative Commons Zero v1.0 Universal" + # (see: https://choosealicense.com/licenses/cc0-1.0/) + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.PatchCamelyon + init_args: + <<: *PREDICT_DATASET_ARGS + split: val + - class_path: eva.vision.datasets.PatchCamelyon + init_args: + <<: *PREDICT_DATASET_ARGS + split: test + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 256} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: true + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + test: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS diff --git a/OpenMidnight/eval_configs/pcam_10.yaml b/OpenMidnight/eval_configs/pcam_10.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c6177565d4fdd1b43d7a7ff6ceb8f0d742d6d47a --- /dev/null +++ b/OpenMidnight/eval_configs/pcam_10.yaml @@ -0,0 +1,143 @@ +--- +trainer: + class_path: eva.Trainer + init_args: + n_runs: &N_RUNS ${oc.env:N_RUNS, 50} + default_root_dir: &OUTPUT_ROOT ${oc.env:OUTPUT_ROOT, logs/${oc.env:MODEL_NAME, vitg14_reg}/offline/patch_camelyon} + max_steps: &MAX_STEPS ${oc.env:MAX_STEPS, 12500} + num_sanity_val_steps: 0 + check_val_every_n_epoch: 10 + checkpoint_type: ${oc.env:CHECKPOINT_TYPE, best} + devices: ${oc.env:NUM_DEVICES, 1} + callbacks: + - class_path: eva.callbacks.ConfigurationLogger + - class_path: lightning.pytorch.callbacks.TQDMProgressBar + init_args: + refresh_rate: ${oc.env:TQDM_REFRESH_RATE, 1} + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: epoch + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + filename: best + save_last: ${oc.env:SAVE_LAST, false} + save_top_k: 1 + monitor: &MONITOR_METRIC ${oc.env:MONITOR_METRIC, val/BinaryBalancedAccuracy} + mode: &MONITOR_METRIC_MODE ${oc.env:MONITOR_METRIC_MODE, max} + - class_path: lightning.pytorch.callbacks.EarlyStopping + init_args: + min_delta: 0.0001 + patience: ${oc.env:PATIENCE, 125} + monitor: *MONITOR_METRIC + mode: *MONITOR_METRIC_MODE + - class_path: eva.callbacks.ClassificationEmbeddingsInMemoryWriter + init_args: + output_dir: &DATASET_EMBEDDINGS_ROOT ${oc.env:EMBEDDINGS_ROOT, ./data/embeddings}/${oc.env:MODEL_NAME, vitg14_reg}/patch_camelyon + dataloader_idx_map: + 0: train + 1: val + 2: test + backbone: + class_path: eva.core.models.wrappers.ModelFromFunction + init_args: + path: torch.hub.load + arguments: + repo_or_dir: facebookresearch/dinov2 + model: dinov2_vitg14_reg + pretrained: true + checkpoint_path: ${oc.env:CHECKPOINT_PATH, ../checkpoints/teacher_epoch250000.pth} + + overwrite: true + logger: + - class_path: lightning.pytorch.loggers.TensorBoardLogger + init_args: + save_dir: *OUTPUT_ROOT + name: "" +model: + class_path: eva.HeadModule + init_args: + head: + class_path: torch.nn.Linear + init_args: + in_features: ${oc.env:IN_FEATURES, 1536} + out_features: 1 + criterion: torch.nn.BCEWithLogitsLoss + optimizer: + class_path: torch.optim.AdamW + init_args: + lr: ${oc.env:LR_VALUE, 0.0003} + metrics: + common: + - class_path: eva.metrics.AverageLoss + - class_path: eva.metrics.BinaryClassificationMetrics +data: + class_path: eva.DataModule + init_args: + datasets: + train: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: &DATASET_ARGS + root: *DATASET_EMBEDDINGS_ROOT + manifest_file: manifest.csv + split: train + target_transforms: + class_path: torchvision.transforms.v2.ToDtype + init_args: + dtype: torch.float32 + val: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: val + test: + class_path: eva.datasets.InMemoryEmbeddingsClassificationDataset + init_args: + <<: *DATASET_ARGS + split: test + predict: + - class_path: eva.vision.datasets.PatchCamelyon + init_args: &PREDICT_DATASET_ARGS + root: ${oc.env:DATA_ROOT, /block/eva-data/patch_camelyon} + split: train + download: ${oc.env:DOWNLOAD_DATA, false} + # Set `download: true` to download the dataset from https://zenodo.org/records/1494286 + # The PatchCamelyon dataset is distributed under the following license: + # "Creative Commons Zero v1.0 Universal" + # (see: https://choosealicense.com/licenses/cc0-1.0/) + transforms: + class_path: eva.vision.data.transforms.common.ResizeAndCrop + init_args: + size: ${oc.env:RESIZE_DIM, 224} + mean: ${oc.env:NORMALIZE_MEAN, [0.485, 0.456, 0.406]} + std: ${oc.env:NORMALIZE_STD, [0.229, 0.224, 0.225]} + - class_path: eva.vision.datasets.PatchCamelyon + init_args: + <<: *PREDICT_DATASET_ARGS + split: val + - class_path: eva.vision.datasets.PatchCamelyon + init_args: + <<: *PREDICT_DATASET_ARGS + split: test + dataloaders: + train: + batch_size: &BATCH_SIZE ${oc.env:BATCH_SIZE, 256} + num_workers: &N_DATA_WORKERS ${oc.env:N_DATA_WORKERS, 4} + shuffle: false + val: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + test: + batch_size: *BATCH_SIZE + num_workers: *N_DATA_WORKERS + predict: + batch_size: &PREDICT_BATCH_SIZE ${oc.env:PREDICT_BATCH_SIZE, 64} + num_workers: *N_DATA_WORKERS + samplers: + train: + class_path: eva.core.data.samplers.classification.BalancedSampler + init_args: + num_samples: 10 + predict: + class_path: eva.core.data.samplers.classification.BalancedSampler + init_args: + num_samples: 10 diff --git a/OpenMidnight/install.sh b/OpenMidnight/install.sh new file mode 100644 index 0000000000000000000000000000000000000000..06718c585272ddc85ee485519cba29f30b891c0b --- /dev/null +++ b/OpenMidnight/install.sh @@ -0,0 +1,44 @@ +#!/usr/bin/env bash +set -euo pipefail + +# This script bootstraps the project using uv, installing the managed Python, +# dependencies described in pyproject.toml, and GPU-aware PyTorch wheels. + +PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +PYTHON_VERSION="3.10.12" +DEFAULT_INSTALLER_URL="https://astral.sh/uv/install.sh" + +# Ensure `~/.local/bin` is considered when checking for uv. +export PATH="$HOME/.local/bin:$PATH" + +if ! command -v uv >/dev/null 2>&1; then + INSTALLER_URL="${UV_INSTALLER_URL:-$DEFAULT_INSTALLER_URL}" + echo "uv not found on PATH; installing from ${INSTALLER_URL}..." + if command -v curl >/dev/null 2>&1; then + curl -LsSf "${INSTALLER_URL}" | sh + elif command -v wget >/dev/null 2>&1; then + wget -qO- "${INSTALLER_URL}" | sh + else + echo "Neither curl nor wget is available; please install one and re-run." >&2 + exit 1 + fi + hash -r +fi + +cd "${PROJECT_ROOT}" + +# Make sure the pinned interpreter is available so `uv sync` does not prompt. +if ! uv python list --only-installed | grep -q "${PYTHON_VERSION}"; then + echo "Installing Python ${PYTHON_VERSION} via uv..." + uv python install "${PYTHON_VERSION}" +fi + +# Create the project venv (uses the uv-managed Python above). +uv venv +uv pip install -e . --torch-backend=auto -p .venv/bin/python + +# Loosen transformers' hub pin so hub 1.x works. +.venv/bin/python -c "import transformers.dependency_versions_table as t;from pathlib import Path;p=Path(t.__file__);p.write_text(p.read_text().replace('huggingface-hub>=0.34.0,<1.0','huggingface-hub>=0.34.0'))" + +echo "Environment ready. Activate it with 'source .venv/bin/activate' when needed." +echo "By default wandb logging is enabled, remember to run 'wandb init' before training." diff --git a/OpenMidnight/prepatching_scripts/build_parquet_sample_dataset.py b/OpenMidnight/prepatching_scripts/build_parquet_sample_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..2c5b4b2f58e4447f758f7d86c8c90b06d12b07b1 --- /dev/null +++ b/OpenMidnight/prepatching_scripts/build_parquet_sample_dataset.py @@ -0,0 +1,538 @@ +#!/usr/bin/env python3 +""" +Generate a Parquet dataset of TCGA patches described in sample_dataset_30.txt. + +Each line in the input text file is expected to follow the format emitted by +create_sample_dataset_txt.py: + + /path/to/slide.svs + +Lines that include MPP metadata from the ablation sampler are also accepted: + + /path/to/slide.svs + +The script opens every referenced slide once, extracts a 224x224 RGB patch at the +requested coordinates/level, and writes the samples into per-task Parquet files. +It supports PNG/JPEG/raw outputs, task chunking, resume markers, and optional +multi-processing. Results land in /data/TCGA_parquet_sample30/ unless overridden. +""" + +from __future__ import annotations + +import argparse +import atexit +import logging +import multiprocessing as mp +from collections import OrderedDict +from concurrent.futures import ProcessPoolExecutor, as_completed +from dataclasses import dataclass +from io import BytesIO +import os +import random +from pathlib import Path +from typing import Iterable, List, Sequence, Set, Tuple + +import numpy as np +import pyarrow as pa +import pyarrow.parquet as pq +from openslide import OpenSlide + + +@dataclass(frozen=True) +class PatchSpec: + slide_path: str + x: int + y: int + level: int + + +@dataclass(frozen=True) +class TaskConfig: + tile_size: int + encoding: str + max_open_slides: int + output_dir: str + progress_dir: str + parquet_compression: str | None + + +CACHE_LIMIT_ENV = "PARQUET_MAX_OPEN_SLIDES" +try: + _env_cache_limit = int(os.environ.get(CACHE_LIMIT_ENV, "16")) +except (TypeError, ValueError): + _env_cache_limit = 16 +DEFAULT_MAX_OPEN_SLIDES = max(1, _env_cache_limit) +MAX_OPEN_SLIDES = DEFAULT_MAX_OPEN_SLIDES +SLIDE_CACHE: "OrderedDict[str, OpenSlide]" = OrderedDict() + + +def prune_slide_cache() -> None: + """Ensure the slide cache does not exceed MAX_OPEN_SLIDES.""" + if MAX_OPEN_SLIDES < 1: + return + while len(SLIDE_CACHE) > MAX_OPEN_SLIDES: + old_path, old_slide = SLIDE_CACHE.popitem(last=False) + try: + old_slide.close() + except Exception: + logging.exception("Failed to close slide %s during cache prune.", old_path) + + +def set_max_open_slides(limit: int) -> None: + """Update cache limit and prune if needed.""" + global MAX_OPEN_SLIDES + limit = max(1, int(limit)) + if limit == MAX_OPEN_SLIDES: + return + MAX_OPEN_SLIDES = limit + prune_slide_cache() + + +def ensure_cache_limit(limit: int) -> None: + """Idempotent helper invoked inside workers.""" + try: + set_max_open_slides(limit) + except Exception: + logging.exception("Unexpected failure updating slide cache limit.") + + +@atexit.register +def close_all_slides() -> None: + """Close any slides left in the cache when the process exits.""" + while SLIDE_CACHE: + path, slide = SLIDE_CACHE.popitem(last=False) + try: + slide.close() + except Exception: + logging.exception("Failed to close slide %s during interpreter shutdown.", path) + + +def get_slide(path: str) -> OpenSlide: + slide = SLIDE_CACHE.get(path) + if slide is None: + slide = OpenSlide(path) + SLIDE_CACHE[path] = slide + SLIDE_CACHE.move_to_end(path, last=True) + prune_slide_cache() + else: + SLIDE_CACHE.move_to_end(path, last=True) + return slide + + +def parse_specs(spec_file: Path) -> List[PatchSpec]: + specs: List[PatchSpec] = [] + with spec_file.open("r", encoding="utf-8") as fh: + for idx, raw_line in enumerate(fh, start=1): + line = raw_line.strip() + if not line or line.startswith("#"): + continue + parts = line.split() + if len(parts) == 4: + slide_path, x, y, level = parts + elif len(parts) == 6: + slide_path, x, y, level, *_mpp = parts + else: + raise ValueError(f"Invalid spec line {idx}: {line}") + specs.append(PatchSpec(slide_path, int(x), int(y), int(level))) + if not specs: + raise ValueError(f"No patch specifications found in {spec_file}") + logging.info("Parsed %d patch specifications from %s.", len(specs), spec_file) + return specs + + +def group_by_slide(specs: Sequence[PatchSpec]) -> List[Tuple[str, List[PatchSpec]]]: + """Group patch specs so each slide is opened only once.""" + grouped: "OrderedDict[str, List[PatchSpec]]" = OrderedDict() + for spec in specs: + grouped.setdefault(spec.slide_path, []).append(spec) + return [(slide, patches) for slide, patches in grouped.items()] + + +def build_tasks( + groups: Sequence[Tuple[str, Sequence[PatchSpec]]], + max_patches_per_task: int, + *, + start_index: int = 0, +) -> List[Tuple[str, List[PatchSpec], str]]: + """Chunk grouped specs to improve parallel balance on large nodes.""" + tasks: List[Tuple[str, List[PatchSpec], str]] = [] + idx = start_index + for slide, patches in groups: + chunk = len(patches) if max_patches_per_task <= 0 else max_patches_per_task + for start in range(0, len(patches), chunk): + chunk_specs = list(patches[start : start + chunk]) + task_id = f"{idx:08d}" + tasks.append((slide, chunk_specs, task_id)) + idx += 1 + return tasks + + +def find_next_task_index(output_dir: Path) -> int: + """Return the next sequential task index based on existing Parquet files.""" + max_idx = -1 + for candidate in output_dir.glob("*.parquet"): + stem = candidate.stem + if stem.isdigit(): + try: + max_idx = max(max_idx, int(stem)) + except ValueError: + continue + return max_idx + 1 + + +def load_completed_task_ids(progress_dir: Path, output_dir: Path) -> Set[str]: + """Load completed task IDs from progress markers, pruning stale entries.""" + done_ids: Set[str] = set() + for marker in progress_dir.iterdir(): + if not marker.is_file(): + continue + if marker.name == "task_offset.txt": + continue + parquet_path = output_dir / f"{marker.stem}.parquet" + if parquet_path.exists(): + done_ids.add(marker.stem) + else: + marker.unlink() + return done_ids + + +def process_task_worker( + task: Tuple[str, Sequence[PatchSpec], str], + config: TaskConfig, +) -> str: + """Process a single task and materialize it to a Parquet file.""" + slide_path, specs, task_id = task + ensure_cache_limit(config.max_open_slides) + slide = get_slide(slide_path) + buf = BytesIO() if config.encoding in ("png", "jpeg") else None + + task_ids: List[str] = [] + slide_paths: List[str] = [] + xs: List[int] = [] + ys: List[int] = [] + levels: List[int] = [] + tile_sizes: List[int] = [] + level_downsamples: List[float] = [] + image_bytes: List[bytes] = [] + image_dtypes: List[str] = [] + + for spec in specs: + if spec.level < 0 or spec.level >= slide.level_count: + raise ValueError(f"Level {spec.level} invalid for {slide_path}") + region = slide.read_region( + (spec.x, spec.y), spec.level, (config.tile_size, config.tile_size) + ).convert("RGB") + + task_ids.append(task_id) + slide_paths.append(slide_path) + xs.append(spec.x) + ys.append(spec.y) + levels.append(spec.level) + tile_sizes.append(config.tile_size) + level_downsamples.append(float(slide.level_downsamples[spec.level])) + + if config.encoding == "png": + buf.seek(0) + buf.truncate(0) + region.save(buf, format="PNG", optimize=True) + image_bytes.append(buf.getvalue()) + image_dtypes.append("uint8") + elif config.encoding == "jpeg": + buf.seek(0) + buf.truncate(0) + region.save(buf, format="JPEG", quality=95, optimize=True) + image_bytes.append(buf.getvalue()) + image_dtypes.append("uint8") + else: + arr = np.asarray(region, dtype=np.uint8) + image_bytes.append(arr.tobytes()) + image_dtypes.append(str(arr.dtype)) + + table = pa.table( + { + "task_id": pa.array(task_ids, type=pa.string()), + "slide_path": pa.array(slide_paths, type=pa.string()), + "x": pa.array(xs, type=pa.int32()), + "y": pa.array(ys, type=pa.int32()), + "level": pa.array(levels, type=pa.int32()), + "tile_size": pa.array(tile_sizes, type=pa.int32()), + "level_downsample": pa.array(level_downsamples, type=pa.float32()), + "image_dtype": pa.array(image_dtypes, type=pa.string()), + "image_bytes": pa.array(image_bytes, type=pa.binary()), + } + ) + + metadata = dict(table.schema.metadata or {}) + metadata.update( + { + b"image_encoding": config.encoding.encode("utf-8"), + b"tile_size": str(config.tile_size).encode("utf-8"), + } + ) + table = table.replace_schema_metadata(metadata) + + output_path = Path(config.output_dir) / f"{task_id}.parquet" + pq.write_table(table, output_path, compression=config.parquet_compression) + progress_path = Path(config.progress_dir) / f"{task_id}.done" + progress_path.write_text("1\n") + return task_id + + +def parse_args(argv: Iterable[str] | None = None) -> argparse.Namespace: + parser = argparse.ArgumentParser( + description="Build a Parquet dataset of TCGA patches listed in a text file." + ) + parser.add_argument( + "--spec-file", + type=Path, + default=Path("sample_dataset_30.txt"), + help="Path to the text file produced by create_sample_dataset_txt.py.", + ) + parser.add_argument( + "--output-dir", + type=Path, + default=Path("/data/TCGA_parquet_sample30/"), + help="Directory where Parquet files will be written (default: /data/TCGA_parquet_sample30/).", + ) + parser.add_argument( + "--tile-size", + type=int, + default=224, + help="Square tile size (pixels) to read from each slide.", + ) + parser.add_argument( + "--num-workers", + type=int, + default=None, + help="Worker processes for parallel patch extraction (default: auto based on CPUs).", + ) + parser.add_argument( + "--start-method", + choices=("fork", "spawn", "forkserver"), + default=None, + help="Multiprocessing start method used by the worker pool (default: library default).", + ) + parser.add_argument( + "--mode", + choices=("overwrite", "append"), + default="overwrite", + help="Whether to overwrite or append to an existing Parquet dataset.", + ) + parser.add_argument( + "--keep-order", + action="store_true", + help="Keep samples in the same order as listed in the spec file.", + ) + parser.add_argument( + "--encoding", + choices=("png", "jpeg", "raw"), + default="png", + help="Patch serialization format (png: smaller, jpeg/raw: faster).", + ) + parser.add_argument( + "--task-chunk-size", + type=int, + default=42000, + help="Max patches per task to balance multi-process workloads (<=0 disables chunking). This is an arbitrarily high number which basically means that all patches for a slide will be processed in a single task. Can consider letting tasks span multiple slides in a future code revision if you want parquet files to be larger size.", + ) + parser.add_argument( + "--shuffle-tasks", + action="store_true", + help="Shuffle task order (ignored when --keep-order is set).", + ) + parser.add_argument( + "--resume", + action="store_true", + help="Skip tasks that completed in a previous run using progress markers.", + ) + parser.add_argument( + "--max-open-slides", + type=int, + default=DEFAULT_MAX_OPEN_SLIDES, + help=( + "Maximum slides cached per worker before least-recently-used eviction; " + ), + ) + parser.add_argument( + "--parquet-compression", + default="none", + choices=("none", "snappy", "gzip", "brotli", "zstd", "lz4"), + help="Compression codec for Parquet output (default: none).", + ) + parser.add_argument( + "--log-level", + default="INFO", + help="Python logging level (default: INFO).", + ) + return parser.parse_args(argv) + + +def main(argv: Iterable[str] | None = None) -> None: + args = parse_args(argv) + logging.basicConfig( + level=getattr(logging, args.log_level.upper(), logging.INFO), + format="%(asctime)s - %(levelname)s - %(message)s", + ) + ensure_cache_limit(args.max_open_slides) + + if not args.spec_file.exists(): + raise SystemExit(f"Spec file not found: {args.spec_file}") + + specs = parse_specs(args.spec_file) + if not specs: + raise SystemExit("No valid patch specs to process. Aborting.") + + args.output_dir.mkdir(parents=True, exist_ok=True) + + compression = None if args.parquet_compression == "none" else args.parquet_compression + + existing_parquet = [ + path for path in args.output_dir.glob("*.parquet") if path.is_file() + ] + if args.mode == "overwrite" and not args.resume: + for path in existing_parquet: + try: + path.unlink() + except Exception: + logging.exception("Failed to remove %s during overwrite preparation.", path) + raise + + progress_dir = args.output_dir / ".resume" + progress_dir.mkdir(parents=True, exist_ok=True) + if not args.resume: + for marker in progress_dir.iterdir(): + if marker.is_file(): + marker.unlink() + + done_ids = load_completed_task_ids(progress_dir, args.output_dir) + offset_file = progress_dir / "task_offset.txt" + + if args.resume: + if offset_file.exists(): + try: + start_index = int(offset_file.read_text().strip()) + except ValueError: + logging.warning("Ignoring malformed task offset metadata in %s.", offset_file) + start_index = 0 + elif done_ids: + try: + start_index = min(int(task_id) for task_id in done_ids) + except ValueError: + start_index = 0 + elif args.mode == "append": + start_index = find_next_task_index(args.output_dir) + else: + start_index = 0 + else: + start_index = find_next_task_index(args.output_dir) if args.mode == "append" else 0 + + try: + offset_file.write_text(f"{start_index}\n") + except Exception: + logging.exception("Failed to persist task offset metadata to %s.", offset_file) + raise + + grouped = group_by_slide(specs) + tasks = build_tasks( + grouped, + args.task_chunk_size, + start_index=start_index, + ) + + if done_ids: + tasks = [task for task in tasks if task[2] not in done_ids] + + if args.shuffle_tasks and not args.keep_order: + random.shuffle(tasks) + + if not tasks: + logging.info("No tasks remaining after resume check.") + return + + pending_patches = sum(len(task[1]) for task in tasks) + cpu_count = os.cpu_count() or 1 + num_workers = args.num_workers + if num_workers is None: + num_workers = max(1, min(cpu_count, 64)) + + logging.info( + "Building Parquet dataset in %s (num_workers=%d, mode=%s, encoding=%s, compression=%s).", + args.output_dir, + num_workers, + args.mode, + args.encoding, + compression or "none", + ) + logging.info( + "Prepared %d task(s) across %d slide(s) [chunk_size=%d, pending_patches=%d].", + len(tasks), + len(grouped), + args.task_chunk_size, + pending_patches, + ) + if done_ids: + logging.info("Skipping %d previously completed task(s).", len(done_ids)) + + config = TaskConfig( + tile_size=args.tile_size, + encoding=args.encoding, + max_open_slides=args.max_open_slides, + output_dir=str(args.output_dir), + progress_dir=str(progress_dir), + parquet_compression=compression, + ) + + if num_workers <= 1: + for idx, task in enumerate(tasks, start=1): + task_id = process_task_worker(task, config) + logging.info( + "Completed task %s (%d/%d) for slide %s (%d patch(es)).", + task_id, + idx, + len(tasks), + task[0], + len(task[1]), + ) + else: + mp_context = mp.get_context(args.start_method) if args.start_method else None + with ProcessPoolExecutor(max_workers=num_workers, mp_context=mp_context) as executor: + futures = {executor.submit(process_task_worker, task, config): task for task in tasks} + for idx, future in enumerate(as_completed(futures), start=1): + slide_path, specs_for_task, task_id_hint = futures[future] + try: + completed_task_id = future.result() + except Exception: + logging.exception( + "Task %s failed for slide %s (%d patch(es)).", + task_id_hint, + slide_path, + len(specs_for_task), + ) + raise + logging.info( + "Completed task %s (%d/%d) for slide %s (%d patch(es)).", + completed_task_id, + idx, + len(tasks), + slide_path, + len(specs_for_task), + ) + logging.info("Dataset build complete.") + + +if __name__ == "__main__": + main() + +# python3 build_parquet_sample_dataset.py \ +# --spec-file /data/TCGA/sample_dataset_ablation.txt \ +# --output-dir /data/TCGA_ablations_baseline/ \ +# --encoding jpeg \ +# --shuffle-tasks \ +# --num-workers 32 \ +# --max-open-slides 1 \ +# --start-method spawn \ +# --mode append \ +# --resume + + +# PS: Always set max-open-slides to 1 because you'll go out of memory otherwise; diff --git a/OpenMidnight/prepatching_scripts/create_sample_dataset_for_ablations.py b/OpenMidnight/prepatching_scripts/create_sample_dataset_for_ablations.py new file mode 100644 index 0000000000000000000000000000000000000000..af4a1ee963ef1429f17db076ae3f8ed237bdd22f --- /dev/null +++ b/OpenMidnight/prepatching_scripts/create_sample_dataset_for_ablations.py @@ -0,0 +1,124 @@ +import cv2 +import random +from pathlib import Path +from openslide import OpenSlide +import numpy as np +from tqdm import tqdm +from concurrent.futures import ProcessPoolExecutor + +data_root = Path("/data/TCGA") +output_filename = "/data/TCGA/sample_dataset_ablation.txt" +patch_size = 224 +max_tries_per_level = 1000 +max_patches = 500_000 +patches_per_level = 100 +seed = 0 +workers = 10 +MPP_X_KEY = "openslide.mpp-x" +MPP_Y_KEY = "openslide.mpp-y" + +def hsv(tile_rgb): + """ + Checks if a given tile has a high concentration of tissue based on an HSV mask. + """ + tile = np.array(tile_rgb) + # Convert from RGB to HSV color space + tile = cv2.cvtColor(tile, cv2.COLOR_RGB2HSV) + min_ratio = .6 + + # Define the color range for tissue in HSV + lower_bound = np.array([90, 8, 103]) + upper_bound = np.array([180, 255, 255]) + + # Create a mask for the specified color range + mask = cv2.inRange(tile, lower_bound, upper_bound) + + # Calculate the ratio of tissue pixels + ratio = np.count_nonzero(mask) / mask.size + + if ratio > min_ratio: + return tile_rgb + else: + return None + +random.seed(seed) +svs_files = sorted(str(path) for path in data_root.rglob("*.svs")) +random.shuffle(svs_files) +if not svs_files: + raise RuntimeError(f"No SVS files found under {data_root}") + +def sample_slide(args): + path, slide_idx, pass_idx = args + random.seed(seed + pass_idx * 10_000 + slide_idx) + image = OpenSlide(path) + collected_lines = [] + + props = image.properties + if MPP_X_KEY not in props or MPP_Y_KEY not in props: + image.close() + print(f"Skipping slide without MPP metadata: {path}") + return [] + + base_mpp_x = float(props[MPP_X_KEY]) + base_mpp_y = float(props[MPP_Y_KEY]) + + for level in range(0, image.level_count): + height = image.level_dimensions[0][1] + width = image.level_dimensions[0][0] + if width < patch_size or height < patch_size: + continue + + target_for_level = patches_per_level + collected = 0 + tries = 0 + downsample = image.level_downsamples[level] + mpp_x = base_mpp_x * downsample + mpp_y = base_mpp_y * downsample + while collected < target_for_level and tries < max_tries_per_level: + tries += 1 + x = random.randint(0, width - patch_size) + y = random.randint(0, height - patch_size) + patch = image.read_region((x, y), level=level, size=(patch_size, patch_size)) + res = hsv(patch) + if res is not None: + collected_lines.append(f"{path} {x} {y} {level} {mpp_x} {mpp_y}\n") + collected += 1 + image.close() + return collected_lines + +# Open the output file in write mode ('w') +# This will create the file if it doesn't exist or overwrite it if it does. +with open(output_filename, 'w') as f: + print(f"Starting patch sampling (target: {max_patches} patches). Output will be saved to {output_filename}") + + patches_written = 0 + progress = tqdm(total=max_patches, desc="Patches collected") + pass_idx = 0 + while patches_written < max_patches: + patches_before = patches_written + with ProcessPoolExecutor(max_workers=workers) as executor: + tasks = ((path, idx, pass_idx) for idx, path in enumerate(svs_files)) + for lines in executor.map(sample_slide, tasks): + for line in lines: + if patches_written >= max_patches: + break + f.write(line) + patches_written += 1 + progress.update(1) + if patches_written >= max_patches: + break + pass_idx += 1 + if patches_written == patches_before: + break + progress.close() + +# Shuffle the collected entries once generation finishes +with open(output_filename, 'r') as f: + lines = f.readlines() + +random.shuffle(lines) + +with open(output_filename, 'w') as f: + f.writelines(lines) + +print("Done") diff --git a/OpenMidnight/prepatching_scripts/create_sample_dataset_txt.py b/OpenMidnight/prepatching_scripts/create_sample_dataset_txt.py new file mode 100644 index 0000000000000000000000000000000000000000..91bbf2ff9e4f6b5774d26ba7b21059d2e6779c08 --- /dev/null +++ b/OpenMidnight/prepatching_scripts/create_sample_dataset_txt.py @@ -0,0 +1,96 @@ +import cv2 +import random +from pathlib import Path +from openslide import OpenSlide +import numpy as np + +data_root = Path("/data/TCGA") +output_filename = "sample_dataset_30.txt" +patch_size = 224 +max_tries = 1000 + +def hsv(tile_rgb): + """ + Checks if a given tile has a high concentration of tissue based on an HSV mask. + """ + tile = np.array(tile_rgb) + # Convert from RGB to HSV color space + tile = cv2.cvtColor(tile, cv2.COLOR_RGB2HSV) + min_ratio = .6 + + # Define the color range for tissue in HSV + lower_bound = np.array([90, 8, 103]) + upper_bound = np.array([180, 255, 255]) + + # Create a mask for the specified color range + mask = cv2.inRange(tile, lower_bound, upper_bound) + + # Calculate the ratio of tissue pixels + ratio = np.count_nonzero(mask) / mask.size + + if ratio > min_ratio: + return tile_rgb + else: + return None + +finish = 3072 * 1000000 +svs_files = sorted(str(path) for path in data_root.rglob("*.svs")) +if not svs_files: + raise RuntimeError(f"No SVS files found under {data_root}") + +# Open the output file in write mode ('w') +# This will create the file if it doesn't exist or overwrite it if it does. +with open(output_filename, 'w') as f: + print(f"Starting patch sampling. Output will be saved to {output_filename}") + print("\nFor our OpenMidnight checkpoint we ran this script until we reached 29 million patches and then manually force-quit the script. You can adjust the 'finish' variable as needed.") + + for e in range(0, finish): + for path in svs_files: + image = OpenSlide(path) + + # Iterate through each level of the slide + for level in range(0, image.level_count): + + # Get dimensions for the current level being processed + height = image.level_dimensions[0][1] + width = image.level_dimensions[0][0] + + # Ensure dimensions are valid for patch extraction + if width < patch_size or height < patch_size: + continue + + tries = 0 + while True: + tries += 1 + + # Randomly select a top-left coordinate for the patch + x = random.randint(0, width - patch_size) + y = random.randint(0, height - patch_size) + + # Read the region from the slide + patch = image.read_region((x, y), level=level, size=(patch_size, patch_size)) + + # Check if the patch contains enough tissue + res = hsv(patch) + + if res is not None: + # If the patch is valid, write its info to the file + output_line = f"{path} {x} {y} {level}\n" + f.write(output_line) + break # Move to the next level/image + + if tries >= max_tries: + # If 1000 random patches at this level are invalid, move on + break + image.close() + +# Shuffle the collected entries once generation finishes +with open(output_filename, 'r') as f: + lines = f.readlines() + +random.shuffle(lines) + +with open(output_filename, 'w') as f: + f.writelines(lines) + +print("Done") diff --git a/OpenMidnight/prepatching_scripts/sample_dataset_ablation.txt b/OpenMidnight/prepatching_scripts/sample_dataset_ablation.txt new file mode 100644 index 0000000000000000000000000000000000000000..528b8f80494d71abdc03c252235a11b73083b616 --- /dev/null +++ b/OpenMidnight/prepatching_scripts/sample_dataset_ablation.txt @@ -0,0 +1,2778 @@ +/data/TCGA/fd7d9ef2-9e82-4639-ada1-94e7103e7e9c/TCGA-CQ-A4CI-01Z-00-DX1.BDA4315B-03B2-455B-8AE6-9925987AC11F.svs 26595 24757 0 +/data/TCGA/fd7d9ef2-9e82-4639-ada1-94e7103e7e9c/TCGA-CQ-A4CI-01Z-00-DX1.BDA4315B-03B2-455B-8AE6-9925987AC11F.svs 14047 21533 1 +/data/TCGA/fd7d9ef2-9e82-4639-ada1-94e7103e7e9c/TCGA-CQ-A4CI-01Z-00-DX1.BDA4315B-03B2-455B-8AE6-9925987AC11F.svs 8964 18295 2 +/data/TCGA/85f58be7-f8c2-46fd-b23e-6b2d457b5d01/TCGA-A8-A096-01Z-00-DX1.FCECFB0D-4E02-4C69-A0FE-7D6C7F9FEB07.svs 24930 24336 0 +/data/TCGA/85f58be7-f8c2-46fd-b23e-6b2d457b5d01/TCGA-A8-A096-01Z-00-DX1.FCECFB0D-4E02-4C69-A0FE-7D6C7F9FEB07.svs 14434 28947 1 +/data/TCGA/85f58be7-f8c2-46fd-b23e-6b2d457b5d01/TCGA-A8-A096-01Z-00-DX1.FCECFB0D-4E02-4C69-A0FE-7D6C7F9FEB07.svs 12612 13421 2 +/data/TCGA/028fec93-084c-4209-9808-2da6181eae2c/TCGA-ET-A3DW-01Z-00-DX1.02B1407D-BD72-42C1-A8D4-85D7F14CC3F1.svs 65408 24777 0 +/data/TCGA/028fec93-084c-4209-9808-2da6181eae2c/TCGA-ET-A3DW-01Z-00-DX1.02B1407D-BD72-42C1-A8D4-85D7F14CC3F1.svs 81895 26402 1 +/data/TCGA/028fec93-084c-4209-9808-2da6181eae2c/TCGA-ET-A3DW-01Z-00-DX1.02B1407D-BD72-42C1-A8D4-85D7F14CC3F1.svs 25781 35067 2 +/data/TCGA/028fec93-084c-4209-9808-2da6181eae2c/TCGA-ET-A3DW-01Z-00-DX1.02B1407D-BD72-42C1-A8D4-85D7F14CC3F1.svs 56725 33059 3 +/data/TCGA/b4fe39c7-195d-49b1-b82e-a7b9941427dd/TCGA-IB-7889-01Z-00-DX1.6D4EE9ED-5AE0-4AC2-B75C-2B26F562D346.svs 71664 31161 0 +/data/TCGA/b4fe39c7-195d-49b1-b82e-a7b9941427dd/TCGA-IB-7889-01Z-00-DX1.6D4EE9ED-5AE0-4AC2-B75C-2B26F562D346.svs 33474 62723 1 +/data/TCGA/b4fe39c7-195d-49b1-b82e-a7b9941427dd/TCGA-IB-7889-01Z-00-DX1.6D4EE9ED-5AE0-4AC2-B75C-2B26F562D346.svs 81448 18175 2 +/data/TCGA/b4fe39c7-195d-49b1-b82e-a7b9941427dd/TCGA-IB-7889-01Z-00-DX1.6D4EE9ED-5AE0-4AC2-B75C-2B26F562D346.svs 32409 3672 3 +/data/TCGA/0166427c-15c9-4b49-954c-eb3545e5699e/TCGA-BC-A217-01Z-00-DX1.E15D9B32-F809-40D8-846B-2334447B80C0.svs 47995 61430 0 +/data/TCGA/0166427c-15c9-4b49-954c-eb3545e5699e/TCGA-BC-A217-01Z-00-DX1.E15D9B32-F809-40D8-846B-2334447B80C0.svs 115527 29073 1 +/data/TCGA/0166427c-15c9-4b49-954c-eb3545e5699e/TCGA-BC-A217-01Z-00-DX1.E15D9B32-F809-40D8-846B-2334447B80C0.svs 134016 50352 2 +/data/TCGA/0166427c-15c9-4b49-954c-eb3545e5699e/TCGA-BC-A217-01Z-00-DX1.E15D9B32-F809-40D8-846B-2334447B80C0.svs 10567 36818 3 +/data/TCGA/b86fb8e6-fe7d-4a25-a003-29e36a3cca0b/TCGA-CJ-5677-01Z-00-DX1.46FEF9C4-445C-4046-9ACC-54402E3702A9.svs 66904 20485 0 +/data/TCGA/b86fb8e6-fe7d-4a25-a003-29e36a3cca0b/TCGA-CJ-5677-01Z-00-DX1.46FEF9C4-445C-4046-9ACC-54402E3702A9.svs 80325 37929 1 +/data/TCGA/b86fb8e6-fe7d-4a25-a003-29e36a3cca0b/TCGA-CJ-5677-01Z-00-DX1.46FEF9C4-445C-4046-9ACC-54402E3702A9.svs 46936 13983 2 +/data/TCGA/b86fb8e6-fe7d-4a25-a003-29e36a3cca0b/TCGA-CJ-5677-01Z-00-DX1.46FEF9C4-445C-4046-9ACC-54402E3702A9.svs 67151 24789 3 +/data/TCGA/66ed303d-a878-4769-969e-dfd02cf2a027/TCGA-12-0703-01Z-00-DX2.2fb49fe5-2b2b-4dbd-9cf4-76f0d0032d2a.svs 56744 18170 0 +/data/TCGA/66ed303d-a878-4769-969e-dfd02cf2a027/TCGA-12-0703-01Z-00-DX2.2fb49fe5-2b2b-4dbd-9cf4-76f0d0032d2a.svs 33481 6292 1 +/data/TCGA/66ed303d-a878-4769-969e-dfd02cf2a027/TCGA-12-0703-01Z-00-DX2.2fb49fe5-2b2b-4dbd-9cf4-76f0d0032d2a.svs 55926 5622 2 +/data/TCGA/409acc6e-1222-42c2-9697-a26ae5041541/TCGA-BR-8380-01Z-00-DX1.4692f9c9-a7f2-4274-be65-6990f02c1275.svs 10502 25515 0 +/data/TCGA/409acc6e-1222-42c2-9697-a26ae5041541/TCGA-BR-8380-01Z-00-DX1.4692f9c9-a7f2-4274-be65-6990f02c1275.svs 75438 21316 1 +/data/TCGA/409acc6e-1222-42c2-9697-a26ae5041541/TCGA-BR-8380-01Z-00-DX1.4692f9c9-a7f2-4274-be65-6990f02c1275.svs 34038 37708 2 +/data/TCGA/409acc6e-1222-42c2-9697-a26ae5041541/TCGA-BR-8380-01Z-00-DX1.4692f9c9-a7f2-4274-be65-6990f02c1275.svs 12397 2929 3 +/data/TCGA/b5dda425-75cd-4000-a493-7650fe232dba/TCGA-CV-7418-01Z-00-DX1.2E40E4A0-7A9C-4593-987C-CB0849D41AC7.svs 44893 46441 0 +/data/TCGA/b5dda425-75cd-4000-a493-7650fe232dba/TCGA-CV-7418-01Z-00-DX1.2E40E4A0-7A9C-4593-987C-CB0849D41AC7.svs 56961 45224 1 +/data/TCGA/b5dda425-75cd-4000-a493-7650fe232dba/TCGA-CV-7418-01Z-00-DX1.2E40E4A0-7A9C-4593-987C-CB0849D41AC7.svs 42800 30142 2 +/data/TCGA/b5dda425-75cd-4000-a493-7650fe232dba/TCGA-CV-7418-01Z-00-DX1.2E40E4A0-7A9C-4593-987C-CB0849D41AC7.svs 8890 36803 3 +/data/TCGA/f4bac606-8f20-4642-81a2-31f0dbc37866/TCGA-DG-A2KK-01Z-00-DX1.248D92C3-AD5B-4F3C-AE5C-6F8C70C7AE87.svs 10145 24748 0 +/data/TCGA/f4bac606-8f20-4642-81a2-31f0dbc37866/TCGA-DG-A2KK-01Z-00-DX1.248D92C3-AD5B-4F3C-AE5C-6F8C70C7AE87.svs 11142 9323 1 +/data/TCGA/f4bac606-8f20-4642-81a2-31f0dbc37866/TCGA-DG-A2KK-01Z-00-DX1.248D92C3-AD5B-4F3C-AE5C-6F8C70C7AE87.svs 22078 15054 2 +/data/TCGA/07574c8c-a284-4866-b8fc-a1c98c04e8d9/TCGA-VD-A8KH-01Z-00-DX1.E63BFFDC-0572-4DF4-928A-3E84350433E8.svs 8067 33335 0 +/data/TCGA/07574c8c-a284-4866-b8fc-a1c98c04e8d9/TCGA-VD-A8KH-01Z-00-DX1.E63BFFDC-0572-4DF4-928A-3E84350433E8.svs 10107 25264 1 +/data/TCGA/07574c8c-a284-4866-b8fc-a1c98c04e8d9/TCGA-VD-A8KH-01Z-00-DX1.E63BFFDC-0572-4DF4-928A-3E84350433E8.svs 26640 25726 2 +/data/TCGA/63d8a83f-dc75-448f-9b3e-f561befa86ca/TCGA-CV-7425-01Z-00-DX1.D35EB305-DFB5-494D-A350-359A6CDECAC3.svs 86818 39229 0 +/data/TCGA/63d8a83f-dc75-448f-9b3e-f561befa86ca/TCGA-CV-7425-01Z-00-DX1.D35EB305-DFB5-494D-A350-359A6CDECAC3.svs 23313 26707 1 +/data/TCGA/63d8a83f-dc75-448f-9b3e-f561befa86ca/TCGA-CV-7425-01Z-00-DX1.D35EB305-DFB5-494D-A350-359A6CDECAC3.svs 73033 46434 2 +/data/TCGA/63d8a83f-dc75-448f-9b3e-f561befa86ca/TCGA-CV-7425-01Z-00-DX1.D35EB305-DFB5-494D-A350-359A6CDECAC3.svs 52762 16777 3 +/data/TCGA/fda25a62-820e-4e36-8502-ecec3f049cfd/TCGA-WJ-A86L-01Z-00-DX1.2EB59E0F-D5B9-4212-8E31-2CA8529722A1.svs 55026 68627 0 +/data/TCGA/fda25a62-820e-4e36-8502-ecec3f049cfd/TCGA-WJ-A86L-01Z-00-DX1.2EB59E0F-D5B9-4212-8E31-2CA8529722A1.svs 56113 34138 1 +/data/TCGA/fda25a62-820e-4e36-8502-ecec3f049cfd/TCGA-WJ-A86L-01Z-00-DX1.2EB59E0F-D5B9-4212-8E31-2CA8529722A1.svs 44297 74052 2 +/data/TCGA/fda25a62-820e-4e36-8502-ecec3f049cfd/TCGA-WJ-A86L-01Z-00-DX1.2EB59E0F-D5B9-4212-8E31-2CA8529722A1.svs 4545 37636 3 +/data/TCGA/f7ddb88c-d2f1-40a9-a705-660fbb9b79cd/TCGA-W2-A7HA-01Z-00-DX1.EE9C6027-4404-41E9-8157-2709B993C830.svs 77514 59551 0 +/data/TCGA/f7ddb88c-d2f1-40a9-a705-660fbb9b79cd/TCGA-W2-A7HA-01Z-00-DX1.EE9C6027-4404-41E9-8157-2709B993C830.svs 90348 54474 1 +/data/TCGA/f7ddb88c-d2f1-40a9-a705-660fbb9b79cd/TCGA-W2-A7HA-01Z-00-DX1.EE9C6027-4404-41E9-8157-2709B993C830.svs 98237 32227 2 +/data/TCGA/f7ddb88c-d2f1-40a9-a705-660fbb9b79cd/TCGA-W2-A7HA-01Z-00-DX1.EE9C6027-4404-41E9-8157-2709B993C830.svs 98373 52215 3 +/data/TCGA/33ef26ba-d58f-449e-a07e-94cb0f7e0c40/TCGA-DX-A8BU-01Z-00-DX3.E1C699EA-E835-4131-B585-B6DD35F6776D.svs 8454 33860 0 +/data/TCGA/33ef26ba-d58f-449e-a07e-94cb0f7e0c40/TCGA-DX-A8BU-01Z-00-DX3.E1C699EA-E835-4131-B585-B6DD35F6776D.svs 48438 24876 1 +/data/TCGA/33ef26ba-d58f-449e-a07e-94cb0f7e0c40/TCGA-DX-A8BU-01Z-00-DX3.E1C699EA-E835-4131-B585-B6DD35F6776D.svs 17511 40532 2 +/data/TCGA/33ef26ba-d58f-449e-a07e-94cb0f7e0c40/TCGA-DX-A8BU-01Z-00-DX3.E1C699EA-E835-4131-B585-B6DD35F6776D.svs 13643 29670 3 +/data/TCGA/e4eb9ea1-2b0e-4c79-9a45-31db1f50885d/TCGA-WK-A8XY-01Z-00-DX2.F0FC7B27-D321-417D-A66C-61D7A008E416.svs 66029 47450 0 +/data/TCGA/e4eb9ea1-2b0e-4c79-9a45-31db1f50885d/TCGA-WK-A8XY-01Z-00-DX2.F0FC7B27-D321-417D-A66C-61D7A008E416.svs 85168 30840 1 +/data/TCGA/e4eb9ea1-2b0e-4c79-9a45-31db1f50885d/TCGA-WK-A8XY-01Z-00-DX2.F0FC7B27-D321-417D-A66C-61D7A008E416.svs 72121 52032 2 +/data/TCGA/e4eb9ea1-2b0e-4c79-9a45-31db1f50885d/TCGA-WK-A8XY-01Z-00-DX2.F0FC7B27-D321-417D-A66C-61D7A008E416.svs 54858 46534 3 +/data/TCGA/71757896-d679-4b08-b500-0936cbfdc031/TCGA-06-0195-01Z-00-DX3.6a796dec-5f1f-404e-b100-70e7abe3c45a.svs 16204 41 0 +/data/TCGA/71757896-d679-4b08-b500-0936cbfdc031/TCGA-06-0195-01Z-00-DX3.6a796dec-5f1f-404e-b100-70e7abe3c45a.svs 12198 30070 1 +/data/TCGA/71757896-d679-4b08-b500-0936cbfdc031/TCGA-06-0195-01Z-00-DX3.6a796dec-5f1f-404e-b100-70e7abe3c45a.svs 68525 8828 2 +/data/TCGA/6dffd67f-8ea7-4216-8bea-c58885e6f4e6/TCGA-AA-A02O-01Z-00-DX1.CB9BE08B-D78B-46B3-8339-A3DADD24439F.svs 64821 99740 0 +/data/TCGA/6dffd67f-8ea7-4216-8bea-c58885e6f4e6/TCGA-AA-A02O-01Z-00-DX1.CB9BE08B-D78B-46B3-8339-A3DADD24439F.svs 42539 102155 1 +/data/TCGA/6dffd67f-8ea7-4216-8bea-c58885e6f4e6/TCGA-AA-A02O-01Z-00-DX1.CB9BE08B-D78B-46B3-8339-A3DADD24439F.svs 52191 95016 2 +/data/TCGA/6dffd67f-8ea7-4216-8bea-c58885e6f4e6/TCGA-AA-A02O-01Z-00-DX1.CB9BE08B-D78B-46B3-8339-A3DADD24439F.svs 37599 78289 3 +/data/TCGA/f0609b76-0848-429b-bd68-2aab86da193c/TCGA-IG-A51D-01Z-00-DX1.46951C8F-2583-4511-8A6E-E815F5EED0BC.svs 57197 31904 0 +/data/TCGA/f0609b76-0848-429b-bd68-2aab86da193c/TCGA-IG-A51D-01Z-00-DX1.46951C8F-2583-4511-8A6E-E815F5EED0BC.svs 59050 28805 1 +/data/TCGA/f0609b76-0848-429b-bd68-2aab86da193c/TCGA-IG-A51D-01Z-00-DX1.46951C8F-2583-4511-8A6E-E815F5EED0BC.svs 37299 30140 2 +/data/TCGA/f0609b76-0848-429b-bd68-2aab86da193c/TCGA-IG-A51D-01Z-00-DX1.46951C8F-2583-4511-8A6E-E815F5EED0BC.svs 82884 38657 3 +/data/TCGA/6d2f7690-568e-49b5-800a-a2ad39737bfb/TCGA-33-6738-01Z-00-DX1.d688fae9-4daf-4b6e-b907-fb55e3983d62.svs 42583 36160 0 +/data/TCGA/6d2f7690-568e-49b5-800a-a2ad39737bfb/TCGA-33-6738-01Z-00-DX1.d688fae9-4daf-4b6e-b907-fb55e3983d62.svs 33143 11163 1 +/data/TCGA/6d2f7690-568e-49b5-800a-a2ad39737bfb/TCGA-33-6738-01Z-00-DX1.d688fae9-4daf-4b6e-b907-fb55e3983d62.svs 57240 6685 2 +/data/TCGA/6d2f7690-568e-49b5-800a-a2ad39737bfb/TCGA-33-6738-01Z-00-DX1.d688fae9-4daf-4b6e-b907-fb55e3983d62.svs 21843 14967 3 +/data/TCGA/25974f4b-40cc-4cd0-b8f5-40daec7f0a0d/TCGA-12-3653-01Z-00-DX3.7A9DE9AC-76BA-4FDF-90BF-D47B2276E195.svs 32519 31047 0 +/data/TCGA/25974f4b-40cc-4cd0-b8f5-40daec7f0a0d/TCGA-12-3653-01Z-00-DX3.7A9DE9AC-76BA-4FDF-90BF-D47B2276E195.svs 35189 24283 1 +/data/TCGA/25974f4b-40cc-4cd0-b8f5-40daec7f0a0d/TCGA-12-3653-01Z-00-DX3.7A9DE9AC-76BA-4FDF-90BF-D47B2276E195.svs 20930 18189 2 +/data/TCGA/25b8e598-711a-41a2-9f64-a6c132e233f8/TCGA-S7-A7WV-01Z-00-DX1.7EA04D99-5AFB-4079-8400-F9169551934B.svs 80813 43453 0 +/data/TCGA/25b8e598-711a-41a2-9f64-a6c132e233f8/TCGA-S7-A7WV-01Z-00-DX1.7EA04D99-5AFB-4079-8400-F9169551934B.svs 12197 21324 1 +/data/TCGA/25b8e598-711a-41a2-9f64-a6c132e233f8/TCGA-S7-A7WV-01Z-00-DX1.7EA04D99-5AFB-4079-8400-F9169551934B.svs 58084 41301 2 +/data/TCGA/25b8e598-711a-41a2-9f64-a6c132e233f8/TCGA-S7-A7WV-01Z-00-DX1.7EA04D99-5AFB-4079-8400-F9169551934B.svs 57255 59493 3 +/data/TCGA/5adf7dd9-cf70-447f-8a5f-6125aab91f1e/TCGA-E6-A2P8-01Z-00-DX1.D7CDBFDA-7EDA-4769-808C-A30466E74D6A.svs 16487 61864 0 +/data/TCGA/5adf7dd9-cf70-447f-8a5f-6125aab91f1e/TCGA-E6-A2P8-01Z-00-DX1.D7CDBFDA-7EDA-4769-808C-A30466E74D6A.svs 36597 61095 1 +/data/TCGA/5adf7dd9-cf70-447f-8a5f-6125aab91f1e/TCGA-E6-A2P8-01Z-00-DX1.D7CDBFDA-7EDA-4769-808C-A30466E74D6A.svs 43010 66229 2 +/data/TCGA/5adf7dd9-cf70-447f-8a5f-6125aab91f1e/TCGA-E6-A2P8-01Z-00-DX1.D7CDBFDA-7EDA-4769-808C-A30466E74D6A.svs 54466 5406 3 +/data/TCGA/74b8a067-e473-4c4a-8a87-f4905649dfea/TCGA-AC-A8OS-01Z-00-DX1.3FD44846-8BD2-4A7A-9A87-8D3D29C25F60.svs 17992 37174 0 +/data/TCGA/74b8a067-e473-4c4a-8a87-f4905649dfea/TCGA-AC-A8OS-01Z-00-DX1.3FD44846-8BD2-4A7A-9A87-8D3D29C25F60.svs 9399 18805 1 +/data/TCGA/74b8a067-e473-4c4a-8a87-f4905649dfea/TCGA-AC-A8OS-01Z-00-DX1.3FD44846-8BD2-4A7A-9A87-8D3D29C25F60.svs 29390 28879 2 +/data/TCGA/5b0d1cfd-7b35-48a9-9e00-eb590e2b884e/TCGA-BQ-7048-01Z-00-DX1.656594d9-dfe1-416a-81bb-12e5cf46d0e5.svs 17288 11352 0 +/data/TCGA/5b0d1cfd-7b35-48a9-9e00-eb590e2b884e/TCGA-BQ-7048-01Z-00-DX1.656594d9-dfe1-416a-81bb-12e5cf46d0e5.svs 32599 26916 1 +/data/TCGA/5b0d1cfd-7b35-48a9-9e00-eb590e2b884e/TCGA-BQ-7048-01Z-00-DX1.656594d9-dfe1-416a-81bb-12e5cf46d0e5.svs 4982 12942 2 +/data/TCGA/5b0d1cfd-7b35-48a9-9e00-eb590e2b884e/TCGA-BQ-7048-01Z-00-DX1.656594d9-dfe1-416a-81bb-12e5cf46d0e5.svs 25665 5051 3 +/data/TCGA/bca43d2b-4809-488c-af55-5c734939601c/TCGA-E8-A242-01Z-00-DX1.9DDBB5BB-696E-4C61-BF4A-464062403F04.svs 37778 35017 0 +/data/TCGA/bca43d2b-4809-488c-af55-5c734939601c/TCGA-E8-A242-01Z-00-DX1.9DDBB5BB-696E-4C61-BF4A-464062403F04.svs 27223 40353 1 +/data/TCGA/bca43d2b-4809-488c-af55-5c734939601c/TCGA-E8-A242-01Z-00-DX1.9DDBB5BB-696E-4C61-BF4A-464062403F04.svs 56582 38126 2 +/data/TCGA/bca43d2b-4809-488c-af55-5c734939601c/TCGA-E8-A242-01Z-00-DX1.9DDBB5BB-696E-4C61-BF4A-464062403F04.svs 40900 37072 3 +/data/TCGA/62b74f9d-9679-48bb-83be-2244db5c53f2/TCGA-D8-A27N-01Z-00-DX1.85613A4F-1FFB-4091-B925-8E8A7C7A6D95.svs 151588 32426 0 +/data/TCGA/62b74f9d-9679-48bb-83be-2244db5c53f2/TCGA-D8-A27N-01Z-00-DX1.85613A4F-1FFB-4091-B925-8E8A7C7A6D95.svs 39164 23613 1 +/data/TCGA/62b74f9d-9679-48bb-83be-2244db5c53f2/TCGA-D8-A27N-01Z-00-DX1.85613A4F-1FFB-4091-B925-8E8A7C7A6D95.svs 55210 17745 2 +/data/TCGA/62b74f9d-9679-48bb-83be-2244db5c53f2/TCGA-D8-A27N-01Z-00-DX1.85613A4F-1FFB-4091-B925-8E8A7C7A6D95.svs 125242 20566 3 +/data/TCGA/b6c0ea5f-32d3-4210-b85b-9cb435e8167e/TCGA-AA-3494-01Z-00-DX1.E275AF20-3AA7-4191-BD1F-FFE744CA6A2F.svs 5544 4796 0 +/data/TCGA/b6c0ea5f-32d3-4210-b85b-9cb435e8167e/TCGA-AA-3494-01Z-00-DX1.E275AF20-3AA7-4191-BD1F-FFE744CA6A2F.svs 2361 974 1 +/data/TCGA/c83b9d30-aeae-4398-839d-5c2326b67ebf/TCGA-S9-A6TS-01Z-00-DX1.A10361F8-6208-44EE-9B2E-8513EBA31ED3.svs 22730 50018 0 +/data/TCGA/c83b9d30-aeae-4398-839d-5c2326b67ebf/TCGA-S9-A6TS-01Z-00-DX1.A10361F8-6208-44EE-9B2E-8513EBA31ED3.svs 38959 72960 1 +/data/TCGA/c83b9d30-aeae-4398-839d-5c2326b67ebf/TCGA-S9-A6TS-01Z-00-DX1.A10361F8-6208-44EE-9B2E-8513EBA31ED3.svs 25879 49526 2 +/data/TCGA/c83b9d30-aeae-4398-839d-5c2326b67ebf/TCGA-S9-A6TS-01Z-00-DX1.A10361F8-6208-44EE-9B2E-8513EBA31ED3.svs 62017 27342 3 +/data/TCGA/b699cba2-1064-4f4b-b5db-d0fb2f14f32e/TCGA-4V-A9QN-01Z-00-DX1.9FAB3E85-65FF-4987-8D8C-BC80766A3885.svs 59793 48333 0 +/data/TCGA/b699cba2-1064-4f4b-b5db-d0fb2f14f32e/TCGA-4V-A9QN-01Z-00-DX1.9FAB3E85-65FF-4987-8D8C-BC80766A3885.svs 78669 52381 1 +/data/TCGA/b699cba2-1064-4f4b-b5db-d0fb2f14f32e/TCGA-4V-A9QN-01Z-00-DX1.9FAB3E85-65FF-4987-8D8C-BC80766A3885.svs 52003 24818 2 +/data/TCGA/b699cba2-1064-4f4b-b5db-d0fb2f14f32e/TCGA-4V-A9QN-01Z-00-DX1.9FAB3E85-65FF-4987-8D8C-BC80766A3885.svs 19118 51925 3 +/data/TCGA/c4113122-d2ff-48ba-9765-f91f864d4c93/TCGA-56-5897-01Z-00-DX1.776271b1-77a9-4653-8ed3-13294c9fc056.svs 12848 10105 0 +/data/TCGA/c4113122-d2ff-48ba-9765-f91f864d4c93/TCGA-56-5897-01Z-00-DX1.776271b1-77a9-4653-8ed3-13294c9fc056.svs 28130 25898 1 +/data/TCGA/c4113122-d2ff-48ba-9765-f91f864d4c93/TCGA-56-5897-01Z-00-DX1.776271b1-77a9-4653-8ed3-13294c9fc056.svs 36159 15297 2 +/data/TCGA/def6231c-c8cd-4807-9a6f-935b265bee74/TCGA-KV-A6GE-01Z-00-DX8.1FD4BD73-5A15-4712-B5F4-3529BD01044F.svs 13502 44848 0 +/data/TCGA/def6231c-c8cd-4807-9a6f-935b265bee74/TCGA-KV-A6GE-01Z-00-DX8.1FD4BD73-5A15-4712-B5F4-3529BD01044F.svs 83707 37862 1 +/data/TCGA/def6231c-c8cd-4807-9a6f-935b265bee74/TCGA-KV-A6GE-01Z-00-DX8.1FD4BD73-5A15-4712-B5F4-3529BD01044F.svs 24733 29455 2 +/data/TCGA/def6231c-c8cd-4807-9a6f-935b265bee74/TCGA-KV-A6GE-01Z-00-DX8.1FD4BD73-5A15-4712-B5F4-3529BD01044F.svs 11733 35923 3 +/data/TCGA/9efc6d5d-499d-4c34-973a-50b95c959882/TCGA-D1-A0ZS-01Z-00-DX1.8021A060-3CA2-418E-AE16-C48E911F5C25.svs 83286 70315 0 +/data/TCGA/9efc6d5d-499d-4c34-973a-50b95c959882/TCGA-D1-A0ZS-01Z-00-DX1.8021A060-3CA2-418E-AE16-C48E911F5C25.svs 18140 40757 1 +/data/TCGA/9efc6d5d-499d-4c34-973a-50b95c959882/TCGA-D1-A0ZS-01Z-00-DX1.8021A060-3CA2-418E-AE16-C48E911F5C25.svs 52141 13175 2 +/data/TCGA/9efc6d5d-499d-4c34-973a-50b95c959882/TCGA-D1-A0ZS-01Z-00-DX1.8021A060-3CA2-418E-AE16-C48E911F5C25.svs 104216 22648 3 +/data/TCGA/880ae8ec-b8e8-4d9f-b0f1-2457a8a69cc5/TCGA-ET-A3DQ-01Z-00-DX1.A9648057-5AC1-4A77-9A82-846BF4D5804E.svs 68171 39610 0 +/data/TCGA/880ae8ec-b8e8-4d9f-b0f1-2457a8a69cc5/TCGA-ET-A3DQ-01Z-00-DX1.A9648057-5AC1-4A77-9A82-846BF4D5804E.svs 81103 24469 1 +/data/TCGA/880ae8ec-b8e8-4d9f-b0f1-2457a8a69cc5/TCGA-ET-A3DQ-01Z-00-DX1.A9648057-5AC1-4A77-9A82-846BF4D5804E.svs 33502 30756 2 +/data/TCGA/880ae8ec-b8e8-4d9f-b0f1-2457a8a69cc5/TCGA-ET-A3DQ-01Z-00-DX1.A9648057-5AC1-4A77-9A82-846BF4D5804E.svs 59381 4080 3 +/data/TCGA/7d6ca479-3e7c-424d-af7c-9b2daecece68/TCGA-DJ-A2QB-01Z-00-DX1.3C514B32-31C5-4BFF-8DDD-9BA583B33E19.svs 49116 65530 0 +/data/TCGA/7d6ca479-3e7c-424d-af7c-9b2daecece68/TCGA-DJ-A2QB-01Z-00-DX1.3C514B32-31C5-4BFF-8DDD-9BA583B33E19.svs 51183 51052 1 +/data/TCGA/7d6ca479-3e7c-424d-af7c-9b2daecece68/TCGA-DJ-A2QB-01Z-00-DX1.3C514B32-31C5-4BFF-8DDD-9BA583B33E19.svs 33405 35675 2 +/data/TCGA/7d6ca479-3e7c-424d-af7c-9b2daecece68/TCGA-DJ-A2QB-01Z-00-DX1.3C514B32-31C5-4BFF-8DDD-9BA583B33E19.svs 35021 39257 3 +/data/TCGA/f877e4f3-a467-4cb8-af27-d91f9565447a/TCGA-HQ-A2OE-01Z-00-DX1.6F764592-DFDC-4636-BE91-3F1F92EE5A65.svs 46596 19989 0 +/data/TCGA/f877e4f3-a467-4cb8-af27-d91f9565447a/TCGA-HQ-A2OE-01Z-00-DX1.6F764592-DFDC-4636-BE91-3F1F92EE5A65.svs 8798 12626 1 +/data/TCGA/f877e4f3-a467-4cb8-af27-d91f9565447a/TCGA-HQ-A2OE-01Z-00-DX1.6F764592-DFDC-4636-BE91-3F1F92EE5A65.svs 6883 14753 2 +/data/TCGA/b5506234-c969-4b27-89f5-5dffead8683a/TCGA-95-7043-01Z-00-DX1.AE0FD8AA-9B88-45FE-B247-402BED1285EF.svs 71520 11051 0 +/data/TCGA/b5506234-c969-4b27-89f5-5dffead8683a/TCGA-95-7043-01Z-00-DX1.AE0FD8AA-9B88-45FE-B247-402BED1285EF.svs 90088 39428 1 +/data/TCGA/b5506234-c969-4b27-89f5-5dffead8683a/TCGA-95-7043-01Z-00-DX1.AE0FD8AA-9B88-45FE-B247-402BED1285EF.svs 69654 9490 2 +/data/TCGA/b5506234-c969-4b27-89f5-5dffead8683a/TCGA-95-7043-01Z-00-DX1.AE0FD8AA-9B88-45FE-B247-402BED1285EF.svs 83331 11684 3 +/data/TCGA/483691a5-23b1-4788-90c5-1c136e4c09fa/TCGA-WE-AA9Y-06Z-00-DX1.83813BA4-04FA-4AEA-A50D-B962A753A59E.svs 84988 19571 0 +/data/TCGA/483691a5-23b1-4788-90c5-1c136e4c09fa/TCGA-WE-AA9Y-06Z-00-DX1.83813BA4-04FA-4AEA-A50D-B962A753A59E.svs 22213 66565 1 +/data/TCGA/483691a5-23b1-4788-90c5-1c136e4c09fa/TCGA-WE-AA9Y-06Z-00-DX1.83813BA4-04FA-4AEA-A50D-B962A753A59E.svs 63363 40004 2 +/data/TCGA/483691a5-23b1-4788-90c5-1c136e4c09fa/TCGA-WE-AA9Y-06Z-00-DX1.83813BA4-04FA-4AEA-A50D-B962A753A59E.svs 23567 68748 3 +/data/TCGA/6e139280-8e82-4506-bc4c-4e8958813497/TCGA-BP-4174-01Z-00-DX1.be4a0246-98f6-44c3-a00f-dfb7d076e9db.svs 74983 43826 0 +/data/TCGA/6e139280-8e82-4506-bc4c-4e8958813497/TCGA-BP-4174-01Z-00-DX1.be4a0246-98f6-44c3-a00f-dfb7d076e9db.svs 58931 39128 1 +/data/TCGA/6e139280-8e82-4506-bc4c-4e8958813497/TCGA-BP-4174-01Z-00-DX1.be4a0246-98f6-44c3-a00f-dfb7d076e9db.svs 68234 21005 2 +/data/TCGA/6e139280-8e82-4506-bc4c-4e8958813497/TCGA-BP-4174-01Z-00-DX1.be4a0246-98f6-44c3-a00f-dfb7d076e9db.svs 65656 46673 3 +/data/TCGA/a51a959b-d70b-4f51-a360-99f7ca48efaa/TCGA-AR-A2LN-01Z-00-DX1.3EF43524-28B8-4326-9356-6BCBC63A1DA8.svs 45806 4796 0 +/data/TCGA/a51a959b-d70b-4f51-a360-99f7ca48efaa/TCGA-AR-A2LN-01Z-00-DX1.3EF43524-28B8-4326-9356-6BCBC63A1DA8.svs 23650 25246 1 +/data/TCGA/a51a959b-d70b-4f51-a360-99f7ca48efaa/TCGA-AR-A2LN-01Z-00-DX1.3EF43524-28B8-4326-9356-6BCBC63A1DA8.svs 17797 67074 2 +/data/TCGA/a51a959b-d70b-4f51-a360-99f7ca48efaa/TCGA-AR-A2LN-01Z-00-DX1.3EF43524-28B8-4326-9356-6BCBC63A1DA8.svs 21705 42875 3 +/data/TCGA/bf98b535-2c98-49e2-b40b-55751190d296/TCGA-DB-5275-01Z-00-DX2.30F63FE2-C9CC-4BBA-B2AB-9D857898397E.svs 21476 10084 0 +/data/TCGA/bf98b535-2c98-49e2-b40b-55751190d296/TCGA-DB-5275-01Z-00-DX2.30F63FE2-C9CC-4BBA-B2AB-9D857898397E.svs 24414 19160 1 +/data/TCGA/bf98b535-2c98-49e2-b40b-55751190d296/TCGA-DB-5275-01Z-00-DX2.30F63FE2-C9CC-4BBA-B2AB-9D857898397E.svs 24523 14197 2 +/data/TCGA/bf98b535-2c98-49e2-b40b-55751190d296/TCGA-DB-5275-01Z-00-DX2.30F63FE2-C9CC-4BBA-B2AB-9D857898397E.svs 5333 39157 3 +/data/TCGA/dd8bcaa6-ddf5-425f-bf20-fdc50747f50f/TCGA-W2-A7HE-01Z-00-DX1.3DCBF9B9-5C37-4EDF-8FA0-13124BF65EF9.svs 23522 42776 0 +/data/TCGA/dd8bcaa6-ddf5-425f-bf20-fdc50747f50f/TCGA-W2-A7HE-01Z-00-DX1.3DCBF9B9-5C37-4EDF-8FA0-13124BF65EF9.svs 42804 54052 1 +/data/TCGA/dd8bcaa6-ddf5-425f-bf20-fdc50747f50f/TCGA-W2-A7HE-01Z-00-DX1.3DCBF9B9-5C37-4EDF-8FA0-13124BF65EF9.svs 38358 18978 2 +/data/TCGA/dd8bcaa6-ddf5-425f-bf20-fdc50747f50f/TCGA-W2-A7HE-01Z-00-DX1.3DCBF9B9-5C37-4EDF-8FA0-13124BF65EF9.svs 51242 59858 3 +/data/TCGA/26322daa-5925-454d-847e-4228ccec5d80/TCGA-N5-A4RO-01Z-00-DX2.C833DA0E-2C7C-438C-8878-2C5656E50228.svs 15386 23177 0 +/data/TCGA/26322daa-5925-454d-847e-4228ccec5d80/TCGA-N5-A4RO-01Z-00-DX2.C833DA0E-2C7C-438C-8878-2C5656E50228.svs 33825 20617 1 +/data/TCGA/26322daa-5925-454d-847e-4228ccec5d80/TCGA-N5-A4RO-01Z-00-DX2.C833DA0E-2C7C-438C-8878-2C5656E50228.svs 57620 40117 2 +/data/TCGA/26322daa-5925-454d-847e-4228ccec5d80/TCGA-N5-A4RO-01Z-00-DX2.C833DA0E-2C7C-438C-8878-2C5656E50228.svs 58868 51121 3 +/data/TCGA/57af0f44-2c46-4c3f-9357-a7e8fbbee85c/TCGA-EL-A3CP-01Z-00-DX1.D0F4C535-AF19-4F30-9440-5B6656B0C3F0.svs 40325 12346 0 +/data/TCGA/57af0f44-2c46-4c3f-9357-a7e8fbbee85c/TCGA-EL-A3CP-01Z-00-DX1.D0F4C535-AF19-4F30-9440-5B6656B0C3F0.svs 32042 23019 1 +/data/TCGA/57af0f44-2c46-4c3f-9357-a7e8fbbee85c/TCGA-EL-A3CP-01Z-00-DX1.D0F4C535-AF19-4F30-9440-5B6656B0C3F0.svs 30633 11951 2 +/data/TCGA/57af0f44-2c46-4c3f-9357-a7e8fbbee85c/TCGA-EL-A3CP-01Z-00-DX1.D0F4C535-AF19-4F30-9440-5B6656B0C3F0.svs 34477 5909 3 +/data/TCGA/600defe9-cd83-4df7-9cc2-1050e2297feb/TCGA-73-4659-01Z-00-DX1.578400cd-d284-451b-8fdf-9f82c1458276.svs 18356 37632 0 +/data/TCGA/600defe9-cd83-4df7-9cc2-1050e2297feb/TCGA-73-4659-01Z-00-DX1.578400cd-d284-451b-8fdf-9f82c1458276.svs 94539 43761 1 +/data/TCGA/600defe9-cd83-4df7-9cc2-1050e2297feb/TCGA-73-4659-01Z-00-DX1.578400cd-d284-451b-8fdf-9f82c1458276.svs 27698 5361 2 +/data/TCGA/600defe9-cd83-4df7-9cc2-1050e2297feb/TCGA-73-4659-01Z-00-DX1.578400cd-d284-451b-8fdf-9f82c1458276.svs 86935 35509 3 +/data/TCGA/7e2224db-3f9c-48a2-a97d-e14e44f63c36/TCGA-CQ-5332-01Z-00-DX1.93c007e9-00e2-457a-8bd1-a1cea4903b65.svs 21517 27831 0 +/data/TCGA/7e2224db-3f9c-48a2-a97d-e14e44f63c36/TCGA-CQ-5332-01Z-00-DX1.93c007e9-00e2-457a-8bd1-a1cea4903b65.svs 38903 25413 1 +/data/TCGA/7e2224db-3f9c-48a2-a97d-e14e44f63c36/TCGA-CQ-5332-01Z-00-DX1.93c007e9-00e2-457a-8bd1-a1cea4903b65.svs 15030 30585 2 +/data/TCGA/5ba7738a-dd63-4c39-b48d-7b9c28be1d7d/TCGA-AD-6888-01Z-00-DX1.47AE342C-4577-4D8B-9048-0B106C5960E7.svs 28815 22604 0 +/data/TCGA/5ba7738a-dd63-4c39-b48d-7b9c28be1d7d/TCGA-AD-6888-01Z-00-DX1.47AE342C-4577-4D8B-9048-0B106C5960E7.svs 7905 18635 1 +/data/TCGA/5ba7738a-dd63-4c39-b48d-7b9c28be1d7d/TCGA-AD-6888-01Z-00-DX1.47AE342C-4577-4D8B-9048-0B106C5960E7.svs 9483 12397 2 +/data/TCGA/78479de9-a0b9-448d-b277-b5315fc72b8c/TCGA-AC-A6NO-01Z-00-DX1.61B7F48C-6D6E-4C1B-B236-DD130ECBDA9D.svs 53079 13122 0 +/data/TCGA/78479de9-a0b9-448d-b277-b5315fc72b8c/TCGA-AC-A6NO-01Z-00-DX1.61B7F48C-6D6E-4C1B-B236-DD130ECBDA9D.svs 13075 29756 1 +/data/TCGA/78479de9-a0b9-448d-b277-b5315fc72b8c/TCGA-AC-A6NO-01Z-00-DX1.61B7F48C-6D6E-4C1B-B236-DD130ECBDA9D.svs 51909 11942 2 +/data/TCGA/0662c036-7645-4c1d-862b-2fcf6c49c64c/TCGA-HT-7611-01Z-00-DX1.AE487FF3-EF5A-4CE5-8618-20F234A59F1E.svs 43922 32848 0 +/data/TCGA/0662c036-7645-4c1d-862b-2fcf6c49c64c/TCGA-HT-7611-01Z-00-DX1.AE487FF3-EF5A-4CE5-8618-20F234A59F1E.svs 38729 23568 1 +/data/TCGA/0662c036-7645-4c1d-862b-2fcf6c49c64c/TCGA-HT-7611-01Z-00-DX1.AE487FF3-EF5A-4CE5-8618-20F234A59F1E.svs 118481 22423 2 +/data/TCGA/0662c036-7645-4c1d-862b-2fcf6c49c64c/TCGA-HT-7611-01Z-00-DX1.AE487FF3-EF5A-4CE5-8618-20F234A59F1E.svs 32472 43381 3 +/data/TCGA/6d774ca0-2407-4f15-96d9-c365a2aa8ec7/TCGA-MP-A4TI-01Z-00-DX1.08AB4C0B-F953-41B5-A9BB-7452A8E34A54.svs 48584 28637 0 +/data/TCGA/6d774ca0-2407-4f15-96d9-c365a2aa8ec7/TCGA-MP-A4TI-01Z-00-DX1.08AB4C0B-F953-41B5-A9BB-7452A8E34A54.svs 20737 36289 1 +/data/TCGA/6d774ca0-2407-4f15-96d9-c365a2aa8ec7/TCGA-MP-A4TI-01Z-00-DX1.08AB4C0B-F953-41B5-A9BB-7452A8E34A54.svs 64590 4698 2 +/data/TCGA/6d774ca0-2407-4f15-96d9-c365a2aa8ec7/TCGA-MP-A4TI-01Z-00-DX1.08AB4C0B-F953-41B5-A9BB-7452A8E34A54.svs 61001 37562 3 +/data/TCGA/409cd9ce-682f-4196-a224-e8e15c33e28e/TCGA-B0-4852-01Z-00-DX1.b3511f16-8d4e-4fa4-9f67-8309f277f167.svs 61112 44561 0 +/data/TCGA/409cd9ce-682f-4196-a224-e8e15c33e28e/TCGA-B0-4852-01Z-00-DX1.b3511f16-8d4e-4fa4-9f67-8309f277f167.svs 51783 23375 1 +/data/TCGA/409cd9ce-682f-4196-a224-e8e15c33e28e/TCGA-B0-4852-01Z-00-DX1.b3511f16-8d4e-4fa4-9f67-8309f277f167.svs 3591 18259 2 +/data/TCGA/409cd9ce-682f-4196-a224-e8e15c33e28e/TCGA-B0-4852-01Z-00-DX1.b3511f16-8d4e-4fa4-9f67-8309f277f167.svs 29136 13190 3 +/data/TCGA/bb7d6bc1-4d6a-4ecc-a8ad-ecc31ff4f471/TCGA-C8-A1HO-01Z-00-DX1.0C702CEE-C373-4D00-A706-32206D41AC17.svs 10139 50416 0 +/data/TCGA/bb7d6bc1-4d6a-4ecc-a8ad-ecc31ff4f471/TCGA-C8-A1HO-01Z-00-DX1.0C702CEE-C373-4D00-A706-32206D41AC17.svs 39163 49845 1 +/data/TCGA/bb7d6bc1-4d6a-4ecc-a8ad-ecc31ff4f471/TCGA-C8-A1HO-01Z-00-DX1.0C702CEE-C373-4D00-A706-32206D41AC17.svs 19941 34271 2 +/data/TCGA/bb7d6bc1-4d6a-4ecc-a8ad-ecc31ff4f471/TCGA-C8-A1HO-01Z-00-DX1.0C702CEE-C373-4D00-A706-32206D41AC17.svs 48083 22729 3 +/data/TCGA/3b57f43a-44ec-4632-b673-e5104f2ddea1/TCGA-VP-A879-01Z-00-DX1.FC957319-7D9E-4480-B279-D42D5FFD2A4B.svs 62317 7306 0 +/data/TCGA/3b57f43a-44ec-4632-b673-e5104f2ddea1/TCGA-VP-A879-01Z-00-DX1.FC957319-7D9E-4480-B279-D42D5FFD2A4B.svs 56457 9298 1 +/data/TCGA/3b57f43a-44ec-4632-b673-e5104f2ddea1/TCGA-VP-A879-01Z-00-DX1.FC957319-7D9E-4480-B279-D42D5FFD2A4B.svs 62656 20341 2 +/data/TCGA/3b57f43a-44ec-4632-b673-e5104f2ddea1/TCGA-VP-A879-01Z-00-DX1.FC957319-7D9E-4480-B279-D42D5FFD2A4B.svs 52084 23187 3 +/data/TCGA/0dd2b471-dde2-4847-892e-4a42f417544f/TCGA-55-A493-01Z-00-DX1.1CF94B85-7A64-4213-9B04-16504512DE2E.svs 7633 32831 0 +/data/TCGA/0dd2b471-dde2-4847-892e-4a42f417544f/TCGA-55-A493-01Z-00-DX1.1CF94B85-7A64-4213-9B04-16504512DE2E.svs 20381 26853 1 +/data/TCGA/0dd2b471-dde2-4847-892e-4a42f417544f/TCGA-55-A493-01Z-00-DX1.1CF94B85-7A64-4213-9B04-16504512DE2E.svs 5490 21663 2 +/data/TCGA/ded5fe47-8c93-4824-9add-3a404c86b36d/TCGA-HT-A61C-01Z-00-DX1.034BF077-8710-4F6A-B346-67740B77A277.svs 56717 30680 0 +/data/TCGA/ded5fe47-8c93-4824-9add-3a404c86b36d/TCGA-HT-A61C-01Z-00-DX1.034BF077-8710-4F6A-B346-67740B77A277.svs 53994 27326 1 +/data/TCGA/ded5fe47-8c93-4824-9add-3a404c86b36d/TCGA-HT-A61C-01Z-00-DX1.034BF077-8710-4F6A-B346-67740B77A277.svs 48637 18646 2 +/data/TCGA/ded5fe47-8c93-4824-9add-3a404c86b36d/TCGA-HT-A61C-01Z-00-DX1.034BF077-8710-4F6A-B346-67740B77A277.svs 54499 39617 3 +/data/TCGA/48b9e16a-431b-4985-a943-6747b340ec56/TCGA-HT-7609-01Z-00-DX5.E03C11A8-957A-4B22-8699-5D6C6511A1D6.svs 48082 47993 0 +/data/TCGA/48b9e16a-431b-4985-a943-6747b340ec56/TCGA-HT-7609-01Z-00-DX5.E03C11A8-957A-4B22-8699-5D6C6511A1D6.svs 30160 49683 1 +/data/TCGA/48b9e16a-431b-4985-a943-6747b340ec56/TCGA-HT-7609-01Z-00-DX5.E03C11A8-957A-4B22-8699-5D6C6511A1D6.svs 18981 49283 2 +/data/TCGA/48b9e16a-431b-4985-a943-6747b340ec56/TCGA-HT-7609-01Z-00-DX5.E03C11A8-957A-4B22-8699-5D6C6511A1D6.svs 21502 27997 3 +/data/TCGA/5c1216f3-19ec-4d3c-9bb0-9bd740b79f62/TCGA-AR-A1AW-01Z-00-DX1.E527CA46-D83F-4055-8C7E-AEFEF13C1E29.svs 24638 25601 0 +/data/TCGA/5c1216f3-19ec-4d3c-9bb0-9bd740b79f62/TCGA-AR-A1AW-01Z-00-DX1.E527CA46-D83F-4055-8C7E-AEFEF13C1E29.svs 7225 39851 1 +/data/TCGA/5c1216f3-19ec-4d3c-9bb0-9bd740b79f62/TCGA-AR-A1AW-01Z-00-DX1.E527CA46-D83F-4055-8C7E-AEFEF13C1E29.svs 24323 16912 2 +/data/TCGA/5c1216f3-19ec-4d3c-9bb0-9bd740b79f62/TCGA-AR-A1AW-01Z-00-DX1.E527CA46-D83F-4055-8C7E-AEFEF13C1E29.svs 27684 23074 3 +/data/TCGA/e61e6244-5a12-4640-996f-57597d0c452a/TCGA-GM-A2DD-01Z-00-DX1.01332FF3-7488-41B7-A515-7841715DE92B.svs 67173 9397 0 +/data/TCGA/e61e6244-5a12-4640-996f-57597d0c452a/TCGA-GM-A2DD-01Z-00-DX1.01332FF3-7488-41B7-A515-7841715DE92B.svs 83913 48653 1 +/data/TCGA/e61e6244-5a12-4640-996f-57597d0c452a/TCGA-GM-A2DD-01Z-00-DX1.01332FF3-7488-41B7-A515-7841715DE92B.svs 108999 39871 2 +/data/TCGA/e61e6244-5a12-4640-996f-57597d0c452a/TCGA-GM-A2DD-01Z-00-DX1.01332FF3-7488-41B7-A515-7841715DE92B.svs 80188 39048 3 +/data/TCGA/3ef706c3-31b6-4936-b732-eddd302e5754/TCGA-E7-A4XJ-01Z-00-DX1.70DA8872-34A6-41B7-8D17-2B15C80EF5CF.svs 20938 38826 0 +/data/TCGA/3ef706c3-31b6-4936-b732-eddd302e5754/TCGA-E7-A4XJ-01Z-00-DX1.70DA8872-34A6-41B7-8D17-2B15C80EF5CF.svs 5694 42804 1 +/data/TCGA/3ef706c3-31b6-4936-b732-eddd302e5754/TCGA-E7-A4XJ-01Z-00-DX1.70DA8872-34A6-41B7-8D17-2B15C80EF5CF.svs 55431 21275 2 +/data/TCGA/3ef706c3-31b6-4936-b732-eddd302e5754/TCGA-E7-A4XJ-01Z-00-DX1.70DA8872-34A6-41B7-8D17-2B15C80EF5CF.svs 21198 18745 3 +/data/TCGA/0a6ef6d7-4e0b-4b23-90a7-da39e0eaf5af/TCGA-D3-A2JL-06Z-00-DX1.3258F79C-866E-4AC5-BB16-F4DF65E9DFC2.svs 31875 5924 0 +/data/TCGA/0a6ef6d7-4e0b-4b23-90a7-da39e0eaf5af/TCGA-D3-A2JL-06Z-00-DX1.3258F79C-866E-4AC5-BB16-F4DF65E9DFC2.svs 20758 6460 1 +/data/TCGA/0a6ef6d7-4e0b-4b23-90a7-da39e0eaf5af/TCGA-D3-A2JL-06Z-00-DX1.3258F79C-866E-4AC5-BB16-F4DF65E9DFC2.svs 32855 9294 2 +/data/TCGA/940ede98-79e7-4135-ab54-4f3e653a70d6/TCGA-DJ-A3UY-01Z-00-DX1.18014546-386C-4EBE-95FA-590B1BA9AA50.svs 27350 16626 0 +/data/TCGA/940ede98-79e7-4135-ab54-4f3e653a70d6/TCGA-DJ-A3UY-01Z-00-DX1.18014546-386C-4EBE-95FA-590B1BA9AA50.svs 12376 62933 1 +/data/TCGA/940ede98-79e7-4135-ab54-4f3e653a70d6/TCGA-DJ-A3UY-01Z-00-DX1.18014546-386C-4EBE-95FA-590B1BA9AA50.svs 76809 42975 2 +/data/TCGA/940ede98-79e7-4135-ab54-4f3e653a70d6/TCGA-DJ-A3UY-01Z-00-DX1.18014546-386C-4EBE-95FA-590B1BA9AA50.svs 89784 25837 3 +/data/TCGA/7a459e54-3a75-4000-ac21-3ff41d029a8f/TCGA-OR-A5JK-01Z-00-DX1.175C14F3-8CB4-40A0-8E61-A1E77F4CA538.svs 136631 51223 0 +/data/TCGA/7a459e54-3a75-4000-ac21-3ff41d029a8f/TCGA-OR-A5JK-01Z-00-DX1.175C14F3-8CB4-40A0-8E61-A1E77F4CA538.svs 21071 22247 1 +/data/TCGA/7a459e54-3a75-4000-ac21-3ff41d029a8f/TCGA-OR-A5JK-01Z-00-DX1.175C14F3-8CB4-40A0-8E61-A1E77F4CA538.svs 40600 41460 2 +/data/TCGA/7a459e54-3a75-4000-ac21-3ff41d029a8f/TCGA-OR-A5JK-01Z-00-DX1.175C14F3-8CB4-40A0-8E61-A1E77F4CA538.svs 136219 49963 3 +/data/TCGA/6a0fb0c5-2766-4126-9014-cc40229d88fe/TCGA-DQ-5624-01Z-00-DX1.2FBB7F46-9D34-4B79-AF37-1BD87D19036B.svs 100068 13062 0 +/data/TCGA/6a0fb0c5-2766-4126-9014-cc40229d88fe/TCGA-DQ-5624-01Z-00-DX1.2FBB7F46-9D34-4B79-AF37-1BD87D19036B.svs 19766 74209 1 +/data/TCGA/6a0fb0c5-2766-4126-9014-cc40229d88fe/TCGA-DQ-5624-01Z-00-DX1.2FBB7F46-9D34-4B79-AF37-1BD87D19036B.svs 18007 27503 2 +/data/TCGA/ce62b2b2-0d50-4bec-beed-53bd86a2389f/TCGA-OR-A5J3-01Z-00-DX1.4C551BE0-E8AF-46C4-8A44-173AD1BB18B5.svs 53806 58608 0 +/data/TCGA/ce62b2b2-0d50-4bec-beed-53bd86a2389f/TCGA-OR-A5J3-01Z-00-DX1.4C551BE0-E8AF-46C4-8A44-173AD1BB18B5.svs 43852 13150 1 +/data/TCGA/ce62b2b2-0d50-4bec-beed-53bd86a2389f/TCGA-OR-A5J3-01Z-00-DX1.4C551BE0-E8AF-46C4-8A44-173AD1BB18B5.svs 20439 39218 2 +/data/TCGA/ce62b2b2-0d50-4bec-beed-53bd86a2389f/TCGA-OR-A5J3-01Z-00-DX1.4C551BE0-E8AF-46C4-8A44-173AD1BB18B5.svs 78670 715 3 +/data/TCGA/28133b49-4f5f-4012-9ef3-caa4f8a12e46/TCGA-CD-8529-01Z-00-DX1.C3BA5482-04EB-4E1A-BFFA-5461489B5792.svs 63719 22882 0 +/data/TCGA/28133b49-4f5f-4012-9ef3-caa4f8a12e46/TCGA-CD-8529-01Z-00-DX1.C3BA5482-04EB-4E1A-BFFA-5461489B5792.svs 18282 38787 1 +/data/TCGA/28133b49-4f5f-4012-9ef3-caa4f8a12e46/TCGA-CD-8529-01Z-00-DX1.C3BA5482-04EB-4E1A-BFFA-5461489B5792.svs 38962 24764 2 +/data/TCGA/28133b49-4f5f-4012-9ef3-caa4f8a12e46/TCGA-CD-8529-01Z-00-DX1.C3BA5482-04EB-4E1A-BFFA-5461489B5792.svs 12297 45553 3 +/data/TCGA/692d5887-0738-425e-92b9-81771f00a21d/TCGA-02-0330-01Z-00-DX1.e93b88e9-01f4-4bab-bebd-3102752feb79.svs 31409 5816 0 +/data/TCGA/692d5887-0738-425e-92b9-81771f00a21d/TCGA-02-0330-01Z-00-DX1.e93b88e9-01f4-4bab-bebd-3102752feb79.svs 45523 8673 1 +/data/TCGA/692d5887-0738-425e-92b9-81771f00a21d/TCGA-02-0330-01Z-00-DX1.e93b88e9-01f4-4bab-bebd-3102752feb79.svs 30307 11525 2 +/data/TCGA/da122018-99c6-439b-9f4b-8a682cd55c34/TCGA-D6-6825-01Z-00-DX2.988BA622-0BBB-456A-8050-B52DA96A699A.svs 22311 39455 0 +/data/TCGA/da122018-99c6-439b-9f4b-8a682cd55c34/TCGA-D6-6825-01Z-00-DX2.988BA622-0BBB-456A-8050-B52DA96A699A.svs 43593 21476 1 +/data/TCGA/da122018-99c6-439b-9f4b-8a682cd55c34/TCGA-D6-6825-01Z-00-DX2.988BA622-0BBB-456A-8050-B52DA96A699A.svs 54329 21599 2 +/data/TCGA/da122018-99c6-439b-9f4b-8a682cd55c34/TCGA-D6-6825-01Z-00-DX2.988BA622-0BBB-456A-8050-B52DA96A699A.svs 121064 31810 3 +/data/TCGA/7a3ea161-3b35-40de-a2f7-a5879cdfe245/TCGA-23-1030-01Z-00-DX1.FC93147F-FB55-4C62-B187-337A5C107096.svs 41343 54588 0 +/data/TCGA/7a3ea161-3b35-40de-a2f7-a5879cdfe245/TCGA-23-1030-01Z-00-DX1.FC93147F-FB55-4C62-B187-337A5C107096.svs 29792 53859 1 +/data/TCGA/7a3ea161-3b35-40de-a2f7-a5879cdfe245/TCGA-23-1030-01Z-00-DX1.FC93147F-FB55-4C62-B187-337A5C107096.svs 31778 43069 2 +/data/TCGA/7a3ea161-3b35-40de-a2f7-a5879cdfe245/TCGA-23-1030-01Z-00-DX1.FC93147F-FB55-4C62-B187-337A5C107096.svs 49299 40881 3 +/data/TCGA/e9505ca9-bf69-410a-8a6a-e1f00a2673e8/TCGA-DX-A6YV-01Z-00-DX2.13AA3F9B-4841-412F-9E2C-42F0852A98AF.svs 20479 7630 0 +/data/TCGA/e9505ca9-bf69-410a-8a6a-e1f00a2673e8/TCGA-DX-A6YV-01Z-00-DX2.13AA3F9B-4841-412F-9E2C-42F0852A98AF.svs 72851 51173 1 +/data/TCGA/e9505ca9-bf69-410a-8a6a-e1f00a2673e8/TCGA-DX-A6YV-01Z-00-DX2.13AA3F9B-4841-412F-9E2C-42F0852A98AF.svs 51300 20132 2 +/data/TCGA/e9505ca9-bf69-410a-8a6a-e1f00a2673e8/TCGA-DX-A6YV-01Z-00-DX2.13AA3F9B-4841-412F-9E2C-42F0852A98AF.svs 66031 6307 3 +/data/TCGA/b522b324-b124-4390-8348-6c0ce36dadce/TCGA-06-0189-01Z-00-DX3.8e42ed95-d001-430a-a24f-65e7838ff95a.svs 17577 7882 0 +/data/TCGA/b522b324-b124-4390-8348-6c0ce36dadce/TCGA-06-0189-01Z-00-DX3.8e42ed95-d001-430a-a24f-65e7838ff95a.svs 15530 7942 1 +/data/TCGA/b522b324-b124-4390-8348-6c0ce36dadce/TCGA-06-0189-01Z-00-DX3.8e42ed95-d001-430a-a24f-65e7838ff95a.svs 9549 4817 2 +/data/TCGA/ded10b7f-e408-4b52-b735-dfc530e6bc5f/TCGA-B6-A1KI-01Z-00-DX1.EFAA08A8-02EC-4A9B-AC6B-79BF2DC5A2AA.svs 94942 75643 0 +/data/TCGA/ded10b7f-e408-4b52-b735-dfc530e6bc5f/TCGA-B6-A1KI-01Z-00-DX1.EFAA08A8-02EC-4A9B-AC6B-79BF2DC5A2AA.svs 80697 8387 1 +/data/TCGA/ded10b7f-e408-4b52-b735-dfc530e6bc5f/TCGA-B6-A1KI-01Z-00-DX1.EFAA08A8-02EC-4A9B-AC6B-79BF2DC5A2AA.svs 55367 48753 2 +/data/TCGA/ded10b7f-e408-4b52-b735-dfc530e6bc5f/TCGA-B6-A1KI-01Z-00-DX1.EFAA08A8-02EC-4A9B-AC6B-79BF2DC5A2AA.svs 58440 39812 3 +/data/TCGA/de5e2841-c54a-4435-b91f-69ca13145c65/TCGA-EE-A3AC-01Z-00-DX1.88164694-3D29-4D4F-AFF1-8E8425FA7A56.svs 74775 74417 0 +/data/TCGA/de5e2841-c54a-4435-b91f-69ca13145c65/TCGA-EE-A3AC-01Z-00-DX1.88164694-3D29-4D4F-AFF1-8E8425FA7A56.svs 71144 49390 1 +/data/TCGA/de5e2841-c54a-4435-b91f-69ca13145c65/TCGA-EE-A3AC-01Z-00-DX1.88164694-3D29-4D4F-AFF1-8E8425FA7A56.svs 97078 43475 2 +/data/TCGA/de5e2841-c54a-4435-b91f-69ca13145c65/TCGA-EE-A3AC-01Z-00-DX1.88164694-3D29-4D4F-AFF1-8E8425FA7A56.svs 35546 51491 3 +/data/TCGA/5d972c91-4a49-4dda-994f-25fc0fc8491a/TCGA-CV-7180-01Z-00-DX1.9C31E39D-548C-4587-9FF1-18B1F1E0BE22.svs 60032 25732 0 +/data/TCGA/5d972c91-4a49-4dda-994f-25fc0fc8491a/TCGA-CV-7180-01Z-00-DX1.9C31E39D-548C-4587-9FF1-18B1F1E0BE22.svs 25809 46289 1 +/data/TCGA/5d972c91-4a49-4dda-994f-25fc0fc8491a/TCGA-CV-7180-01Z-00-DX1.9C31E39D-548C-4587-9FF1-18B1F1E0BE22.svs 4745 10778 2 +/data/TCGA/5d972c91-4a49-4dda-994f-25fc0fc8491a/TCGA-CV-7180-01Z-00-DX1.9C31E39D-548C-4587-9FF1-18B1F1E0BE22.svs 49831 36113 3 +/data/TCGA/cfe0818a-1baf-407f-a43d-373725e3e581/TCGA-G9-6342-01Z-00-DX1.5ea9bcc5-b2ce-4aef-a89d-c02eb3fd8910.svs 19880 28162 0 +/data/TCGA/cfe0818a-1baf-407f-a43d-373725e3e581/TCGA-G9-6342-01Z-00-DX1.5ea9bcc5-b2ce-4aef-a89d-c02eb3fd8910.svs 70032 52343 1 +/data/TCGA/cfe0818a-1baf-407f-a43d-373725e3e581/TCGA-G9-6342-01Z-00-DX1.5ea9bcc5-b2ce-4aef-a89d-c02eb3fd8910.svs 54264 34389 2 +/data/TCGA/cfe0818a-1baf-407f-a43d-373725e3e581/TCGA-G9-6342-01Z-00-DX1.5ea9bcc5-b2ce-4aef-a89d-c02eb3fd8910.svs 18429 16908 3 +/data/TCGA/cebe8a34-5f4f-42cf-a723-41e655a1ff55/TCGA-EL-A3MX-01Z-00-DX1.4E7683C9-AA35-4A12-BE04-948A609446FB.svs 78071 30350 0 +/data/TCGA/cebe8a34-5f4f-42cf-a723-41e655a1ff55/TCGA-EL-A3MX-01Z-00-DX1.4E7683C9-AA35-4A12-BE04-948A609446FB.svs 46760 61503 1 +/data/TCGA/cebe8a34-5f4f-42cf-a723-41e655a1ff55/TCGA-EL-A3MX-01Z-00-DX1.4E7683C9-AA35-4A12-BE04-948A609446FB.svs 59167 48719 2 +/data/TCGA/cebe8a34-5f4f-42cf-a723-41e655a1ff55/TCGA-EL-A3MX-01Z-00-DX1.4E7683C9-AA35-4A12-BE04-948A609446FB.svs 18330 37358 3 +/data/TCGA/e10336a7-0b79-4c1b-b1f5-bfe09aeefd61/TCGA-ND-A4WC-01Z-00-DX3.C9E15FCA-65BA-4F46-B9FF-320C021FE76C.svs 30747 48756 0 +/data/TCGA/e10336a7-0b79-4c1b-b1f5-bfe09aeefd61/TCGA-ND-A4WC-01Z-00-DX3.C9E15FCA-65BA-4F46-B9FF-320C021FE76C.svs 83972 61790 1 +/data/TCGA/e10336a7-0b79-4c1b-b1f5-bfe09aeefd61/TCGA-ND-A4WC-01Z-00-DX3.C9E15FCA-65BA-4F46-B9FF-320C021FE76C.svs 80892 52931 2 +/data/TCGA/e10336a7-0b79-4c1b-b1f5-bfe09aeefd61/TCGA-ND-A4WC-01Z-00-DX3.C9E15FCA-65BA-4F46-B9FF-320C021FE76C.svs 10657 53412 3 +/data/TCGA/b7e4d0de-470b-4b30-9034-7f723c61bbc9/TCGA-AP-A05D-01Z-00-DX1.02C9F205-6854-47C6-BCCF-A5B40267106C.svs 10891 36065 0 +/data/TCGA/b7e4d0de-470b-4b30-9034-7f723c61bbc9/TCGA-AP-A05D-01Z-00-DX1.02C9F205-6854-47C6-BCCF-A5B40267106C.svs 17655 13621 1 +/data/TCGA/b7e4d0de-470b-4b30-9034-7f723c61bbc9/TCGA-AP-A05D-01Z-00-DX1.02C9F205-6854-47C6-BCCF-A5B40267106C.svs 28616 2299 2 +/data/TCGA/29a3c818-1336-4c3f-a0b5-be6ba62bf26f/TCGA-CN-6016-01Z-00-DX1.737054ae-50f4-42c4-b79c-c462220b12f3.svs 14627 29300 0 +/data/TCGA/29a3c818-1336-4c3f-a0b5-be6ba62bf26f/TCGA-CN-6016-01Z-00-DX1.737054ae-50f4-42c4-b79c-c462220b12f3.svs 22061 27580 1 +/data/TCGA/29a3c818-1336-4c3f-a0b5-be6ba62bf26f/TCGA-CN-6016-01Z-00-DX1.737054ae-50f4-42c4-b79c-c462220b12f3.svs 12118 17656 2 +/data/TCGA/29a3c818-1336-4c3f-a0b5-be6ba62bf26f/TCGA-CN-6016-01Z-00-DX1.737054ae-50f4-42c4-b79c-c462220b12f3.svs 78551 19241 3 +/data/TCGA/bd9345b3-50c3-4d89-8b34-45ca11cfed13/TCGA-YL-A9WH-01Z-00-DX1.7240AB29-F661-4456-A68D-B0FF40F553B8.svs 71150 43826 0 +/data/TCGA/bd9345b3-50c3-4d89-8b34-45ca11cfed13/TCGA-YL-A9WH-01Z-00-DX1.7240AB29-F661-4456-A68D-B0FF40F553B8.svs 35817 75498 1 +/data/TCGA/bd9345b3-50c3-4d89-8b34-45ca11cfed13/TCGA-YL-A9WH-01Z-00-DX1.7240AB29-F661-4456-A68D-B0FF40F553B8.svs 79283 58874 2 +/data/TCGA/bd9345b3-50c3-4d89-8b34-45ca11cfed13/TCGA-YL-A9WH-01Z-00-DX1.7240AB29-F661-4456-A68D-B0FF40F553B8.svs 65504 9282 3 +/data/TCGA/111bea5e-d0ab-4fb8-b1e5-49e104a3fee3/TCGA-JL-A3YX-01Z-00-DX1.0FE8F389-F79A-4CF8-A83C-420380A02552.svs 32101 63078 0 +/data/TCGA/111bea5e-d0ab-4fb8-b1e5-49e104a3fee3/TCGA-JL-A3YX-01Z-00-DX1.0FE8F389-F79A-4CF8-A83C-420380A02552.svs 80042 42676 1 +/data/TCGA/111bea5e-d0ab-4fb8-b1e5-49e104a3fee3/TCGA-JL-A3YX-01Z-00-DX1.0FE8F389-F79A-4CF8-A83C-420380A02552.svs 63072 17987 2 +/data/TCGA/111bea5e-d0ab-4fb8-b1e5-49e104a3fee3/TCGA-JL-A3YX-01Z-00-DX1.0FE8F389-F79A-4CF8-A83C-420380A02552.svs 43957 69950 3 +/data/TCGA/ba327d54-5850-45de-925a-f6c9e693bdd6/TCGA-CC-A3M9-01Z-00-DX1.64A68473-D774-44E0-9569-BD3FECAC6C19.svs 32434 18218 0 +/data/TCGA/ba327d54-5850-45de-925a-f6c9e693bdd6/TCGA-CC-A3M9-01Z-00-DX1.64A68473-D774-44E0-9569-BD3FECAC6C19.svs 22235 27972 1 +/data/TCGA/ba327d54-5850-45de-925a-f6c9e693bdd6/TCGA-CC-A3M9-01Z-00-DX1.64A68473-D774-44E0-9569-BD3FECAC6C19.svs 13959 49625 2 +/data/TCGA/ba327d54-5850-45de-925a-f6c9e693bdd6/TCGA-CC-A3M9-01Z-00-DX1.64A68473-D774-44E0-9569-BD3FECAC6C19.svs 29904 19155 3 +/data/TCGA/7c866367-5ee8-4910-942d-0c41a22e7a1f/TCGA-HT-7680-01Z-00-DX2.97354FFD-A8D4-400F-9FEA-7C69C47D4A57.svs 27003 18468 0 +/data/TCGA/7c866367-5ee8-4910-942d-0c41a22e7a1f/TCGA-HT-7680-01Z-00-DX2.97354FFD-A8D4-400F-9FEA-7C69C47D4A57.svs 42681 30436 1 +/data/TCGA/7c866367-5ee8-4910-942d-0c41a22e7a1f/TCGA-HT-7680-01Z-00-DX2.97354FFD-A8D4-400F-9FEA-7C69C47D4A57.svs 24990 58149 2 +/data/TCGA/7c866367-5ee8-4910-942d-0c41a22e7a1f/TCGA-HT-7680-01Z-00-DX2.97354FFD-A8D4-400F-9FEA-7C69C47D4A57.svs 31253 40027 3 +/data/TCGA/7ad7641b-6921-46a0-b231-cc8a8ceee117/TCGA-PG-A5BC-01Z-00-DX7.267346BC-B6C5-4613-9B19-460672319141.svs 30985 49213 0 +/data/TCGA/7ad7641b-6921-46a0-b231-cc8a8ceee117/TCGA-PG-A5BC-01Z-00-DX7.267346BC-B6C5-4613-9B19-460672319141.svs 44824 10545 1 +/data/TCGA/7ad7641b-6921-46a0-b231-cc8a8ceee117/TCGA-PG-A5BC-01Z-00-DX7.267346BC-B6C5-4613-9B19-460672319141.svs 98447 49891 2 +/data/TCGA/7ad7641b-6921-46a0-b231-cc8a8ceee117/TCGA-PG-A5BC-01Z-00-DX7.267346BC-B6C5-4613-9B19-460672319141.svs 37881 55115 3 +/data/TCGA/56b303fd-0e87-46ae-a503-e3fc750444bf/TCGA-GC-A6I3-01Z-00-DX1.1B3D09B9-14FB-4236-9354-3E5CC59354A7.svs 25658 33557 0 +/data/TCGA/56b303fd-0e87-46ae-a503-e3fc750444bf/TCGA-GC-A6I3-01Z-00-DX1.1B3D09B9-14FB-4236-9354-3E5CC59354A7.svs 58791 7042 1 +/data/TCGA/56b303fd-0e87-46ae-a503-e3fc750444bf/TCGA-GC-A6I3-01Z-00-DX1.1B3D09B9-14FB-4236-9354-3E5CC59354A7.svs 5020 25552 2 +/data/TCGA/56b303fd-0e87-46ae-a503-e3fc750444bf/TCGA-GC-A6I3-01Z-00-DX1.1B3D09B9-14FB-4236-9354-3E5CC59354A7.svs 22268 18552 3 +/data/TCGA/f562cd11-2cb0-45c7-acca-7df9da6bf466/TCGA-DX-A3M1-01Z-00-DX1.89418A40-925B-49FA-8A6D-C67DF76DBD6F.svs 119637 21349 0 +/data/TCGA/f562cd11-2cb0-45c7-acca-7df9da6bf466/TCGA-DX-A3M1-01Z-00-DX1.89418A40-925B-49FA-8A6D-C67DF76DBD6F.svs 22180 38408 1 +/data/TCGA/f562cd11-2cb0-45c7-acca-7df9da6bf466/TCGA-DX-A3M1-01Z-00-DX1.89418A40-925B-49FA-8A6D-C67DF76DBD6F.svs 44456 50541 2 +/data/TCGA/f562cd11-2cb0-45c7-acca-7df9da6bf466/TCGA-DX-A3M1-01Z-00-DX1.89418A40-925B-49FA-8A6D-C67DF76DBD6F.svs 81115 12456 3 +/data/TCGA/9f14941b-ea41-4a4d-82fd-de2755076c51/TCGA-HV-A7OP-01Z-00-DX1.9DCA3D26-8093-4D09-AE2C-1E04564C053A.svs 104729 17871 0 +/data/TCGA/9f14941b-ea41-4a4d-82fd-de2755076c51/TCGA-HV-A7OP-01Z-00-DX1.9DCA3D26-8093-4D09-AE2C-1E04564C053A.svs 21801 11909 1 +/data/TCGA/9f14941b-ea41-4a4d-82fd-de2755076c51/TCGA-HV-A7OP-01Z-00-DX1.9DCA3D26-8093-4D09-AE2C-1E04564C053A.svs 16210 10644 2 +/data/TCGA/9f14941b-ea41-4a4d-82fd-de2755076c51/TCGA-HV-A7OP-01Z-00-DX1.9DCA3D26-8093-4D09-AE2C-1E04564C053A.svs 109207 18395 3 +/data/TCGA/a0739286-1384-42c1-a91b-80ec2851ea5e/TCGA-22-4595-01Z-00-DX1.42F28D1E-7AC2-4113-B4EC-F1E7850EA14D.svs 32867 19201 0 +/data/TCGA/a0739286-1384-42c1-a91b-80ec2851ea5e/TCGA-22-4595-01Z-00-DX1.42F28D1E-7AC2-4113-B4EC-F1E7850EA14D.svs 125852 48362 1 +/data/TCGA/a0739286-1384-42c1-a91b-80ec2851ea5e/TCGA-22-4595-01Z-00-DX1.42F28D1E-7AC2-4113-B4EC-F1E7850EA14D.svs 30501 15458 2 +/data/TCGA/a0739286-1384-42c1-a91b-80ec2851ea5e/TCGA-22-4595-01Z-00-DX1.42F28D1E-7AC2-4113-B4EC-F1E7850EA14D.svs 129507 3313 3 +/data/TCGA/c362b1ce-0af7-43a4-80f5-43d849262abc/TCGA-55-8621-01Z-00-DX1.7C519007-D59D-432A-BF4D-23D14A1C8BB6.svs 12455 20590 0 +/data/TCGA/c362b1ce-0af7-43a4-80f5-43d849262abc/TCGA-55-8621-01Z-00-DX1.7C519007-D59D-432A-BF4D-23D14A1C8BB6.svs 24655 8145 1 +/data/TCGA/c362b1ce-0af7-43a4-80f5-43d849262abc/TCGA-55-8621-01Z-00-DX1.7C519007-D59D-432A-BF4D-23D14A1C8BB6.svs 29387 9232 2 +/data/TCGA/4c33c7ae-7b8a-4117-9e33-80c88f0efa53/TCGA-FB-A545-01Z-00-DX1.E1FE6733-4EB1-46C9-A7DB-1DA3D4295360.svs 16596 7538 0 +/data/TCGA/4c33c7ae-7b8a-4117-9e33-80c88f0efa53/TCGA-FB-A545-01Z-00-DX1.E1FE6733-4EB1-46C9-A7DB-1DA3D4295360.svs 23293 9208 1 +/data/TCGA/4c33c7ae-7b8a-4117-9e33-80c88f0efa53/TCGA-FB-A545-01Z-00-DX1.E1FE6733-4EB1-46C9-A7DB-1DA3D4295360.svs 57653 58006 2 +/data/TCGA/4c33c7ae-7b8a-4117-9e33-80c88f0efa53/TCGA-FB-A545-01Z-00-DX1.E1FE6733-4EB1-46C9-A7DB-1DA3D4295360.svs 31338 49882 3 +/data/TCGA/637861c1-1e9c-4934-962a-6360a5eb2703/TCGA-BR-6453-01Z-00-DX1.2e52d64c-e34f-47a9-9e5e-8954b5ef18ca.svs 38074 23822 0 +/data/TCGA/637861c1-1e9c-4934-962a-6360a5eb2703/TCGA-BR-6453-01Z-00-DX1.2e52d64c-e34f-47a9-9e5e-8954b5ef18ca.svs 63290 22033 1 +/data/TCGA/637861c1-1e9c-4934-962a-6360a5eb2703/TCGA-BR-6453-01Z-00-DX1.2e52d64c-e34f-47a9-9e5e-8954b5ef18ca.svs 81267 15573 2 +/data/TCGA/637861c1-1e9c-4934-962a-6360a5eb2703/TCGA-BR-6453-01Z-00-DX1.2e52d64c-e34f-47a9-9e5e-8954b5ef18ca.svs 67003 21668 3 +/data/TCGA/77a8d82f-9d8c-48f5-a0cc-641b3e8da151/TCGA-A7-A13E-01Z-00-DX2.1E1262AE-A32D-4814-94A5-D951CA8BA35D.svs 20180 11437 0 +/data/TCGA/77a8d82f-9d8c-48f5-a0cc-641b3e8da151/TCGA-A7-A13E-01Z-00-DX2.1E1262AE-A32D-4814-94A5-D951CA8BA35D.svs 112810 45287 1 +/data/TCGA/77a8d82f-9d8c-48f5-a0cc-641b3e8da151/TCGA-A7-A13E-01Z-00-DX2.1E1262AE-A32D-4814-94A5-D951CA8BA35D.svs 105263 36697 2 +/data/TCGA/77a8d82f-9d8c-48f5-a0cc-641b3e8da151/TCGA-A7-A13E-01Z-00-DX2.1E1262AE-A32D-4814-94A5-D951CA8BA35D.svs 8315 8608 3 +/data/TCGA/31181a20-a87b-426b-a3f4-2a485d40313b/TCGA-J8-A3O1-01Z-00-DX1.0BDEF136-AA2A-424F-B8E4-61B6C8C4F93A.svs 33516 56045 0 +/data/TCGA/31181a20-a87b-426b-a3f4-2a485d40313b/TCGA-J8-A3O1-01Z-00-DX1.0BDEF136-AA2A-424F-B8E4-61B6C8C4F93A.svs 65148 36748 1 +/data/TCGA/31181a20-a87b-426b-a3f4-2a485d40313b/TCGA-J8-A3O1-01Z-00-DX1.0BDEF136-AA2A-424F-B8E4-61B6C8C4F93A.svs 72323 40218 2 +/data/TCGA/31181a20-a87b-426b-a3f4-2a485d40313b/TCGA-J8-A3O1-01Z-00-DX1.0BDEF136-AA2A-424F-B8E4-61B6C8C4F93A.svs 87645 22336 3 +/data/TCGA/396ce131-0fff-4a74-8a6e-b878f263f772/TCGA-KL-8325-01Z-00-DX1.330bdb6c-86ee-4577-9846-298080b4c2ad.svs 79578 11883 0 +/data/TCGA/396ce131-0fff-4a74-8a6e-b878f263f772/TCGA-KL-8325-01Z-00-DX1.330bdb6c-86ee-4577-9846-298080b4c2ad.svs 73706 38731 1 +/data/TCGA/396ce131-0fff-4a74-8a6e-b878f263f772/TCGA-KL-8325-01Z-00-DX1.330bdb6c-86ee-4577-9846-298080b4c2ad.svs 17564 30168 2 +/data/TCGA/396ce131-0fff-4a74-8a6e-b878f263f772/TCGA-KL-8325-01Z-00-DX1.330bdb6c-86ee-4577-9846-298080b4c2ad.svs 74539 26923 3 +/data/TCGA/779367cd-53f1-4a8a-835b-99bcfcb61885/TCGA-DC-6160-01Z-00-DX1.5de94ec6-7c9b-41ee-ad43-189d30c11657.svs 32792 30774 0 +/data/TCGA/779367cd-53f1-4a8a-835b-99bcfcb61885/TCGA-DC-6160-01Z-00-DX1.5de94ec6-7c9b-41ee-ad43-189d30c11657.svs 76444 68966 1 +/data/TCGA/779367cd-53f1-4a8a-835b-99bcfcb61885/TCGA-DC-6160-01Z-00-DX1.5de94ec6-7c9b-41ee-ad43-189d30c11657.svs 49524 18925 2 +/data/TCGA/779367cd-53f1-4a8a-835b-99bcfcb61885/TCGA-DC-6160-01Z-00-DX1.5de94ec6-7c9b-41ee-ad43-189d30c11657.svs 82748 44285 3 +/data/TCGA/f775f62a-1bfa-4785-acde-38ecde9c812b/TCGA-21-1077-01Z-00-DX1.e7d0d3ca-b24c-4b2b-bb8f-13cc6991fb78.svs 3784 8083 0 +/data/TCGA/f775f62a-1bfa-4785-acde-38ecde9c812b/TCGA-21-1077-01Z-00-DX1.e7d0d3ca-b24c-4b2b-bb8f-13cc6991fb78.svs 2552 6813 1 +/data/TCGA/f775f62a-1bfa-4785-acde-38ecde9c812b/TCGA-21-1077-01Z-00-DX1.e7d0d3ca-b24c-4b2b-bb8f-13cc6991fb78.svs 14313 4467 2 +/data/TCGA/0af7eabf-001b-49e8-8013-100e2f266bb6/TCGA-02-0009-01Z-00-DX2.f5c99ad0-30b1-4f1b-afb0-0a355068eacc.svs 42257 11759 0 +/data/TCGA/0af7eabf-001b-49e8-8013-100e2f266bb6/TCGA-02-0009-01Z-00-DX2.f5c99ad0-30b1-4f1b-afb0-0a355068eacc.svs 21654 4740 1 +/data/TCGA/0af7eabf-001b-49e8-8013-100e2f266bb6/TCGA-02-0009-01Z-00-DX2.f5c99ad0-30b1-4f1b-afb0-0a355068eacc.svs 31984 6103 2 +/data/TCGA/5f4f67bf-5b13-4aa4-929b-9aa096bb89d5/TCGA-AA-3697-01Z-00-DX1.AAB8DB74-F76D-4D0A-A50E-E7F97504A3C4.svs 883 3646 0 +/data/TCGA/5f4f67bf-5b13-4aa4-929b-9aa096bb89d5/TCGA-AA-3697-01Z-00-DX1.AAB8DB74-F76D-4D0A-A50E-E7F97504A3C4.svs 816 5761 1 +/data/TCGA/41240f65-484a-48bf-ac0b-0dec95ee91fb/TCGA-SI-A71P-01Z-00-DX2.E412D194-CDF3-4808-932C-0C45693AD9CE.svs 36919 41640 0 +/data/TCGA/41240f65-484a-48bf-ac0b-0dec95ee91fb/TCGA-SI-A71P-01Z-00-DX2.E412D194-CDF3-4808-932C-0C45693AD9CE.svs 55278 43727 1 +/data/TCGA/41240f65-484a-48bf-ac0b-0dec95ee91fb/TCGA-SI-A71P-01Z-00-DX2.E412D194-CDF3-4808-932C-0C45693AD9CE.svs 39790 17282 2 +/data/TCGA/41240f65-484a-48bf-ac0b-0dec95ee91fb/TCGA-SI-A71P-01Z-00-DX2.E412D194-CDF3-4808-932C-0C45693AD9CE.svs 16672 2692 3 +/data/TCGA/e8ee660d-3245-49f9-ab99-da4f3bd5eb11/TCGA-QH-A6XA-01Z-00-DX1.7B4C2D32-6621-4109-8B13-7620D1E07A0D.svs 14667 42980 0 +/data/TCGA/e8ee660d-3245-49f9-ab99-da4f3bd5eb11/TCGA-QH-A6XA-01Z-00-DX1.7B4C2D32-6621-4109-8B13-7620D1E07A0D.svs 52612 26159 1 +/data/TCGA/e8ee660d-3245-49f9-ab99-da4f3bd5eb11/TCGA-QH-A6XA-01Z-00-DX1.7B4C2D32-6621-4109-8B13-7620D1E07A0D.svs 10635 22921 2 +/data/TCGA/e8ee660d-3245-49f9-ab99-da4f3bd5eb11/TCGA-QH-A6XA-01Z-00-DX1.7B4C2D32-6621-4109-8B13-7620D1E07A0D.svs 46167 21474 3 +/data/TCGA/9e4e1b4c-8d44-4bdc-8b9a-272a6c13e7ae/TCGA-B6-A0I5-01Z-00-DX1.47A30509-4BA0-4BA5-AD9B-F2C2DB701159.svs 99372 12629 0 +/data/TCGA/9e4e1b4c-8d44-4bdc-8b9a-272a6c13e7ae/TCGA-B6-A0I5-01Z-00-DX1.47A30509-4BA0-4BA5-AD9B-F2C2DB701159.svs 69218 33353 1 +/data/TCGA/9e4e1b4c-8d44-4bdc-8b9a-272a6c13e7ae/TCGA-B6-A0I5-01Z-00-DX1.47A30509-4BA0-4BA5-AD9B-F2C2DB701159.svs 27639 53603 2 +/data/TCGA/9e4e1b4c-8d44-4bdc-8b9a-272a6c13e7ae/TCGA-B6-A0I5-01Z-00-DX1.47A30509-4BA0-4BA5-AD9B-F2C2DB701159.svs 69433 32207 3 +/data/TCGA/c6886452-ade0-4c95-ba3c-10b2337c61b3/TCGA-DX-AB32-01Z-00-DX2.79E62C3F-DF00-47C9-8C40-F18A6852C649.svs 36811 25325 0 +/data/TCGA/c6886452-ade0-4c95-ba3c-10b2337c61b3/TCGA-DX-AB32-01Z-00-DX2.79E62C3F-DF00-47C9-8C40-F18A6852C649.svs 11868 62575 1 +/data/TCGA/c6886452-ade0-4c95-ba3c-10b2337c61b3/TCGA-DX-AB32-01Z-00-DX2.79E62C3F-DF00-47C9-8C40-F18A6852C649.svs 39725 24828 2 +/data/TCGA/c6886452-ade0-4c95-ba3c-10b2337c61b3/TCGA-DX-AB32-01Z-00-DX2.79E62C3F-DF00-47C9-8C40-F18A6852C649.svs 49207 38365 3 +/data/TCGA/d1dc64ae-1761-4b18-a484-6f15bb415d27/TCGA-BR-8080-01Z-00-DX1.bd4c0cc9-5baa-4cd0-990b-1f2ce0a19a35.svs 64381 15553 0 +/data/TCGA/d1dc64ae-1761-4b18-a484-6f15bb415d27/TCGA-BR-8080-01Z-00-DX1.bd4c0cc9-5baa-4cd0-990b-1f2ce0a19a35.svs 73318 37088 1 +/data/TCGA/d1dc64ae-1761-4b18-a484-6f15bb415d27/TCGA-BR-8080-01Z-00-DX1.bd4c0cc9-5baa-4cd0-990b-1f2ce0a19a35.svs 23064 41194 2 +/data/TCGA/d1dc64ae-1761-4b18-a484-6f15bb415d27/TCGA-BR-8080-01Z-00-DX1.bd4c0cc9-5baa-4cd0-990b-1f2ce0a19a35.svs 8165 12431 3 +/data/TCGA/060db58e-6c27-428b-9624-2dfe1e4e181b/TCGA-HT-7480-01Z-00-DX1.42E0C267-020A-464E-9652-2068BEC181B8.svs 14038 21647 0 +/data/TCGA/060db58e-6c27-428b-9624-2dfe1e4e181b/TCGA-HT-7480-01Z-00-DX1.42E0C267-020A-464E-9652-2068BEC181B8.svs 9922 23627 1 +/data/TCGA/060db58e-6c27-428b-9624-2dfe1e4e181b/TCGA-HT-7480-01Z-00-DX1.42E0C267-020A-464E-9652-2068BEC181B8.svs 19238 25436 2 +/data/TCGA/33c17f3e-ac55-4a31-b1c3-7aa3effc041c/TCGA-02-0317-01Z-00-DX2.15FFEA24-40C1-42C8-AE60-9CD346EE171A.svs 60229 58750 0 +/data/TCGA/33c17f3e-ac55-4a31-b1c3-7aa3effc041c/TCGA-02-0317-01Z-00-DX2.15FFEA24-40C1-42C8-AE60-9CD346EE171A.svs 48525 40138 1 +/data/TCGA/33c17f3e-ac55-4a31-b1c3-7aa3effc041c/TCGA-02-0317-01Z-00-DX2.15FFEA24-40C1-42C8-AE60-9CD346EE171A.svs 43739 54680 2 +/data/TCGA/33c17f3e-ac55-4a31-b1c3-7aa3effc041c/TCGA-02-0317-01Z-00-DX2.15FFEA24-40C1-42C8-AE60-9CD346EE171A.svs 39440 19691 3 +/data/TCGA/10e96bb7-a8db-4bd8-8077-ecd671052b8c/TCGA-VP-AA1N-01Z-00-DX1.D052BFA0-B7AD-44E4-BCC8-A962960CCCBE.svs 36391 64161 0 +/data/TCGA/10e96bb7-a8db-4bd8-8077-ecd671052b8c/TCGA-VP-AA1N-01Z-00-DX1.D052BFA0-B7AD-44E4-BCC8-A962960CCCBE.svs 44053 26784 1 +/data/TCGA/10e96bb7-a8db-4bd8-8077-ecd671052b8c/TCGA-VP-AA1N-01Z-00-DX1.D052BFA0-B7AD-44E4-BCC8-A962960CCCBE.svs 78839 29704 2 +/data/TCGA/10e96bb7-a8db-4bd8-8077-ecd671052b8c/TCGA-VP-AA1N-01Z-00-DX1.D052BFA0-B7AD-44E4-BCC8-A962960CCCBE.svs 73135 46353 3 +/data/TCGA/193cc528-3328-4ba7-b285-3adb8a0f7586/TCGA-44-7671-01Z-00-DX1.00297baa-00e7-4894-a7b8-c9ac2a9d42d8.svs 85834 21341 0 +/data/TCGA/193cc528-3328-4ba7-b285-3adb8a0f7586/TCGA-44-7671-01Z-00-DX1.00297baa-00e7-4894-a7b8-c9ac2a9d42d8.svs 96271 18014 1 +/data/TCGA/193cc528-3328-4ba7-b285-3adb8a0f7586/TCGA-44-7671-01Z-00-DX1.00297baa-00e7-4894-a7b8-c9ac2a9d42d8.svs 89450 21527 2 +/data/TCGA/193cc528-3328-4ba7-b285-3adb8a0f7586/TCGA-44-7671-01Z-00-DX1.00297baa-00e7-4894-a7b8-c9ac2a9d42d8.svs 1740 18149 3 +/data/TCGA/17605b10-2e42-4d04-b061-54565e69892f/TCGA-37-A5EL-01Z-00-DX1.DFD49A5B-27F6-407E-8ADA-54EDACAA0788.svs 25152 35617 0 +/data/TCGA/17605b10-2e42-4d04-b061-54565e69892f/TCGA-37-A5EL-01Z-00-DX1.DFD49A5B-27F6-407E-8ADA-54EDACAA0788.svs 28567 15623 1 +/data/TCGA/17605b10-2e42-4d04-b061-54565e69892f/TCGA-37-A5EL-01Z-00-DX1.DFD49A5B-27F6-407E-8ADA-54EDACAA0788.svs 29249 34651 2 +/data/TCGA/c9b76172-f2c8-4c66-9a5b-f600fb95ca37/TCGA-HT-7485-01Z-00-DX1.37BA9895-CDC8-4EE9-8264-233C19ADA0FE.svs 55109 21604 0 +/data/TCGA/c9b76172-f2c8-4c66-9a5b-f600fb95ca37/TCGA-HT-7485-01Z-00-DX1.37BA9895-CDC8-4EE9-8264-233C19ADA0FE.svs 33485 55460 1 +/data/TCGA/c9b76172-f2c8-4c66-9a5b-f600fb95ca37/TCGA-HT-7485-01Z-00-DX1.37BA9895-CDC8-4EE9-8264-233C19ADA0FE.svs 20139 53255 2 +/data/TCGA/c9b76172-f2c8-4c66-9a5b-f600fb95ca37/TCGA-HT-7485-01Z-00-DX1.37BA9895-CDC8-4EE9-8264-233C19ADA0FE.svs 16047 27454 3 +/data/TCGA/baa8438c-ae15-4349-9c79-2c9ff02f7210/TCGA-VQ-A8PT-01Z-00-DX1.7A0E6C8F-E0D2-49AC-9C03-3C9B34EB0AE8.svs 67018 14841 0 +/data/TCGA/baa8438c-ae15-4349-9c79-2c9ff02f7210/TCGA-VQ-A8PT-01Z-00-DX1.7A0E6C8F-E0D2-49AC-9C03-3C9B34EB0AE8.svs 19993 13805 1 +/data/TCGA/baa8438c-ae15-4349-9c79-2c9ff02f7210/TCGA-VQ-A8PT-01Z-00-DX1.7A0E6C8F-E0D2-49AC-9C03-3C9B34EB0AE8.svs 88063 5038 2 +/data/TCGA/baa8438c-ae15-4349-9c79-2c9ff02f7210/TCGA-VQ-A8PT-01Z-00-DX1.7A0E6C8F-E0D2-49AC-9C03-3C9B34EB0AE8.svs 31705 15231 3 +/data/TCGA/508855b3-f6a1-4ec3-be38-db51f11b3191/TCGA-06-0174-01Z-00-DX2.de726441-7e3c-47ce-bd09-b890e2d85c5a.svs 3124 17800 0 +/data/TCGA/508855b3-f6a1-4ec3-be38-db51f11b3191/TCGA-06-0174-01Z-00-DX2.de726441-7e3c-47ce-bd09-b890e2d85c5a.svs 5106 20268 1 +/data/TCGA/508855b3-f6a1-4ec3-be38-db51f11b3191/TCGA-06-0174-01Z-00-DX2.de726441-7e3c-47ce-bd09-b890e2d85c5a.svs 9466 5734 2 +/data/TCGA/0a2a3ea8-fe81-42e6-b313-e2d08d126dcb/TCGA-BP-4970-01Z-00-DX1.0075f8d7-796e-4294-b585-3a0bdc29235a.svs 80876 34965 0 +/data/TCGA/0a2a3ea8-fe81-42e6-b313-e2d08d126dcb/TCGA-BP-4970-01Z-00-DX1.0075f8d7-796e-4294-b585-3a0bdc29235a.svs 24468 25901 1 +/data/TCGA/0a2a3ea8-fe81-42e6-b313-e2d08d126dcb/TCGA-BP-4970-01Z-00-DX1.0075f8d7-796e-4294-b585-3a0bdc29235a.svs 60570 46511 2 +/data/TCGA/0a2a3ea8-fe81-42e6-b313-e2d08d126dcb/TCGA-BP-4970-01Z-00-DX1.0075f8d7-796e-4294-b585-3a0bdc29235a.svs 59840 47677 3 +/data/TCGA/ee1f2de4-7699-48e0-8b73-e7348776a50d/TCGA-HT-7877-01Z-00-DX2.FFF695A6-CC46-49AC-8E93-78076B660630.svs 15012 58710 0 +/data/TCGA/ee1f2de4-7699-48e0-8b73-e7348776a50d/TCGA-HT-7877-01Z-00-DX2.FFF695A6-CC46-49AC-8E93-78076B660630.svs 48664 38344 1 +/data/TCGA/ee1f2de4-7699-48e0-8b73-e7348776a50d/TCGA-HT-7877-01Z-00-DX2.FFF695A6-CC46-49AC-8E93-78076B660630.svs 107113 30029 2 +/data/TCGA/ee1f2de4-7699-48e0-8b73-e7348776a50d/TCGA-HT-7877-01Z-00-DX2.FFF695A6-CC46-49AC-8E93-78076B660630.svs 27099 34080 3 +/data/TCGA/ca41a610-64f1-4f7f-8eba-d18ddd738b1c/TCGA-OR-A5JV-01Z-00-DX5.B67C2644-7729-48BA-8498-1D7C97994C1B.svs 76192 51201 0 +/data/TCGA/ca41a610-64f1-4f7f-8eba-d18ddd738b1c/TCGA-OR-A5JV-01Z-00-DX5.B67C2644-7729-48BA-8498-1D7C97994C1B.svs 81640 45981 1 +/data/TCGA/ca41a610-64f1-4f7f-8eba-d18ddd738b1c/TCGA-OR-A5JV-01Z-00-DX5.B67C2644-7729-48BA-8498-1D7C97994C1B.svs 29290 29334 2 +/data/TCGA/ca41a610-64f1-4f7f-8eba-d18ddd738b1c/TCGA-OR-A5JV-01Z-00-DX5.B67C2644-7729-48BA-8498-1D7C97994C1B.svs 47051 48588 3 +/data/TCGA/837ce93b-1bb4-4f04-8ab6-3d7cc44b5bc4/TCGA-PL-A8LZ-01A-02-DX2.E2697718-12E1-4D7C-9ED8-0A71C6D855B8.svs 60919 11873 0 +/data/TCGA/837ce93b-1bb4-4f04-8ab6-3d7cc44b5bc4/TCGA-PL-A8LZ-01A-02-DX2.E2697718-12E1-4D7C-9ED8-0A71C6D855B8.svs 61443 9300 1 +/data/TCGA/837ce93b-1bb4-4f04-8ab6-3d7cc44b5bc4/TCGA-PL-A8LZ-01A-02-DX2.E2697718-12E1-4D7C-9ED8-0A71C6D855B8.svs 11821 17906 2 +/data/TCGA/837ce93b-1bb4-4f04-8ab6-3d7cc44b5bc4/TCGA-PL-A8LZ-01A-02-DX2.E2697718-12E1-4D7C-9ED8-0A71C6D855B8.svs 56717 7865 3 +/data/TCGA/65626174-aa22-4722-a932-058df0c4b232/TCGA-99-AA5R-01Z-00-DX1.4DE7FC30-D338-49CE-B8D9-EB0F34A3DD0B.svs 31090 31207 0 +/data/TCGA/65626174-aa22-4722-a932-058df0c4b232/TCGA-99-AA5R-01Z-00-DX1.4DE7FC30-D338-49CE-B8D9-EB0F34A3DD0B.svs 41789 26317 1 +/data/TCGA/65626174-aa22-4722-a932-058df0c4b232/TCGA-99-AA5R-01Z-00-DX1.4DE7FC30-D338-49CE-B8D9-EB0F34A3DD0B.svs 27977 7773 2 +/data/TCGA/d0d66e51-07c5-4d27-8c73-50e87bcf35ca/TCGA-06-6388-01Z-00-DX1.14c09c5f-3ea4-4e1e-a5e6-308325383165.svs 17361 66094 0 +/data/TCGA/d0d66e51-07c5-4d27-8c73-50e87bcf35ca/TCGA-06-6388-01Z-00-DX1.14c09c5f-3ea4-4e1e-a5e6-308325383165.svs 90641 43320 1 +/data/TCGA/d0d66e51-07c5-4d27-8c73-50e87bcf35ca/TCGA-06-6388-01Z-00-DX1.14c09c5f-3ea4-4e1e-a5e6-308325383165.svs 27759 35840 2 +/data/TCGA/d0d66e51-07c5-4d27-8c73-50e87bcf35ca/TCGA-06-6388-01Z-00-DX1.14c09c5f-3ea4-4e1e-a5e6-308325383165.svs 72756 47750 3 +/data/TCGA/292bd7cc-a608-4c57-8924-b2b5aa27ec92/TCGA-DU-A6S6-01Z-00-DX1.24E0E59F-ADD0-430D-AC6D-F6FD73C60345.svs 26470 18128 0 +/data/TCGA/292bd7cc-a608-4c57-8924-b2b5aa27ec92/TCGA-DU-A6S6-01Z-00-DX1.24E0E59F-ADD0-430D-AC6D-F6FD73C60345.svs 21543 8205 1 +/data/TCGA/292bd7cc-a608-4c57-8924-b2b5aa27ec92/TCGA-DU-A6S6-01Z-00-DX1.24E0E59F-ADD0-430D-AC6D-F6FD73C60345.svs 15407 15032 2 +/data/TCGA/987e8890-7c5d-4644-8a09-dd759765ef6e/TCGA-DU-A7TI-01Z-00-DX1.4D83F5FC-F203-405A-AF16-5CA5F76E5001.svs 10871 3273 0 +/data/TCGA/987e8890-7c5d-4644-8a09-dd759765ef6e/TCGA-DU-A7TI-01Z-00-DX1.4D83F5FC-F203-405A-AF16-5CA5F76E5001.svs 9146 11917 1 +/data/TCGA/987e8890-7c5d-4644-8a09-dd759765ef6e/TCGA-DU-A7TI-01Z-00-DX1.4D83F5FC-F203-405A-AF16-5CA5F76E5001.svs 12436 3506 2 +/data/TCGA/e43af631-d018-4d6d-a1cc-e0f1012613f9/TCGA-B8-4620-01Z-00-DX1.dc9f48a4-0c88-49c7-ae2e-92d3b5c74b16.svs 27934 67514 0 +/data/TCGA/e43af631-d018-4d6d-a1cc-e0f1012613f9/TCGA-B8-4620-01Z-00-DX1.dc9f48a4-0c88-49c7-ae2e-92d3b5c74b16.svs 4757 30440 1 +/data/TCGA/e43af631-d018-4d6d-a1cc-e0f1012613f9/TCGA-B8-4620-01Z-00-DX1.dc9f48a4-0c88-49c7-ae2e-92d3b5c74b16.svs 41802 55803 2 +/data/TCGA/e43af631-d018-4d6d-a1cc-e0f1012613f9/TCGA-B8-4620-01Z-00-DX1.dc9f48a4-0c88-49c7-ae2e-92d3b5c74b16.svs 19926 27109 3 +/data/TCGA/0ee0d97a-2653-4b7f-bde3-ddd418e40199/TCGA-HT-7688-01Z-00-DX1.3F05DC67-1EB1-461D-A51D-E38B99CBFCD1.svs 20714 35989 0 +/data/TCGA/0ee0d97a-2653-4b7f-bde3-ddd418e40199/TCGA-HT-7688-01Z-00-DX1.3F05DC67-1EB1-461D-A51D-E38B99CBFCD1.svs 46861 14015 1 +/data/TCGA/0ee0d97a-2653-4b7f-bde3-ddd418e40199/TCGA-HT-7688-01Z-00-DX1.3F05DC67-1EB1-461D-A51D-E38B99CBFCD1.svs 18871 48133 2 +/data/TCGA/0ee0d97a-2653-4b7f-bde3-ddd418e40199/TCGA-HT-7688-01Z-00-DX1.3F05DC67-1EB1-461D-A51D-E38B99CBFCD1.svs 14717 27039 3 +/data/TCGA/7de15398-9ca2-4e4d-aadd-81c340329114/TCGA-DD-A3A5-01Z-00-DX1.F0D4C0AA-30C3-4954-9367-A63D9E68D2C9.svs 24454 12176 0 +/data/TCGA/7de15398-9ca2-4e4d-aadd-81c340329114/TCGA-DD-A3A5-01Z-00-DX1.F0D4C0AA-30C3-4954-9367-A63D9E68D2C9.svs 81202 48019 1 +/data/TCGA/7de15398-9ca2-4e4d-aadd-81c340329114/TCGA-DD-A3A5-01Z-00-DX1.F0D4C0AA-30C3-4954-9367-A63D9E68D2C9.svs 34099 30862 2 +/data/TCGA/7de15398-9ca2-4e4d-aadd-81c340329114/TCGA-DD-A3A5-01Z-00-DX1.F0D4C0AA-30C3-4954-9367-A63D9E68D2C9.svs 22450 47085 3 +/data/TCGA/2c02fae5-bd2a-4edc-9b07-59d293d35e10/TCGA-EM-A1YD-01Z-00-DX1.476300DE-BEE0-4B66-8128-2C06A2A25D0A.svs 80418 27780 0 +/data/TCGA/2c02fae5-bd2a-4edc-9b07-59d293d35e10/TCGA-EM-A1YD-01Z-00-DX1.476300DE-BEE0-4B66-8128-2C06A2A25D0A.svs 65349 78172 1 +/data/TCGA/2c02fae5-bd2a-4edc-9b07-59d293d35e10/TCGA-EM-A1YD-01Z-00-DX1.476300DE-BEE0-4B66-8128-2C06A2A25D0A.svs 51521 63456 2 +/data/TCGA/2c02fae5-bd2a-4edc-9b07-59d293d35e10/TCGA-EM-A1YD-01Z-00-DX1.476300DE-BEE0-4B66-8128-2C06A2A25D0A.svs 12558 31209 3 +/data/TCGA/6f129ea9-db79-4b9e-9b03-0abcf6167bd2/TCGA-OR-A5LN-01Z-00-DX2.2A409F0B-FF79-49ED-A8B6-D396E58BDC14.svs 104206 24867 0 +/data/TCGA/6f129ea9-db79-4b9e-9b03-0abcf6167bd2/TCGA-OR-A5LN-01Z-00-DX2.2A409F0B-FF79-49ED-A8B6-D396E58BDC14.svs 97084 60603 1 +/data/TCGA/6f129ea9-db79-4b9e-9b03-0abcf6167bd2/TCGA-OR-A5LN-01Z-00-DX2.2A409F0B-FF79-49ED-A8B6-D396E58BDC14.svs 84860 23729 2 +/data/TCGA/6f129ea9-db79-4b9e-9b03-0abcf6167bd2/TCGA-OR-A5LN-01Z-00-DX2.2A409F0B-FF79-49ED-A8B6-D396E58BDC14.svs 73229 46464 3 +/data/TCGA/705acef5-b033-4363-adc4-6aba50d83faf/TCGA-HZ-A77Q-01Z-00-DX1.B28D133B-8DB7-4B89-93BE-3F09C0F101EE.svs 11846 13908 0 +/data/TCGA/705acef5-b033-4363-adc4-6aba50d83faf/TCGA-HZ-A77Q-01Z-00-DX1.B28D133B-8DB7-4B89-93BE-3F09C0F101EE.svs 13338 11517 1 +/data/TCGA/705acef5-b033-4363-adc4-6aba50d83faf/TCGA-HZ-A77Q-01Z-00-DX1.B28D133B-8DB7-4B89-93BE-3F09C0F101EE.svs 10605 11007 2 +/data/TCGA/02d3c810-0b5c-4fa4-bed6-1c2cfb13c737/TCGA-HT-7686-01Z-00-DX2.17E34786-0450-4752-878B-D12DE2D8877D.svs 55686 48863 0 +/data/TCGA/02d3c810-0b5c-4fa4-bed6-1c2cfb13c737/TCGA-HT-7686-01Z-00-DX2.17E34786-0450-4752-878B-D12DE2D8877D.svs 47066 56546 1 +/data/TCGA/02d3c810-0b5c-4fa4-bed6-1c2cfb13c737/TCGA-HT-7686-01Z-00-DX2.17E34786-0450-4752-878B-D12DE2D8877D.svs 44634 16264 2 +/data/TCGA/02d3c810-0b5c-4fa4-bed6-1c2cfb13c737/TCGA-HT-7686-01Z-00-DX2.17E34786-0450-4752-878B-D12DE2D8877D.svs 70988 16117 3 +/data/TCGA/0f58ae76-9875-4861-8d25-19de0b5c827e/TCGA-DK-A3IS-01Z-00-DX1.31CABE32-36D7-4920-BF5A-9C9D8B54320F.svs 80741 71123 0 +/data/TCGA/0f58ae76-9875-4861-8d25-19de0b5c827e/TCGA-DK-A3IS-01Z-00-DX1.31CABE32-36D7-4920-BF5A-9C9D8B54320F.svs 75785 17981 1 +/data/TCGA/0f58ae76-9875-4861-8d25-19de0b5c827e/TCGA-DK-A3IS-01Z-00-DX1.31CABE32-36D7-4920-BF5A-9C9D8B54320F.svs 74641 62464 2 +/data/TCGA/0f58ae76-9875-4861-8d25-19de0b5c827e/TCGA-DK-A3IS-01Z-00-DX1.31CABE32-36D7-4920-BF5A-9C9D8B54320F.svs 95058 12367 3 +/data/TCGA/37d511f7-036f-4750-b40e-8ef00a8ecfde/TCGA-AA-3955-01Z-00-DX1.e0eea910-db79-4797-b9db-bb8bfe35306d.svs 6790 86771 0 +/data/TCGA/37d511f7-036f-4750-b40e-8ef00a8ecfde/TCGA-AA-3955-01Z-00-DX1.e0eea910-db79-4797-b9db-bb8bfe35306d.svs 15898 95850 1 +/data/TCGA/37d511f7-036f-4750-b40e-8ef00a8ecfde/TCGA-AA-3955-01Z-00-DX1.e0eea910-db79-4797-b9db-bb8bfe35306d.svs 19176 86499 2 +/data/TCGA/37d511f7-036f-4750-b40e-8ef00a8ecfde/TCGA-AA-3955-01Z-00-DX1.e0eea910-db79-4797-b9db-bb8bfe35306d.svs 6754 69572 3 +/data/TCGA/870057a9-663c-432a-8c07-4af77e6ca31c/TCGA-AO-A1KT-01Z-00-DX1.47878910-4359-4795-B0BB-FAC147C8D932.svs 29549 30844 0 +/data/TCGA/870057a9-663c-432a-8c07-4af77e6ca31c/TCGA-AO-A1KT-01Z-00-DX1.47878910-4359-4795-B0BB-FAC147C8D932.svs 23686 8521 1 +/data/TCGA/870057a9-663c-432a-8c07-4af77e6ca31c/TCGA-AO-A1KT-01Z-00-DX1.47878910-4359-4795-B0BB-FAC147C8D932.svs 27166 7106 2 +/data/TCGA/870049ab-fb08-41e8-a14f-7377c41942f0/TCGA-IQ-A61K-01Z-00-DX1.92AE10A1-0F59-48DD-A259-6C1B9BD63689.svs 50887 53877 0 +/data/TCGA/870049ab-fb08-41e8-a14f-7377c41942f0/TCGA-IQ-A61K-01Z-00-DX1.92AE10A1-0F59-48DD-A259-6C1B9BD63689.svs 57348 42564 1 +/data/TCGA/870049ab-fb08-41e8-a14f-7377c41942f0/TCGA-IQ-A61K-01Z-00-DX1.92AE10A1-0F59-48DD-A259-6C1B9BD63689.svs 37601 53041 2 +/data/TCGA/870049ab-fb08-41e8-a14f-7377c41942f0/TCGA-IQ-A61K-01Z-00-DX1.92AE10A1-0F59-48DD-A259-6C1B9BD63689.svs 48552 43102 3 +/data/TCGA/5cbea2b5-886f-4d0d-a732-5650cb8cc9d8/TCGA-IB-7649-01Z-00-DX1.4C1EBF34-3C4B-4CF2-999A-976C3B1CC193.svs 31833 20152 0 +/data/TCGA/5cbea2b5-886f-4d0d-a732-5650cb8cc9d8/TCGA-IB-7649-01Z-00-DX1.4C1EBF34-3C4B-4CF2-999A-976C3B1CC193.svs 36160 6916 1 +/data/TCGA/5cbea2b5-886f-4d0d-a732-5650cb8cc9d8/TCGA-IB-7649-01Z-00-DX1.4C1EBF34-3C4B-4CF2-999A-976C3B1CC193.svs 72277 18057 2 +/data/TCGA/5cbea2b5-886f-4d0d-a732-5650cb8cc9d8/TCGA-IB-7649-01Z-00-DX1.4C1EBF34-3C4B-4CF2-999A-976C3B1CC193.svs 10274 56512 3 +/data/TCGA/27905db3-6730-491e-9b67-d1529f0f75d5/TCGA-KO-8415-01Z-00-DX1.CB5F5330-C4E6-4ABB-B9A5-92F94EF23837.svs 43036 53099 0 +/data/TCGA/27905db3-6730-491e-9b67-d1529f0f75d5/TCGA-KO-8415-01Z-00-DX1.CB5F5330-C4E6-4ABB-B9A5-92F94EF23837.svs 26515 32021 1 +/data/TCGA/27905db3-6730-491e-9b67-d1529f0f75d5/TCGA-KO-8415-01Z-00-DX1.CB5F5330-C4E6-4ABB-B9A5-92F94EF23837.svs 34735 10774 2 +/data/TCGA/27905db3-6730-491e-9b67-d1529f0f75d5/TCGA-KO-8415-01Z-00-DX1.CB5F5330-C4E6-4ABB-B9A5-92F94EF23837.svs 56761 21064 3 +/data/TCGA/53bdfb03-93f1-4189-a357-090379f7a2b5/TCGA-06-0188-01Z-00-DX3.4e48d0b9-9941-4b05-9f11-dfe5e3c855a9.svs 8614 5762 0 +/data/TCGA/53bdfb03-93f1-4189-a357-090379f7a2b5/TCGA-06-0188-01Z-00-DX3.4e48d0b9-9941-4b05-9f11-dfe5e3c855a9.svs 10897 8201 1 +/data/TCGA/53bdfb03-93f1-4189-a357-090379f7a2b5/TCGA-06-0188-01Z-00-DX3.4e48d0b9-9941-4b05-9f11-dfe5e3c855a9.svs 17411 23702 2 +/data/TCGA/9f4c83ad-2b86-45dc-bc07-46ee964d20a2/TCGA-78-7536-01Z-00-DX1.6b066140-8b82-40a5-bd48-430eeb4463fe.svs 42602 52508 0 +/data/TCGA/9f4c83ad-2b86-45dc-bc07-46ee964d20a2/TCGA-78-7536-01Z-00-DX1.6b066140-8b82-40a5-bd48-430eeb4463fe.svs 40157 23841 1 +/data/TCGA/9f4c83ad-2b86-45dc-bc07-46ee964d20a2/TCGA-78-7536-01Z-00-DX1.6b066140-8b82-40a5-bd48-430eeb4463fe.svs 13949 44661 2 +/data/TCGA/9f4c83ad-2b86-45dc-bc07-46ee964d20a2/TCGA-78-7536-01Z-00-DX1.6b066140-8b82-40a5-bd48-430eeb4463fe.svs 61387 24870 3 +/data/TCGA/2e6d2481-57e2-4df7-9a1b-737b2837e96c/TCGA-HT-A5R7-01Z-00-DX1.710C776B-5420-42E6-8D40-C5C36D1CA603.svs 17227 15109 0 +/data/TCGA/2e6d2481-57e2-4df7-9a1b-737b2837e96c/TCGA-HT-A5R7-01Z-00-DX1.710C776B-5420-42E6-8D40-C5C36D1CA603.svs 8685 21633 1 +/data/TCGA/2e6d2481-57e2-4df7-9a1b-737b2837e96c/TCGA-HT-A5R7-01Z-00-DX1.710C776B-5420-42E6-8D40-C5C36D1CA603.svs 7989 10409 2 +/data/TCGA/2e6d2481-57e2-4df7-9a1b-737b2837e96c/TCGA-HT-A5R7-01Z-00-DX1.710C776B-5420-42E6-8D40-C5C36D1CA603.svs 11517 9519 3 +/data/TCGA/8a99ca9e-f86b-4d7e-af9b-dcce36bc8773/TCGA-B0-5096-01Z-00-DX1.badbc354-928e-4f7c-9b3f-341154bafbac.svs 20926 31916 0 +/data/TCGA/8a99ca9e-f86b-4d7e-af9b-dcce36bc8773/TCGA-B0-5096-01Z-00-DX1.badbc354-928e-4f7c-9b3f-341154bafbac.svs 22094 41620 1 +/data/TCGA/8a99ca9e-f86b-4d7e-af9b-dcce36bc8773/TCGA-B0-5096-01Z-00-DX1.badbc354-928e-4f7c-9b3f-341154bafbac.svs 22914 26425 2 +/data/TCGA/8a99ca9e-f86b-4d7e-af9b-dcce36bc8773/TCGA-B0-5096-01Z-00-DX1.badbc354-928e-4f7c-9b3f-341154bafbac.svs 32404 30103 3 +/data/TCGA/1fc9e62b-bde1-456c-97bb-6c624169f05b/TCGA-PK-A5H8-01Z-00-DX1.108DAD32-7609-417C-B987-394AA7BB0FA5.svs 50384 48299 0 +/data/TCGA/1fc9e62b-bde1-456c-97bb-6c624169f05b/TCGA-PK-A5H8-01Z-00-DX1.108DAD32-7609-417C-B987-394AA7BB0FA5.svs 89313 64828 1 +/data/TCGA/1fc9e62b-bde1-456c-97bb-6c624169f05b/TCGA-PK-A5H8-01Z-00-DX1.108DAD32-7609-417C-B987-394AA7BB0FA5.svs 75012 65658 2 +/data/TCGA/1fc9e62b-bde1-456c-97bb-6c624169f05b/TCGA-PK-A5H8-01Z-00-DX1.108DAD32-7609-417C-B987-394AA7BB0FA5.svs 43547 13458 3 +/data/TCGA/f0b20193-2629-4aea-8670-4c832039f7d7/TCGA-EE-A3J7-01Z-00-DX1.EEDF0AF3-4BB7-4961-B4EB-65ABA2CE4E18.svs 23369 24518 0 +/data/TCGA/f0b20193-2629-4aea-8670-4c832039f7d7/TCGA-EE-A3J7-01Z-00-DX1.EEDF0AF3-4BB7-4961-B4EB-65ABA2CE4E18.svs 22514 3751 1 +/data/TCGA/f0b20193-2629-4aea-8670-4c832039f7d7/TCGA-EE-A3J7-01Z-00-DX1.EEDF0AF3-4BB7-4961-B4EB-65ABA2CE4E18.svs 16308 17735 2 +/data/TCGA/b3e45b1e-5fb7-4e21-bc71-da5527b50040/TCGA-60-2722-01Z-00-DX1.f3781266-e8dc-4386-9702-5b29e6f2cfa3.svs 19361 28835 0 +/data/TCGA/b3e45b1e-5fb7-4e21-bc71-da5527b50040/TCGA-60-2722-01Z-00-DX1.f3781266-e8dc-4386-9702-5b29e6f2cfa3.svs 33667 1633 1 +/data/TCGA/b3e45b1e-5fb7-4e21-bc71-da5527b50040/TCGA-60-2722-01Z-00-DX1.f3781266-e8dc-4386-9702-5b29e6f2cfa3.svs 26820 3854 2 +/data/TCGA/69b5b476-9c48-46fa-ab6d-f9f6512a0ca6/TCGA-64-5779-01Z-00-DX1.B3268447-DCE0-4927-B5A9-EC4D61E9B17D.svs 81425 25229 0 +/data/TCGA/69b5b476-9c48-46fa-ab6d-f9f6512a0ca6/TCGA-64-5779-01Z-00-DX1.B3268447-DCE0-4927-B5A9-EC4D61E9B17D.svs 44530 28839 1 +/data/TCGA/69b5b476-9c48-46fa-ab6d-f9f6512a0ca6/TCGA-64-5779-01Z-00-DX1.B3268447-DCE0-4927-B5A9-EC4D61E9B17D.svs 9367 12236 2 +/data/TCGA/69b5b476-9c48-46fa-ab6d-f9f6512a0ca6/TCGA-64-5779-01Z-00-DX1.B3268447-DCE0-4927-B5A9-EC4D61E9B17D.svs 45331 17582 3 +/data/TCGA/1cb14e13-72fa-4bf4-8d0b-7318a91d5599/TCGA-C8-A273-01Z-00-DX1.6E5D581F-DF80-478D-82D1-6D6525EED1B5.svs 40988 6763 0 +/data/TCGA/1cb14e13-72fa-4bf4-8d0b-7318a91d5599/TCGA-C8-A273-01Z-00-DX1.6E5D581F-DF80-478D-82D1-6D6525EED1B5.svs 47256 37033 1 +/data/TCGA/1cb14e13-72fa-4bf4-8d0b-7318a91d5599/TCGA-C8-A273-01Z-00-DX1.6E5D581F-DF80-478D-82D1-6D6525EED1B5.svs 36763 26165 2 +/data/TCGA/1cb14e13-72fa-4bf4-8d0b-7318a91d5599/TCGA-C8-A273-01Z-00-DX1.6E5D581F-DF80-478D-82D1-6D6525EED1B5.svs 47639 38883 3 +/data/TCGA/22e8e946-3206-48cf-b2c0-a8e99fcc7aaa/TCGA-EE-A181-01Z-00-DX1.B302A50A-0719-4B46-8605-09D8A0FA20B6.svs 91235 38512 0 +/data/TCGA/22e8e946-3206-48cf-b2c0-a8e99fcc7aaa/TCGA-EE-A181-01Z-00-DX1.B302A50A-0719-4B46-8605-09D8A0FA20B6.svs 84006 47586 1 +/data/TCGA/22e8e946-3206-48cf-b2c0-a8e99fcc7aaa/TCGA-EE-A181-01Z-00-DX1.B302A50A-0719-4B46-8605-09D8A0FA20B6.svs 93913 43117 2 +/data/TCGA/22e8e946-3206-48cf-b2c0-a8e99fcc7aaa/TCGA-EE-A181-01Z-00-DX1.B302A50A-0719-4B46-8605-09D8A0FA20B6.svs 64325 73074 3 +/data/TCGA/7b53b1d0-2b79-49fd-8e67-a7656cdde582/TCGA-AF-4110-01Z-00-DX1.cb8de1f0-0b38-4271-af5f-33655693e35e.svs 29651 29977 0 +/data/TCGA/7b53b1d0-2b79-49fd-8e67-a7656cdde582/TCGA-AF-4110-01Z-00-DX1.cb8de1f0-0b38-4271-af5f-33655693e35e.svs 25002 24121 1 +/data/TCGA/7b53b1d0-2b79-49fd-8e67-a7656cdde582/TCGA-AF-4110-01Z-00-DX1.cb8de1f0-0b38-4271-af5f-33655693e35e.svs 102328 39508 2 +/data/TCGA/7b53b1d0-2b79-49fd-8e67-a7656cdde582/TCGA-AF-4110-01Z-00-DX1.cb8de1f0-0b38-4271-af5f-33655693e35e.svs 15081 4130 3 +/data/TCGA/aefc4939-c6c4-4a41-b578-c13377076c4b/TCGA-23-2084-01Z-00-DX1.94780F2B-9A88-47ED-982B-0048081309C9.svs 30403 64622 0 +/data/TCGA/aefc4939-c6c4-4a41-b578-c13377076c4b/TCGA-23-2084-01Z-00-DX1.94780F2B-9A88-47ED-982B-0048081309C9.svs 11951 52932 1 +/data/TCGA/aefc4939-c6c4-4a41-b578-c13377076c4b/TCGA-23-2084-01Z-00-DX1.94780F2B-9A88-47ED-982B-0048081309C9.svs 43828 24842 2 +/data/TCGA/aefc4939-c6c4-4a41-b578-c13377076c4b/TCGA-23-2084-01Z-00-DX1.94780F2B-9A88-47ED-982B-0048081309C9.svs 11079 41894 3 +/data/TCGA/d84c8e0f-d356-4250-9368-18d3812b8040/TCGA-CV-7245-01Z-00-DX1.9128EEC2-17DC-4DCA-8B91-508A0C0C52D2.svs 21761 33641 0 +/data/TCGA/d84c8e0f-d356-4250-9368-18d3812b8040/TCGA-CV-7245-01Z-00-DX1.9128EEC2-17DC-4DCA-8B91-508A0C0C52D2.svs 62413 19524 1 +/data/TCGA/d84c8e0f-d356-4250-9368-18d3812b8040/TCGA-CV-7245-01Z-00-DX1.9128EEC2-17DC-4DCA-8B91-508A0C0C52D2.svs 76611 35244 2 +/data/TCGA/d84c8e0f-d356-4250-9368-18d3812b8040/TCGA-CV-7245-01Z-00-DX1.9128EEC2-17DC-4DCA-8B91-508A0C0C52D2.svs 50517 19115 3 +/data/TCGA/36130f7e-c4bc-44e3-bc3b-44649955f546/TCGA-AF-3914-01Z-00-DX1.d7bb7792-df51-498b-9d16-fc26e219249f.svs 44676 51899 0 +/data/TCGA/36130f7e-c4bc-44e3-bc3b-44649955f546/TCGA-AF-3914-01Z-00-DX1.d7bb7792-df51-498b-9d16-fc26e219249f.svs 14929 39005 1 +/data/TCGA/36130f7e-c4bc-44e3-bc3b-44649955f546/TCGA-AF-3914-01Z-00-DX1.d7bb7792-df51-498b-9d16-fc26e219249f.svs 17500 26368 2 +/data/TCGA/36130f7e-c4bc-44e3-bc3b-44649955f546/TCGA-AF-3914-01Z-00-DX1.d7bb7792-df51-498b-9d16-fc26e219249f.svs 116672 17407 3 +/data/TCGA/693928b9-15ba-4e69-a23b-b044e35eaf0a/TCGA-HC-7233-01Z-00-DX1.f27b1b5d-4a74-4fa9-95b3-451e478d2691.svs 17810 8684 0 +/data/TCGA/693928b9-15ba-4e69-a23b-b044e35eaf0a/TCGA-HC-7233-01Z-00-DX1.f27b1b5d-4a74-4fa9-95b3-451e478d2691.svs 21180 12468 1 +/data/TCGA/693928b9-15ba-4e69-a23b-b044e35eaf0a/TCGA-HC-7233-01Z-00-DX1.f27b1b5d-4a74-4fa9-95b3-451e478d2691.svs 21563 7499 2 +/data/TCGA/a3c2ab8e-9c83-411e-91f5-9452fcccaef9/TCGA-F2-A44H-01Z-00-DX1.98C75E19-10DE-434A-AF1B-CDD182F6EDD5.svs 37792 42817 0 +/data/TCGA/a3c2ab8e-9c83-411e-91f5-9452fcccaef9/TCGA-F2-A44H-01Z-00-DX1.98C75E19-10DE-434A-AF1B-CDD182F6EDD5.svs 23770 41025 1 +/data/TCGA/a3c2ab8e-9c83-411e-91f5-9452fcccaef9/TCGA-F2-A44H-01Z-00-DX1.98C75E19-10DE-434A-AF1B-CDD182F6EDD5.svs 17534 22282 2 +/data/TCGA/a3c2ab8e-9c83-411e-91f5-9452fcccaef9/TCGA-F2-A44H-01Z-00-DX1.98C75E19-10DE-434A-AF1B-CDD182F6EDD5.svs 11941 18392 3 +/data/TCGA/84e2f3e7-126c-4e1f-98e5-8fc6a8228691/TCGA-CS-6667-01Z-00-DX1.48760481-6237-4876-AA57-612FDADFFC63.svs 416 13060 0 +/data/TCGA/84e2f3e7-126c-4e1f-98e5-8fc6a8228691/TCGA-CS-6667-01Z-00-DX1.48760481-6237-4876-AA57-612FDADFFC63.svs 29017 5451 1 +/data/TCGA/84e2f3e7-126c-4e1f-98e5-8fc6a8228691/TCGA-CS-6667-01Z-00-DX1.48760481-6237-4876-AA57-612FDADFFC63.svs 26141 15300 2 +/data/TCGA/78927bef-e120-4455-89e2-32aed024b4d8/TCGA-IM-A3U2-01Z-00-DX1.CECE491E-95AF-4D3A-8579-358280639B0B.svs 57985 5882 0 +/data/TCGA/78927bef-e120-4455-89e2-32aed024b4d8/TCGA-IM-A3U2-01Z-00-DX1.CECE491E-95AF-4D3A-8579-358280639B0B.svs 42990 39701 1 +/data/TCGA/78927bef-e120-4455-89e2-32aed024b4d8/TCGA-IM-A3U2-01Z-00-DX1.CECE491E-95AF-4D3A-8579-358280639B0B.svs 62783 29920 2 +/data/TCGA/78927bef-e120-4455-89e2-32aed024b4d8/TCGA-IM-A3U2-01Z-00-DX1.CECE491E-95AF-4D3A-8579-358280639B0B.svs 80400 27902 3 +/data/TCGA/aed923bc-d1f0-4490-a9ed-a9b3b7aaeb40/TCGA-CV-6950-01Z-00-DX1.1D8CFDF2-998C-45E2-ACDF-581B679DAD6F.svs 10815 19546 0 +/data/TCGA/aed923bc-d1f0-4490-a9ed-a9b3b7aaeb40/TCGA-CV-6950-01Z-00-DX1.1D8CFDF2-998C-45E2-ACDF-581B679DAD6F.svs 44852 51440 1 +/data/TCGA/aed923bc-d1f0-4490-a9ed-a9b3b7aaeb40/TCGA-CV-6950-01Z-00-DX1.1D8CFDF2-998C-45E2-ACDF-581B679DAD6F.svs 11498 21948 2 +/data/TCGA/aed923bc-d1f0-4490-a9ed-a9b3b7aaeb40/TCGA-CV-6950-01Z-00-DX1.1D8CFDF2-998C-45E2-ACDF-581B679DAD6F.svs 64392 34097 3 +/data/TCGA/21c1d40c-ee8e-4c9a-8d30-dab0faeb3fda/TCGA-86-8669-01Z-00-DX1.845b8b4e-6445-4da1-8275-42b765c024cc.svs 20821 10701 0 +/data/TCGA/21c1d40c-ee8e-4c9a-8d30-dab0faeb3fda/TCGA-86-8669-01Z-00-DX1.845b8b4e-6445-4da1-8275-42b765c024cc.svs 5975 26060 1 +/data/TCGA/21c1d40c-ee8e-4c9a-8d30-dab0faeb3fda/TCGA-86-8669-01Z-00-DX1.845b8b4e-6445-4da1-8275-42b765c024cc.svs 46423 33177 2 +/data/TCGA/21c1d40c-ee8e-4c9a-8d30-dab0faeb3fda/TCGA-86-8669-01Z-00-DX1.845b8b4e-6445-4da1-8275-42b765c024cc.svs 24614 14458 3 +/data/TCGA/90308c41-8fc2-4f27-94ac-975c47d27e97/TCGA-EW-A1J3-01Z-00-DX1.F736F6F4-0859-439A-A417-98B520C8D65A.svs 139701 10716 0 +/data/TCGA/90308c41-8fc2-4f27-94ac-975c47d27e97/TCGA-EW-A1J3-01Z-00-DX1.F736F6F4-0859-439A-A417-98B520C8D65A.svs 37641 17057 1 +/data/TCGA/90308c41-8fc2-4f27-94ac-975c47d27e97/TCGA-EW-A1J3-01Z-00-DX1.F736F6F4-0859-439A-A417-98B520C8D65A.svs 35414 45768 2 +/data/TCGA/90308c41-8fc2-4f27-94ac-975c47d27e97/TCGA-EW-A1J3-01Z-00-DX1.F736F6F4-0859-439A-A417-98B520C8D65A.svs 136181 30314 3 +/data/TCGA/c9051c82-f03e-437b-ac52-a58f05206dbb/TCGA-3G-AB0Q-01Z-00-DX1.B0995F86-D4E1-4DFB-9187-39CDD9ECDF04.svs 53875 45097 0 +/data/TCGA/c9051c82-f03e-437b-ac52-a58f05206dbb/TCGA-3G-AB0Q-01Z-00-DX1.B0995F86-D4E1-4DFB-9187-39CDD9ECDF04.svs 3038 16105 1 +/data/TCGA/c9051c82-f03e-437b-ac52-a58f05206dbb/TCGA-3G-AB0Q-01Z-00-DX1.B0995F86-D4E1-4DFB-9187-39CDD9ECDF04.svs 78946 48514 2 +/data/TCGA/c9051c82-f03e-437b-ac52-a58f05206dbb/TCGA-3G-AB0Q-01Z-00-DX1.B0995F86-D4E1-4DFB-9187-39CDD9ECDF04.svs 33028 13376 3 +/data/TCGA/63b5427c-29d8-4f5b-9e4a-ac73679eca03/TCGA-21-1070-01Z-00-DX1.06363f8a-ef29-4d73-95da-a3172d7873c0.svs 4737 14782 0 +/data/TCGA/63b5427c-29d8-4f5b-9e4a-ac73679eca03/TCGA-21-1070-01Z-00-DX1.06363f8a-ef29-4d73-95da-a3172d7873c0.svs 19620 17346 1 +/data/TCGA/63b5427c-29d8-4f5b-9e4a-ac73679eca03/TCGA-21-1070-01Z-00-DX1.06363f8a-ef29-4d73-95da-a3172d7873c0.svs 34429 8734 2 +/data/TCGA/13323ecb-a0ab-4849-9f77-6ef166d88e96/TCGA-BC-A3KF-01Z-00-DX1.F3B071B2-8C62-4867-8F60-6E207BE1EDF4.svs 26795 20137 0 +/data/TCGA/13323ecb-a0ab-4849-9f77-6ef166d88e96/TCGA-BC-A3KF-01Z-00-DX1.F3B071B2-8C62-4867-8F60-6E207BE1EDF4.svs 31420 42002 1 +/data/TCGA/13323ecb-a0ab-4849-9f77-6ef166d88e96/TCGA-BC-A3KF-01Z-00-DX1.F3B071B2-8C62-4867-8F60-6E207BE1EDF4.svs 35309 3768 2 +/data/TCGA/13323ecb-a0ab-4849-9f77-6ef166d88e96/TCGA-BC-A3KF-01Z-00-DX1.F3B071B2-8C62-4867-8F60-6E207BE1EDF4.svs 115842 4377 3 +/data/TCGA/1c7b2b9a-0efc-4eb8-bc18-704a2c833e0d/TCGA-EO-A3AZ-01Z-00-DX1.113D4EE1-7922-432D-B43B-947756060983.svs 22909 41844 0 +/data/TCGA/1c7b2b9a-0efc-4eb8-bc18-704a2c833e0d/TCGA-EO-A3AZ-01Z-00-DX1.113D4EE1-7922-432D-B43B-947756060983.svs 3639 54707 1 +/data/TCGA/1c7b2b9a-0efc-4eb8-bc18-704a2c833e0d/TCGA-EO-A3AZ-01Z-00-DX1.113D4EE1-7922-432D-B43B-947756060983.svs 6646 48847 2 +/data/TCGA/1c7b2b9a-0efc-4eb8-bc18-704a2c833e0d/TCGA-EO-A3AZ-01Z-00-DX1.113D4EE1-7922-432D-B43B-947756060983.svs 22910 43002 3 +/data/TCGA/2acf254a-9e59-458c-b454-4fef8917d245/TCGA-D7-6520-01Z-00-DX2.60B9C76F-93F5-461E-84F5-C3A3734E5D3C.svs 37108 56568 0 +/data/TCGA/2acf254a-9e59-458c-b454-4fef8917d245/TCGA-D7-6520-01Z-00-DX2.60B9C76F-93F5-461E-84F5-C3A3734E5D3C.svs 119406 63649 1 +/data/TCGA/2acf254a-9e59-458c-b454-4fef8917d245/TCGA-D7-6520-01Z-00-DX2.60B9C76F-93F5-461E-84F5-C3A3734E5D3C.svs 122549 64682 2 +/data/TCGA/2acf254a-9e59-458c-b454-4fef8917d245/TCGA-D7-6520-01Z-00-DX2.60B9C76F-93F5-461E-84F5-C3A3734E5D3C.svs 15931 24188 3 +/data/TCGA/5e7940a3-937d-4f04-84b9-cd9db7e5d5bc/TCGA-OR-A5K0-01Z-00-DX3.7F768C6E-70D5-471D-BD56-95A85B6BDA1E.svs 16739 18538 0 +/data/TCGA/5e7940a3-937d-4f04-84b9-cd9db7e5d5bc/TCGA-OR-A5K0-01Z-00-DX3.7F768C6E-70D5-471D-BD56-95A85B6BDA1E.svs 71690 57508 1 +/data/TCGA/5e7940a3-937d-4f04-84b9-cd9db7e5d5bc/TCGA-OR-A5K0-01Z-00-DX3.7F768C6E-70D5-471D-BD56-95A85B6BDA1E.svs 77167 54991 2 +/data/TCGA/5e7940a3-937d-4f04-84b9-cd9db7e5d5bc/TCGA-OR-A5K0-01Z-00-DX3.7F768C6E-70D5-471D-BD56-95A85B6BDA1E.svs 28398 31429 3 +/data/TCGA/9a809f9d-ea4e-495c-a338-5ecf96847e6e/TCGA-NK-A5CX-01Z-00-DX1.CA1C230C-7A29-491B-A124-7D3B600DAFB7.svs 80168 41781 0 +/data/TCGA/9a809f9d-ea4e-495c-a338-5ecf96847e6e/TCGA-NK-A5CX-01Z-00-DX1.CA1C230C-7A29-491B-A124-7D3B600DAFB7.svs 38735 64208 1 +/data/TCGA/9a809f9d-ea4e-495c-a338-5ecf96847e6e/TCGA-NK-A5CX-01Z-00-DX1.CA1C230C-7A29-491B-A124-7D3B600DAFB7.svs 84078 22657 2 +/data/TCGA/9a809f9d-ea4e-495c-a338-5ecf96847e6e/TCGA-NK-A5CX-01Z-00-DX1.CA1C230C-7A29-491B-A124-7D3B600DAFB7.svs 26418 34250 3 +/data/TCGA/c6053c6a-8ca4-4e15-83b0-3458c5e31d39/TCGA-B6-A0RU-01Z-00-DX1.4977531C-6003-4DA6-9925-30E2DA62C076.svs 115645 48946 0 +/data/TCGA/c6053c6a-8ca4-4e15-83b0-3458c5e31d39/TCGA-B6-A0RU-01Z-00-DX1.4977531C-6003-4DA6-9925-30E2DA62C076.svs 73001 34994 1 +/data/TCGA/c6053c6a-8ca4-4e15-83b0-3458c5e31d39/TCGA-B6-A0RU-01Z-00-DX1.4977531C-6003-4DA6-9925-30E2DA62C076.svs 72362 10457 2 +/data/TCGA/c6053c6a-8ca4-4e15-83b0-3458c5e31d39/TCGA-B6-A0RU-01Z-00-DX1.4977531C-6003-4DA6-9925-30E2DA62C076.svs 126174 34105 3 +/data/TCGA/3d333119-213a-4f2b-9d16-704c275f3770/TCGA-BP-4974-01Z-00-DX1.97991078-9139-4bca-a5c7-0c6c66459df9.svs 106393 63612 0 +/data/TCGA/3d333119-213a-4f2b-9d16-704c275f3770/TCGA-BP-4974-01Z-00-DX1.97991078-9139-4bca-a5c7-0c6c66459df9.svs 88020 60834 1 +/data/TCGA/3d333119-213a-4f2b-9d16-704c275f3770/TCGA-BP-4974-01Z-00-DX1.97991078-9139-4bca-a5c7-0c6c66459df9.svs 74511 51045 2 +/data/TCGA/3d333119-213a-4f2b-9d16-704c275f3770/TCGA-BP-4974-01Z-00-DX1.97991078-9139-4bca-a5c7-0c6c66459df9.svs 26160 46941 3 +/data/TCGA/e8b220d8-eca1-471d-9cd1-46ac3e96adce/TCGA-PG-A914-01Z-00-DX4.33C67F98-A8C3-4C3A-B630-D12014C645EC.svs 123329 25121 0 +/data/TCGA/e8b220d8-eca1-471d-9cd1-46ac3e96adce/TCGA-PG-A914-01Z-00-DX4.33C67F98-A8C3-4C3A-B630-D12014C645EC.svs 136033 35086 1 +/data/TCGA/e8b220d8-eca1-471d-9cd1-46ac3e96adce/TCGA-PG-A914-01Z-00-DX4.33C67F98-A8C3-4C3A-B630-D12014C645EC.svs 122963 30584 2 +/data/TCGA/e8b220d8-eca1-471d-9cd1-46ac3e96adce/TCGA-PG-A914-01Z-00-DX4.33C67F98-A8C3-4C3A-B630-D12014C645EC.svs 103682 47876 3 +/data/TCGA/950a55d7-2c8f-4ab2-82f7-7924276e2a02/TCGA-YF-AA3L-01Z-00-DX1.56C211C1-20C7-4000-9C39-F76919ADA592.svs 36569 38348 0 +/data/TCGA/950a55d7-2c8f-4ab2-82f7-7924276e2a02/TCGA-YF-AA3L-01Z-00-DX1.56C211C1-20C7-4000-9C39-F76919ADA592.svs 61253 23490 1 +/data/TCGA/950a55d7-2c8f-4ab2-82f7-7924276e2a02/TCGA-YF-AA3L-01Z-00-DX1.56C211C1-20C7-4000-9C39-F76919ADA592.svs 48876 12096 2 +/data/TCGA/950a55d7-2c8f-4ab2-82f7-7924276e2a02/TCGA-YF-AA3L-01Z-00-DX1.56C211C1-20C7-4000-9C39-F76919ADA592.svs 20655 47168 3 +/data/TCGA/d68ddec3-da5d-44f7-9bc1-1198b74b9c2e/TCGA-P5-A72W-01Z-00-DX1.0F26308D-5394-4499-AD5C-096B7608AF45.svs 12390 65833 0 +/data/TCGA/d68ddec3-da5d-44f7-9bc1-1198b74b9c2e/TCGA-P5-A72W-01Z-00-DX1.0F26308D-5394-4499-AD5C-096B7608AF45.svs 84191 8524 1 +/data/TCGA/d68ddec3-da5d-44f7-9bc1-1198b74b9c2e/TCGA-P5-A72W-01Z-00-DX1.0F26308D-5394-4499-AD5C-096B7608AF45.svs 45770 34476 2 +/data/TCGA/d68ddec3-da5d-44f7-9bc1-1198b74b9c2e/TCGA-P5-A72W-01Z-00-DX1.0F26308D-5394-4499-AD5C-096B7608AF45.svs 16226 20560 3 +/data/TCGA/183b22ce-1357-4e6e-8246-269d645032dd/TCGA-BR-8592-01Z-00-DX1.5656d484-7850-467a-9d51-b6005a992225.svs 22480 19482 0 +/data/TCGA/183b22ce-1357-4e6e-8246-269d645032dd/TCGA-BR-8592-01Z-00-DX1.5656d484-7850-467a-9d51-b6005a992225.svs 31158 32842 1 +/data/TCGA/183b22ce-1357-4e6e-8246-269d645032dd/TCGA-BR-8592-01Z-00-DX1.5656d484-7850-467a-9d51-b6005a992225.svs 95020 26481 2 +/data/TCGA/183b22ce-1357-4e6e-8246-269d645032dd/TCGA-BR-8592-01Z-00-DX1.5656d484-7850-467a-9d51-b6005a992225.svs 69875 8001 3 +/data/TCGA/95f68385-c86f-4b87-aedb-b39375fa3172/TCGA-AN-A0XN-01Z-00-DX1.A8EB9F62-236E-4C59-A206-DF0C7654AC30.svs 46350 24460 0 +/data/TCGA/95f68385-c86f-4b87-aedb-b39375fa3172/TCGA-AN-A0XN-01Z-00-DX1.A8EB9F62-236E-4C59-A206-DF0C7654AC30.svs 11374 22605 1 +/data/TCGA/95f68385-c86f-4b87-aedb-b39375fa3172/TCGA-AN-A0XN-01Z-00-DX1.A8EB9F62-236E-4C59-A206-DF0C7654AC30.svs 38750 34295 2 +/data/TCGA/95f68385-c86f-4b87-aedb-b39375fa3172/TCGA-AN-A0XN-01Z-00-DX1.A8EB9F62-236E-4C59-A206-DF0C7654AC30.svs 23272 27637 3 +/data/TCGA/f7f69b69-ee8b-43b6-a2d6-75f4074939fe/TCGA-HT-7857-01Z-00-DX2.B2E4366E-05CF-497E-AFA0-77E388C47E82.svs 21969 30528 0 +/data/TCGA/f7f69b69-ee8b-43b6-a2d6-75f4074939fe/TCGA-HT-7857-01Z-00-DX2.B2E4366E-05CF-497E-AFA0-77E388C47E82.svs 49456 28029 1 +/data/TCGA/f7f69b69-ee8b-43b6-a2d6-75f4074939fe/TCGA-HT-7857-01Z-00-DX2.B2E4366E-05CF-497E-AFA0-77E388C47E82.svs 49460 23273 2 +/data/TCGA/f7f69b69-ee8b-43b6-a2d6-75f4074939fe/TCGA-HT-7857-01Z-00-DX2.B2E4366E-05CF-497E-AFA0-77E388C47E82.svs 8145 20607 3 +/data/TCGA/ca3517af-c8f5-4b64-8a39-9999285e9549/TCGA-12-0773-01Z-00-DX3.97970cf6-acd1-4f5a-abd6-92194f2f0055.svs 21169 41641 0 +/data/TCGA/ca3517af-c8f5-4b64-8a39-9999285e9549/TCGA-12-0773-01Z-00-DX3.97970cf6-acd1-4f5a-abd6-92194f2f0055.svs 23495 16674 1 +/data/TCGA/ca3517af-c8f5-4b64-8a39-9999285e9549/TCGA-12-0773-01Z-00-DX3.97970cf6-acd1-4f5a-abd6-92194f2f0055.svs 28028 11646 2 +/data/TCGA/be05944e-5ef9-4da4-ac61-8f9530df4f73/TCGA-CZ-4864-01Z-00-DX1.4c3b083b-cfd3-4b75-9a5f-49286af1b433.svs 10587 16271 0 +/data/TCGA/be05944e-5ef9-4da4-ac61-8f9530df4f73/TCGA-CZ-4864-01Z-00-DX1.4c3b083b-cfd3-4b75-9a5f-49286af1b433.svs 8805 22997 1 +/data/TCGA/be05944e-5ef9-4da4-ac61-8f9530df4f73/TCGA-CZ-4864-01Z-00-DX1.4c3b083b-cfd3-4b75-9a5f-49286af1b433.svs 16768 18220 2 +/data/TCGA/36fc54d9-317b-4c1c-ae55-09acaa86ddf4/TCGA-AO-A0JD-01Z-00-DX1.52E3DCE8-32E3-45C0-AB54-7FA0A2F3F722.svs 18246 10307 0 +/data/TCGA/36fc54d9-317b-4c1c-ae55-09acaa86ddf4/TCGA-AO-A0JD-01Z-00-DX1.52E3DCE8-32E3-45C0-AB54-7FA0A2F3F722.svs 8851 24326 1 +/data/TCGA/36fc54d9-317b-4c1c-ae55-09acaa86ddf4/TCGA-AO-A0JD-01Z-00-DX1.52E3DCE8-32E3-45C0-AB54-7FA0A2F3F722.svs 45286 25455 2 +/data/TCGA/5f9d39db-124c-48dc-b1f0-a2c0c35f810b/TCGA-A5-A0VQ-01Z-00-DX2.5F0F7347-BC10-4568-B2B3-D00BD988D4B2.svs 146178 63848 0 +/data/TCGA/5f9d39db-124c-48dc-b1f0-a2c0c35f810b/TCGA-A5-A0VQ-01Z-00-DX2.5F0F7347-BC10-4568-B2B3-D00BD988D4B2.svs 137695 60914 1 +/data/TCGA/5f9d39db-124c-48dc-b1f0-a2c0c35f810b/TCGA-A5-A0VQ-01Z-00-DX2.5F0F7347-BC10-4568-B2B3-D00BD988D4B2.svs 181911 25802 2 +/data/TCGA/5f9d39db-124c-48dc-b1f0-a2c0c35f810b/TCGA-A5-A0VQ-01Z-00-DX2.5F0F7347-BC10-4568-B2B3-D00BD988D4B2.svs 27476 19712 3 +/data/TCGA/525bb053-2ca4-46ae-b294-3fb6aad4304a/TCGA-EB-A5SH-06Z-00-DX1.2C9CB59B-C09A-487F-BAB7-E71F84DDB985.svs 20431 39354 0 +/data/TCGA/525bb053-2ca4-46ae-b294-3fb6aad4304a/TCGA-EB-A5SH-06Z-00-DX1.2C9CB59B-C09A-487F-BAB7-E71F84DDB985.svs 34273 56408 1 +/data/TCGA/525bb053-2ca4-46ae-b294-3fb6aad4304a/TCGA-EB-A5SH-06Z-00-DX1.2C9CB59B-C09A-487F-BAB7-E71F84DDB985.svs 32069 25359 2 +/data/TCGA/525bb053-2ca4-46ae-b294-3fb6aad4304a/TCGA-EB-A5SH-06Z-00-DX1.2C9CB59B-C09A-487F-BAB7-E71F84DDB985.svs 19651 50293 3 +/data/TCGA/d7efb48a-a583-43c6-a151-0b138cec2c95/TCGA-WB-A814-01Z-00-DX1.432BE11E-CB2D-4907-81B4-C025678A133A.svs 68842 47116 0 +/data/TCGA/d7efb48a-a583-43c6-a151-0b138cec2c95/TCGA-WB-A814-01Z-00-DX1.432BE11E-CB2D-4907-81B4-C025678A133A.svs 67193 15687 1 +/data/TCGA/d7efb48a-a583-43c6-a151-0b138cec2c95/TCGA-WB-A814-01Z-00-DX1.432BE11E-CB2D-4907-81B4-C025678A133A.svs 30627 60080 2 +/data/TCGA/d7efb48a-a583-43c6-a151-0b138cec2c95/TCGA-WB-A814-01Z-00-DX1.432BE11E-CB2D-4907-81B4-C025678A133A.svs 55825 54764 3 +/data/TCGA/5570777f-a9c1-4f2e-a197-d3b0f637f9a7/TCGA-EM-A3FN-01Z-00-DX1.B93AB1DC-1F4A-46FE-A269-0BEC3256E76F.svs 19082 8900 0 +/data/TCGA/5570777f-a9c1-4f2e-a197-d3b0f637f9a7/TCGA-EM-A3FN-01Z-00-DX1.B93AB1DC-1F4A-46FE-A269-0BEC3256E76F.svs 34252 9142 1 +/data/TCGA/5570777f-a9c1-4f2e-a197-d3b0f637f9a7/TCGA-EM-A3FN-01Z-00-DX1.B93AB1DC-1F4A-46FE-A269-0BEC3256E76F.svs 20531 11119 2 +/data/TCGA/04953f26-592e-480d-a56a-bba3f61ed800/TCGA-25-1329-01Z-00-DX1.6DD994F3-E426-4749-8ECA-9A0B87FF04DC.svs 130056 32776 0 +/data/TCGA/04953f26-592e-480d-a56a-bba3f61ed800/TCGA-25-1329-01Z-00-DX1.6DD994F3-E426-4749-8ECA-9A0B87FF04DC.svs 49907 75110 1 +/data/TCGA/04953f26-592e-480d-a56a-bba3f61ed800/TCGA-25-1329-01Z-00-DX1.6DD994F3-E426-4749-8ECA-9A0B87FF04DC.svs 46034 54981 2 +/data/TCGA/04953f26-592e-480d-a56a-bba3f61ed800/TCGA-25-1329-01Z-00-DX1.6DD994F3-E426-4749-8ECA-9A0B87FF04DC.svs 19014 49673 3 +/data/TCGA/d110532e-d387-4f90-8214-f62487829a98/TCGA-IB-7888-01Z-00-DX1.91258212-41B9-4531-B004-C1ACBAA90B6B.svs 84141 16476 0 +/data/TCGA/d110532e-d387-4f90-8214-f62487829a98/TCGA-IB-7888-01Z-00-DX1.91258212-41B9-4531-B004-C1ACBAA90B6B.svs 54826 63528 1 +/data/TCGA/d110532e-d387-4f90-8214-f62487829a98/TCGA-IB-7888-01Z-00-DX1.91258212-41B9-4531-B004-C1ACBAA90B6B.svs 57188 26579 2 +/data/TCGA/d110532e-d387-4f90-8214-f62487829a98/TCGA-IB-7888-01Z-00-DX1.91258212-41B9-4531-B004-C1ACBAA90B6B.svs 73506 41724 3 +/data/TCGA/f379c21c-68ee-4c69-8e69-5fa9bfecfe27/TCGA-E9-A1RI-01Z-00-DX1.3259644B-0888-4B18-B16F-397D55167EAD.svs 51348 40526 0 +/data/TCGA/f379c21c-68ee-4c69-8e69-5fa9bfecfe27/TCGA-E9-A1RI-01Z-00-DX1.3259644B-0888-4B18-B16F-397D55167EAD.svs 32244 43378 1 +/data/TCGA/f379c21c-68ee-4c69-8e69-5fa9bfecfe27/TCGA-E9-A1RI-01Z-00-DX1.3259644B-0888-4B18-B16F-397D55167EAD.svs 79133 39661 2 +/data/TCGA/f379c21c-68ee-4c69-8e69-5fa9bfecfe27/TCGA-E9-A1RI-01Z-00-DX1.3259644B-0888-4B18-B16F-397D55167EAD.svs 80117 23908 3 +/data/TCGA/bc676ee2-d0e4-48ef-9d1d-5a90e79b4fb2/TCGA-D8-A1XS-01Z-00-DX1.E5C78E5A-947C-499D-9E95-619FEEC63E69.svs 72975 23753 0 +/data/TCGA/bc676ee2-d0e4-48ef-9d1d-5a90e79b4fb2/TCGA-D8-A1XS-01Z-00-DX1.E5C78E5A-947C-499D-9E95-619FEEC63E69.svs 11529 42764 1 +/data/TCGA/bc676ee2-d0e4-48ef-9d1d-5a90e79b4fb2/TCGA-D8-A1XS-01Z-00-DX1.E5C78E5A-947C-499D-9E95-619FEEC63E69.svs 44667 50355 2 +/data/TCGA/bc676ee2-d0e4-48ef-9d1d-5a90e79b4fb2/TCGA-D8-A1XS-01Z-00-DX1.E5C78E5A-947C-499D-9E95-619FEEC63E69.svs 60165 47436 3 +/data/TCGA/381ff4ff-9a60-43b2-9624-bcbc8ec53e9b/TCGA-N5-A4RT-01Z-00-DX2.48015BD4-1202-443B-96C8-934A9C77309D.svs 66182 38850 0 +/data/TCGA/381ff4ff-9a60-43b2-9624-bcbc8ec53e9b/TCGA-N5-A4RT-01Z-00-DX2.48015BD4-1202-443B-96C8-934A9C77309D.svs 68267 26938 1 +/data/TCGA/381ff4ff-9a60-43b2-9624-bcbc8ec53e9b/TCGA-N5-A4RT-01Z-00-DX2.48015BD4-1202-443B-96C8-934A9C77309D.svs 57043 9591 2 +/data/TCGA/381ff4ff-9a60-43b2-9624-bcbc8ec53e9b/TCGA-N5-A4RT-01Z-00-DX2.48015BD4-1202-443B-96C8-934A9C77309D.svs 28590 60010 3 +/data/TCGA/4edebcb7-cb76-430d-84af-1ca2a9021533/TCGA-EB-A42Y-01Z-00-DX1.C2F1ACDE-A147-4CAD-AB46-B1A4632BB4A7.svs 47473 21487 0 +/data/TCGA/4edebcb7-cb76-430d-84af-1ca2a9021533/TCGA-EB-A42Y-01Z-00-DX1.C2F1ACDE-A147-4CAD-AB46-B1A4632BB4A7.svs 36185 38054 1 +/data/TCGA/4edebcb7-cb76-430d-84af-1ca2a9021533/TCGA-EB-A42Y-01Z-00-DX1.C2F1ACDE-A147-4CAD-AB46-B1A4632BB4A7.svs 42319 13160 2 +/data/TCGA/4edebcb7-cb76-430d-84af-1ca2a9021533/TCGA-EB-A42Y-01Z-00-DX1.C2F1ACDE-A147-4CAD-AB46-B1A4632BB4A7.svs 11888 13103 3 +/data/TCGA/ee9551ec-bd8f-4117-b999-c2b135d2175b/TCGA-G7-6796-01Z-00-DX1.ec889984-0ec3-44fe-99ae-a8f3ddcf5e52.svs 32684 21378 0 +/data/TCGA/ee9551ec-bd8f-4117-b999-c2b135d2175b/TCGA-G7-6796-01Z-00-DX1.ec889984-0ec3-44fe-99ae-a8f3ddcf5e52.svs 70466 56508 1 +/data/TCGA/ee9551ec-bd8f-4117-b999-c2b135d2175b/TCGA-G7-6796-01Z-00-DX1.ec889984-0ec3-44fe-99ae-a8f3ddcf5e52.svs 10547 29509 2 +/data/TCGA/ee9551ec-bd8f-4117-b999-c2b135d2175b/TCGA-G7-6796-01Z-00-DX1.ec889984-0ec3-44fe-99ae-a8f3ddcf5e52.svs 12262 31184 3 +/data/TCGA/891c5178-53ba-496f-9025-fd20056e65a5/TCGA-E2-A10B-01Z-00-DX1.148CFC4B-EE65-4A7E-918F-10C72F37CB0F.svs 30776 46670 0 +/data/TCGA/891c5178-53ba-496f-9025-fd20056e65a5/TCGA-E2-A10B-01Z-00-DX1.148CFC4B-EE65-4A7E-918F-10C72F37CB0F.svs 36715 24375 1 +/data/TCGA/891c5178-53ba-496f-9025-fd20056e65a5/TCGA-E2-A10B-01Z-00-DX1.148CFC4B-EE65-4A7E-918F-10C72F37CB0F.svs 25253 40952 2 +/data/TCGA/891c5178-53ba-496f-9025-fd20056e65a5/TCGA-E2-A10B-01Z-00-DX1.148CFC4B-EE65-4A7E-918F-10C72F37CB0F.svs 27591 23508 3 +/data/TCGA/af8514a9-7cf5-415f-8899-47c7d94add86/TCGA-QQ-A8VH-01Z-00-DX1.7DD6E80A-C8BD-4114-84B3-995457D756A8.svs 18274 16382 0 +/data/TCGA/af8514a9-7cf5-415f-8899-47c7d94add86/TCGA-QQ-A8VH-01Z-00-DX1.7DD6E80A-C8BD-4114-84B3-995457D756A8.svs 28655 46286 1 +/data/TCGA/af8514a9-7cf5-415f-8899-47c7d94add86/TCGA-QQ-A8VH-01Z-00-DX1.7DD6E80A-C8BD-4114-84B3-995457D756A8.svs 26640 36816 2 +/data/TCGA/af8514a9-7cf5-415f-8899-47c7d94add86/TCGA-QQ-A8VH-01Z-00-DX1.7DD6E80A-C8BD-4114-84B3-995457D756A8.svs 40345 23292 3 +/data/TCGA/7c5e53a9-764b-4772-bef1-ef06c54b1770/TCGA-50-5942-01Z-00-DX1.da1b1274-8740-4c79-adf9-25800913eafa.svs 51693 7966 0 +/data/TCGA/7c5e53a9-764b-4772-bef1-ef06c54b1770/TCGA-50-5942-01Z-00-DX1.da1b1274-8740-4c79-adf9-25800913eafa.svs 34553 66604 1 +/data/TCGA/7c5e53a9-764b-4772-bef1-ef06c54b1770/TCGA-50-5942-01Z-00-DX1.da1b1274-8740-4c79-adf9-25800913eafa.svs 43649 23289 2 +/data/TCGA/7c5e53a9-764b-4772-bef1-ef06c54b1770/TCGA-50-5942-01Z-00-DX1.da1b1274-8740-4c79-adf9-25800913eafa.svs 86272 40595 3 +/data/TCGA/ef497638-68a8-40f4-b321-61bd559c010b/TCGA-G4-6627-01Z-00-DX1.f23c6977-d0cb-4bc8-b373-4b1b73c331cc.svs 69791 54300 0 +/data/TCGA/ef497638-68a8-40f4-b321-61bd559c010b/TCGA-G4-6627-01Z-00-DX1.f23c6977-d0cb-4bc8-b373-4b1b73c331cc.svs 10887 23405 1 +/data/TCGA/ef497638-68a8-40f4-b321-61bd559c010b/TCGA-G4-6627-01Z-00-DX1.f23c6977-d0cb-4bc8-b373-4b1b73c331cc.svs 68850 40781 2 +/data/TCGA/ef497638-68a8-40f4-b321-61bd559c010b/TCGA-G4-6627-01Z-00-DX1.f23c6977-d0cb-4bc8-b373-4b1b73c331cc.svs 32624 8568 3 +/data/TCGA/4081ddff-9524-4699-b7aa-915f6b040823/TCGA-55-1594-01Z-00-DX1.bd90c500-7c0b-4c45-a3f7-2d9177384b1d.svs 62098 32460 0 +/data/TCGA/4081ddff-9524-4699-b7aa-915f6b040823/TCGA-55-1594-01Z-00-DX1.bd90c500-7c0b-4c45-a3f7-2d9177384b1d.svs 38439 10628 1 +/data/TCGA/4081ddff-9524-4699-b7aa-915f6b040823/TCGA-55-1594-01Z-00-DX1.bd90c500-7c0b-4c45-a3f7-2d9177384b1d.svs 52589 19578 2 +/data/TCGA/4081ddff-9524-4699-b7aa-915f6b040823/TCGA-55-1594-01Z-00-DX1.bd90c500-7c0b-4c45-a3f7-2d9177384b1d.svs 48487 37089 3 +/data/TCGA/e66ab28b-e0b1-47c5-b475-bcd3da2a7dc4/TCGA-VS-A9UO-01Z-00-DX1.7498BCE3-5878-47B3-A1E5-196C189C62DC.svs 27615 13625 0 +/data/TCGA/e66ab28b-e0b1-47c5-b475-bcd3da2a7dc4/TCGA-VS-A9UO-01Z-00-DX1.7498BCE3-5878-47B3-A1E5-196C189C62DC.svs 27828 17299 1 +/data/TCGA/e66ab28b-e0b1-47c5-b475-bcd3da2a7dc4/TCGA-VS-A9UO-01Z-00-DX1.7498BCE3-5878-47B3-A1E5-196C189C62DC.svs 24086 13202 2 +/data/TCGA/93f7f4a8-0e3b-413f-bfc5-f663c6204b5d/TCGA-PK-A5HB-01Z-00-DX1.B51AC518-872A-462B-B4AB-EA2876CB5FAF.svs 45525 30239 0 +/data/TCGA/93f7f4a8-0e3b-413f-bfc5-f663c6204b5d/TCGA-PK-A5HB-01Z-00-DX1.B51AC518-872A-462B-B4AB-EA2876CB5FAF.svs 48266 39721 1 +/data/TCGA/93f7f4a8-0e3b-413f-bfc5-f663c6204b5d/TCGA-PK-A5HB-01Z-00-DX1.B51AC518-872A-462B-B4AB-EA2876CB5FAF.svs 59874 24309 2 +/data/TCGA/93f7f4a8-0e3b-413f-bfc5-f663c6204b5d/TCGA-PK-A5HB-01Z-00-DX1.B51AC518-872A-462B-B4AB-EA2876CB5FAF.svs 16041 36048 3 +/data/TCGA/e4f548d7-e4ab-4723-8619-b07e1dab10aa/TCGA-HU-8244-01Z-00-DX1.EF15C805-A823-46EA-B737-2EC4A8C5C278.svs 39596 34354 0 +/data/TCGA/e4f548d7-e4ab-4723-8619-b07e1dab10aa/TCGA-HU-8244-01Z-00-DX1.EF15C805-A823-46EA-B737-2EC4A8C5C278.svs 9398 35247 1 +/data/TCGA/e4f548d7-e4ab-4723-8619-b07e1dab10aa/TCGA-HU-8244-01Z-00-DX1.EF15C805-A823-46EA-B737-2EC4A8C5C278.svs 7318 36742 2 +/data/TCGA/9c2edb86-66e1-405a-8e04-d285e7a2dbee/TCGA-FG-A4MX-01Z-00-DX1.64CE3174-2194-461A-AD83-D0CF49FD27EF.svs 14232 50509 0 +/data/TCGA/9c2edb86-66e1-405a-8e04-d285e7a2dbee/TCGA-FG-A4MX-01Z-00-DX1.64CE3174-2194-461A-AD83-D0CF49FD27EF.svs 16584 46163 1 +/data/TCGA/9c2edb86-66e1-405a-8e04-d285e7a2dbee/TCGA-FG-A4MX-01Z-00-DX1.64CE3174-2194-461A-AD83-D0CF49FD27EF.svs 145751 27821 2 +/data/TCGA/9c2edb86-66e1-405a-8e04-d285e7a2dbee/TCGA-FG-A4MX-01Z-00-DX1.64CE3174-2194-461A-AD83-D0CF49FD27EF.svs 105936 62501 3 +/data/TCGA/150c8041-3a15-426c-bbef-8830a8da06c2/TCGA-BH-A0HP-01Z-00-DX1.F1FF6E88-B2D1-40AA-8373-1714D82E666F.svs 55547 72866 0 +/data/TCGA/150c8041-3a15-426c-bbef-8830a8da06c2/TCGA-BH-A0HP-01Z-00-DX1.F1FF6E88-B2D1-40AA-8373-1714D82E666F.svs 26395 59407 1 +/data/TCGA/150c8041-3a15-426c-bbef-8830a8da06c2/TCGA-BH-A0HP-01Z-00-DX1.F1FF6E88-B2D1-40AA-8373-1714D82E666F.svs 41131 79955 2 +/data/TCGA/150c8041-3a15-426c-bbef-8830a8da06c2/TCGA-BH-A0HP-01Z-00-DX1.F1FF6E88-B2D1-40AA-8373-1714D82E666F.svs 38230 77134 3 +/data/TCGA/b1a24a58-b288-4df4-a58e-c6300e4fca0d/TCGA-HT-7687-01Z-00-DX3.C372372B-F306-448E-9941-060D645A3BC5.svs 57415 11258 0 +/data/TCGA/b1a24a58-b288-4df4-a58e-c6300e4fca0d/TCGA-HT-7687-01Z-00-DX3.C372372B-F306-448E-9941-060D645A3BC5.svs 20592 8682 1 +/data/TCGA/b1a24a58-b288-4df4-a58e-c6300e4fca0d/TCGA-HT-7687-01Z-00-DX3.C372372B-F306-448E-9941-060D645A3BC5.svs 10439 10400 2 +/data/TCGA/c2f9b024-ebbf-435c-aaca-596f17c5516c/TCGA-14-1795-01Z-00-DX6.9e3232ce-11f2-4851-92ff-7386d5065b4d.svs 16081 9628 0 +/data/TCGA/c2f9b024-ebbf-435c-aaca-596f17c5516c/TCGA-14-1795-01Z-00-DX6.9e3232ce-11f2-4851-92ff-7386d5065b4d.svs 34007 20816 1 +/data/TCGA/c2f9b024-ebbf-435c-aaca-596f17c5516c/TCGA-14-1795-01Z-00-DX6.9e3232ce-11f2-4851-92ff-7386d5065b4d.svs 9112 14635 2 +/data/TCGA/5b5c1a70-79e9-4732-b24a-f5df9aceb976/TCGA-DX-A8BG-01Z-00-DX5.83323B32-772F-42DA-B4FE-69FA017B01BF.svs 29469 43212 0 +/data/TCGA/5b5c1a70-79e9-4732-b24a-f5df9aceb976/TCGA-DX-A8BG-01Z-00-DX5.83323B32-772F-42DA-B4FE-69FA017B01BF.svs 39935 38532 1 +/data/TCGA/5b5c1a70-79e9-4732-b24a-f5df9aceb976/TCGA-DX-A8BG-01Z-00-DX5.83323B32-772F-42DA-B4FE-69FA017B01BF.svs 71947 50791 2 +/data/TCGA/5b5c1a70-79e9-4732-b24a-f5df9aceb976/TCGA-DX-A8BG-01Z-00-DX5.83323B32-772F-42DA-B4FE-69FA017B01BF.svs 45543 27129 3 +/data/TCGA/aef825ae-1b7a-4f6e-9c91-0875301eee06/TCGA-EW-A1OW-01Z-00-DX1.97888686-EBB6-4B13-AB5D-452F475E865B.svs 20500 24701 0 +/data/TCGA/aef825ae-1b7a-4f6e-9c91-0875301eee06/TCGA-EW-A1OW-01Z-00-DX1.97888686-EBB6-4B13-AB5D-452F475E865B.svs 35122 35874 1 +/data/TCGA/aef825ae-1b7a-4f6e-9c91-0875301eee06/TCGA-EW-A1OW-01Z-00-DX1.97888686-EBB6-4B13-AB5D-452F475E865B.svs 96370 21906 2 +/data/TCGA/aef825ae-1b7a-4f6e-9c91-0875301eee06/TCGA-EW-A1OW-01Z-00-DX1.97888686-EBB6-4B13-AB5D-452F475E865B.svs 36861 36527 3 +/data/TCGA/40f322e3-ce5c-4990-87fe-da2de6cb7a48/TCGA-DJ-A2Q9-01Z-00-DX1.75717084-0627-47F0-91DF-66B5BE73F667.svs 29831 43109 0 +/data/TCGA/40f322e3-ce5c-4990-87fe-da2de6cb7a48/TCGA-DJ-A2Q9-01Z-00-DX1.75717084-0627-47F0-91DF-66B5BE73F667.svs 65697 40485 1 +/data/TCGA/40f322e3-ce5c-4990-87fe-da2de6cb7a48/TCGA-DJ-A2Q9-01Z-00-DX1.75717084-0627-47F0-91DF-66B5BE73F667.svs 9722 58578 2 +/data/TCGA/40f322e3-ce5c-4990-87fe-da2de6cb7a48/TCGA-DJ-A2Q9-01Z-00-DX1.75717084-0627-47F0-91DF-66B5BE73F667.svs 61217 20418 3 +/data/TCGA/e1072fe7-d1c9-4a70-be92-cbb111223d98/TCGA-G4-6310-01Z-00-DX1.b88472d4-3adc-4e4d-b0f2-0dc195a3d7df.svs 20736 48745 0 +/data/TCGA/e1072fe7-d1c9-4a70-be92-cbb111223d98/TCGA-G4-6310-01Z-00-DX1.b88472d4-3adc-4e4d-b0f2-0dc195a3d7df.svs 23668 5357 1 +/data/TCGA/e1072fe7-d1c9-4a70-be92-cbb111223d98/TCGA-G4-6310-01Z-00-DX1.b88472d4-3adc-4e4d-b0f2-0dc195a3d7df.svs 54088 64213 2 +/data/TCGA/e1072fe7-d1c9-4a70-be92-cbb111223d98/TCGA-G4-6310-01Z-00-DX1.b88472d4-3adc-4e4d-b0f2-0dc195a3d7df.svs 69775 22628 3 +/data/TCGA/dab5e817-d4bc-4c9d-a3d2-65eab664244d/TCGA-12-0822-01Z-00-DX3.2AB8F5AD-CAD0-4680-B537-AC7A8F05A83E.svs 48158 18055 0 +/data/TCGA/dab5e817-d4bc-4c9d-a3d2-65eab664244d/TCGA-12-0822-01Z-00-DX3.2AB8F5AD-CAD0-4680-B537-AC7A8F05A83E.svs 11841 20533 1 +/data/TCGA/dab5e817-d4bc-4c9d-a3d2-65eab664244d/TCGA-12-0822-01Z-00-DX3.2AB8F5AD-CAD0-4680-B537-AC7A8F05A83E.svs 50784 22708 2 +/data/TCGA/6b40e885-cfe3-4187-9eec-f6685cff4f2f/TCGA-06-0190-01Z-00-DX1.84da294a-81f2-4820-b72e-f084769f771a.svs 22831 8743 0 +/data/TCGA/6b40e885-cfe3-4187-9eec-f6685cff4f2f/TCGA-06-0190-01Z-00-DX1.84da294a-81f2-4820-b72e-f084769f771a.svs 25353 13295 1 +/data/TCGA/6b40e885-cfe3-4187-9eec-f6685cff4f2f/TCGA-06-0190-01Z-00-DX1.84da294a-81f2-4820-b72e-f084769f771a.svs 12289 4054 2 +/data/TCGA/e29c2533-854e-49de-b91e-7de0d43b1fa4/TCGA-CC-A7IK-01Z-00-DX1.AE013D44-A3C6-407B-A295-7E82DBB41C27.svs 17190 19891 0 +/data/TCGA/e29c2533-854e-49de-b91e-7de0d43b1fa4/TCGA-CC-A7IK-01Z-00-DX1.AE013D44-A3C6-407B-A295-7E82DBB41C27.svs 34825 47669 1 +/data/TCGA/e29c2533-854e-49de-b91e-7de0d43b1fa4/TCGA-CC-A7IK-01Z-00-DX1.AE013D44-A3C6-407B-A295-7E82DBB41C27.svs 30831 42681 2 +/data/TCGA/e29c2533-854e-49de-b91e-7de0d43b1fa4/TCGA-CC-A7IK-01Z-00-DX1.AE013D44-A3C6-407B-A295-7E82DBB41C27.svs 43367 29500 3 +/data/TCGA/71593122-8cc3-4ab3-8c74-bfb8151dc2b2/TCGA-F7-A622-01Z-00-DX1.CF21E24C-ADA4-49B6-B064-A22CAC2BA770.svs 31766 30893 0 +/data/TCGA/71593122-8cc3-4ab3-8c74-bfb8151dc2b2/TCGA-F7-A622-01Z-00-DX1.CF21E24C-ADA4-49B6-B064-A22CAC2BA770.svs 32640 22314 1 +/data/TCGA/71593122-8cc3-4ab3-8c74-bfb8151dc2b2/TCGA-F7-A622-01Z-00-DX1.CF21E24C-ADA4-49B6-B064-A22CAC2BA770.svs 33458 27224 2 +/data/TCGA/71593122-8cc3-4ab3-8c74-bfb8151dc2b2/TCGA-F7-A622-01Z-00-DX1.CF21E24C-ADA4-49B6-B064-A22CAC2BA770.svs 29878 37082 3 +/data/TCGA/70f3a255-94cc-4107-817c-333363f294ef/TCGA-D9-A149-01Z-00-DX1.D6073E77-0039-41F9-A1C7-F599188585B0.svs 48331 40692 0 +/data/TCGA/70f3a255-94cc-4107-817c-333363f294ef/TCGA-D9-A149-01Z-00-DX1.D6073E77-0039-41F9-A1C7-F599188585B0.svs 67212 30232 1 +/data/TCGA/70f3a255-94cc-4107-817c-333363f294ef/TCGA-D9-A149-01Z-00-DX1.D6073E77-0039-41F9-A1C7-F599188585B0.svs 74157 22287 2 +/data/TCGA/70f3a255-94cc-4107-817c-333363f294ef/TCGA-D9-A149-01Z-00-DX1.D6073E77-0039-41F9-A1C7-F599188585B0.svs 40629 17751 3 +/data/TCGA/7544f41b-9c23-4a8f-902c-797b5e92fd23/TCGA-NC-A5HR-01Z-00-DX1.B8B85EDD-96A6-40DF-B3BF-C97311A7E552.svs 9798 54888 0 +/data/TCGA/7544f41b-9c23-4a8f-902c-797b5e92fd23/TCGA-NC-A5HR-01Z-00-DX1.B8B85EDD-96A6-40DF-B3BF-C97311A7E552.svs 72429 55518 1 +/data/TCGA/7544f41b-9c23-4a8f-902c-797b5e92fd23/TCGA-NC-A5HR-01Z-00-DX1.B8B85EDD-96A6-40DF-B3BF-C97311A7E552.svs 49688 20525 2 +/data/TCGA/7544f41b-9c23-4a8f-902c-797b5e92fd23/TCGA-NC-A5HR-01Z-00-DX1.B8B85EDD-96A6-40DF-B3BF-C97311A7E552.svs 29310 20104 3 +/data/TCGA/a138445d-9748-4939-92a7-d304b4618006/TCGA-4X-A9F9-01Z-00-DX3.ACAF8A74-7AD6-4D40-9A4D-EB2B247EDB97.svs 48663 62049 0 +/data/TCGA/a138445d-9748-4939-92a7-d304b4618006/TCGA-4X-A9F9-01Z-00-DX3.ACAF8A74-7AD6-4D40-9A4D-EB2B247EDB97.svs 12124 49261 1 +/data/TCGA/a138445d-9748-4939-92a7-d304b4618006/TCGA-4X-A9F9-01Z-00-DX3.ACAF8A74-7AD6-4D40-9A4D-EB2B247EDB97.svs 73224 9315 2 +/data/TCGA/a138445d-9748-4939-92a7-d304b4618006/TCGA-4X-A9F9-01Z-00-DX3.ACAF8A74-7AD6-4D40-9A4D-EB2B247EDB97.svs 55855 5465 3 +/data/TCGA/9166d89a-e776-49b2-aee5-eff5949e0aca/TCGA-RW-A8AZ-01Z-00-DX1.D89C6042-8CBB-4669-B89A-32B6CAFACD7A.svs 14416 50554 0 +/data/TCGA/9166d89a-e776-49b2-aee5-eff5949e0aca/TCGA-RW-A8AZ-01Z-00-DX1.D89C6042-8CBB-4669-B89A-32B6CAFACD7A.svs 56693 51503 1 +/data/TCGA/9166d89a-e776-49b2-aee5-eff5949e0aca/TCGA-RW-A8AZ-01Z-00-DX1.D89C6042-8CBB-4669-B89A-32B6CAFACD7A.svs 21943 57234 2 +/data/TCGA/9166d89a-e776-49b2-aee5-eff5949e0aca/TCGA-RW-A8AZ-01Z-00-DX1.D89C6042-8CBB-4669-B89A-32B6CAFACD7A.svs 81567 60018 3 +/data/TCGA/72f064bc-eeac-425f-b29c-865f774fdc27/TCGA-XF-A8HE-01Z-00-DX1.A0E05485-2A24-4BD0-8B2F-E0D9641ADD9F.svs 80678 6262 0 +/data/TCGA/72f064bc-eeac-425f-b29c-865f774fdc27/TCGA-XF-A8HE-01Z-00-DX1.A0E05485-2A24-4BD0-8B2F-E0D9641ADD9F.svs 51628 32840 1 +/data/TCGA/72f064bc-eeac-425f-b29c-865f774fdc27/TCGA-XF-A8HE-01Z-00-DX1.A0E05485-2A24-4BD0-8B2F-E0D9641ADD9F.svs 25395 19432 2 +/data/TCGA/72f064bc-eeac-425f-b29c-865f774fdc27/TCGA-XF-A8HE-01Z-00-DX1.A0E05485-2A24-4BD0-8B2F-E0D9641ADD9F.svs 30518 35712 3 +/data/TCGA/ebc5b05f-63d9-4899-b2b0-b4c454d9610e/TCGA-DW-7842-01Z-00-DX1.939166CE-37A9-4906-8D45-E10C2EEE3CA3.svs 41952 3071 0 +/data/TCGA/ebc5b05f-63d9-4899-b2b0-b4c454d9610e/TCGA-DW-7842-01Z-00-DX1.939166CE-37A9-4906-8D45-E10C2EEE3CA3.svs 50895 57482 1 +/data/TCGA/ebc5b05f-63d9-4899-b2b0-b4c454d9610e/TCGA-DW-7842-01Z-00-DX1.939166CE-37A9-4906-8D45-E10C2EEE3CA3.svs 76085 42721 2 +/data/TCGA/ebc5b05f-63d9-4899-b2b0-b4c454d9610e/TCGA-DW-7842-01Z-00-DX1.939166CE-37A9-4906-8D45-E10C2EEE3CA3.svs 38230 36136 3 +/data/TCGA/51821122-a967-4436-a836-d9f44af16d0a/TCGA-A8-A07E-01Z-00-DX1.AC684481-979A-46F9-91D7-C56CE85992F2.svs 38596 71690 0 +/data/TCGA/51821122-a967-4436-a836-d9f44af16d0a/TCGA-A8-A07E-01Z-00-DX1.AC684481-979A-46F9-91D7-C56CE85992F2.svs 41125 7223 1 +/data/TCGA/51821122-a967-4436-a836-d9f44af16d0a/TCGA-A8-A07E-01Z-00-DX1.AC684481-979A-46F9-91D7-C56CE85992F2.svs 49731 88376 2 +/data/TCGA/51821122-a967-4436-a836-d9f44af16d0a/TCGA-A8-A07E-01Z-00-DX1.AC684481-979A-46F9-91D7-C56CE85992F2.svs 38493 73885 3 +/data/TCGA/9d4f11ce-4e20-4e4f-92c6-cd039ca7973d/TCGA-A6-2685-01Z-00-DX1.c69e23f4-34c9-41ff-a037-44bf7bbf33cd.svs 105200 15149 0 +/data/TCGA/9d4f11ce-4e20-4e4f-92c6-cd039ca7973d/TCGA-A6-2685-01Z-00-DX1.c69e23f4-34c9-41ff-a037-44bf7bbf33cd.svs 26517 11374 1 +/data/TCGA/9d4f11ce-4e20-4e4f-92c6-cd039ca7973d/TCGA-A6-2685-01Z-00-DX1.c69e23f4-34c9-41ff-a037-44bf7bbf33cd.svs 22219 8632 2 +/data/TCGA/9d4f11ce-4e20-4e4f-92c6-cd039ca7973d/TCGA-A6-2685-01Z-00-DX1.c69e23f4-34c9-41ff-a037-44bf7bbf33cd.svs 82079 8483 3 +/data/TCGA/98707209-72ca-4cb7-b569-3314bd5d53be/TCGA-EA-A3QD-01Z-00-DX1.247BDFE4-6352-4531-83CC-D30D5945CAE2.svs 42003 27533 0 +/data/TCGA/98707209-72ca-4cb7-b569-3314bd5d53be/TCGA-EA-A3QD-01Z-00-DX1.247BDFE4-6352-4531-83CC-D30D5945CAE2.svs 21648 27540 1 +/data/TCGA/98707209-72ca-4cb7-b569-3314bd5d53be/TCGA-EA-A3QD-01Z-00-DX1.247BDFE4-6352-4531-83CC-D30D5945CAE2.svs 54904 34850 2 +/data/TCGA/98707209-72ca-4cb7-b569-3314bd5d53be/TCGA-EA-A3QD-01Z-00-DX1.247BDFE4-6352-4531-83CC-D30D5945CAE2.svs 63699 31538 3 +/data/TCGA/491bb407-83b9-4662-b0b2-f96e0b1a5ce6/TCGA-M7-A723-01Z-00-DX1.D1CDCC7C-F5AB-4FB7-A889-F8AFFC071EF3.svs 116628 10635 0 +/data/TCGA/491bb407-83b9-4662-b0b2-f96e0b1a5ce6/TCGA-M7-A723-01Z-00-DX1.D1CDCC7C-F5AB-4FB7-A889-F8AFFC071EF3.svs 103896 25239 1 +/data/TCGA/491bb407-83b9-4662-b0b2-f96e0b1a5ce6/TCGA-M7-A723-01Z-00-DX1.D1CDCC7C-F5AB-4FB7-A889-F8AFFC071EF3.svs 122197 21657 2 +/data/TCGA/491bb407-83b9-4662-b0b2-f96e0b1a5ce6/TCGA-M7-A723-01Z-00-DX1.D1CDCC7C-F5AB-4FB7-A889-F8AFFC071EF3.svs 99876 39013 3 +/data/TCGA/7c5f44ba-5812-4c77-b088-d8656e6d04ab/TCGA-B4-5832-01Z-00-DX1.0ED42E9A-83D1-4008-B775-A934E06D2629.svs 50593 37712 0 +/data/TCGA/7c5f44ba-5812-4c77-b088-d8656e6d04ab/TCGA-B4-5832-01Z-00-DX1.0ED42E9A-83D1-4008-B775-A934E06D2629.svs 55554 21426 1 +/data/TCGA/7c5f44ba-5812-4c77-b088-d8656e6d04ab/TCGA-B4-5832-01Z-00-DX1.0ED42E9A-83D1-4008-B775-A934E06D2629.svs 14141 24913 2 +/data/TCGA/7c5f44ba-5812-4c77-b088-d8656e6d04ab/TCGA-B4-5832-01Z-00-DX1.0ED42E9A-83D1-4008-B775-A934E06D2629.svs 19038 5960 3 +/data/TCGA/87f0ecc4-584b-42b0-b4d4-7f5a4bf98f5b/TCGA-C4-A0F0-01Z-00-DX1.8EBBC2EF-DA6F-4901-838D-C1AC80E83E92.svs 36170 50010 0 +/data/TCGA/87f0ecc4-584b-42b0-b4d4-7f5a4bf98f5b/TCGA-C4-A0F0-01Z-00-DX1.8EBBC2EF-DA6F-4901-838D-C1AC80E83E92.svs 12909 23142 1 +/data/TCGA/87f0ecc4-584b-42b0-b4d4-7f5a4bf98f5b/TCGA-C4-A0F0-01Z-00-DX1.8EBBC2EF-DA6F-4901-838D-C1AC80E83E92.svs 29762 25536 2 +/data/TCGA/87f0ecc4-584b-42b0-b4d4-7f5a4bf98f5b/TCGA-C4-A0F0-01Z-00-DX1.8EBBC2EF-DA6F-4901-838D-C1AC80E83E92.svs 31751 21950 3 +/data/TCGA/ce057ce4-d194-4189-a91a-981962a7e354/TCGA-86-7714-01Z-00-DX1.8ee03c3b-013e-4dd5-aa0e-9c1a771cbdc5.svs 17692 43788 0 +/data/TCGA/ce057ce4-d194-4189-a91a-981962a7e354/TCGA-86-7714-01Z-00-DX1.8ee03c3b-013e-4dd5-aa0e-9c1a771cbdc5.svs 24937 50298 1 +/data/TCGA/ce057ce4-d194-4189-a91a-981962a7e354/TCGA-86-7714-01Z-00-DX1.8ee03c3b-013e-4dd5-aa0e-9c1a771cbdc5.svs 30790 23986 2 +/data/TCGA/ce057ce4-d194-4189-a91a-981962a7e354/TCGA-86-7714-01Z-00-DX1.8ee03c3b-013e-4dd5-aa0e-9c1a771cbdc5.svs 32820 48150 3 +/data/TCGA/11149513-0440-4c1e-a1d6-d326019f0bca/TCGA-HT-7609-01Z-00-DX1.8989643C-6505-468E-BEE4-8F105D4CE4A0.svs 37123 3936 0 +/data/TCGA/11149513-0440-4c1e-a1d6-d326019f0bca/TCGA-HT-7609-01Z-00-DX1.8989643C-6505-468E-BEE4-8F105D4CE4A0.svs 34683 23135 1 +/data/TCGA/11149513-0440-4c1e-a1d6-d326019f0bca/TCGA-HT-7609-01Z-00-DX1.8989643C-6505-468E-BEE4-8F105D4CE4A0.svs 45411 18649 2 +/data/TCGA/11149513-0440-4c1e-a1d6-d326019f0bca/TCGA-HT-7609-01Z-00-DX1.8989643C-6505-468E-BEE4-8F105D4CE4A0.svs 12869 29269 3 +/data/TCGA/c2d4d931-50d6-489b-9e5f-860dbe8bf43a/TCGA-J4-A83L-01Z-00-DX1.A9CB32A5-187C-4DC4-BAF5-84F57309DEE1.svs 74858 14401 0 +/data/TCGA/c2d4d931-50d6-489b-9e5f-860dbe8bf43a/TCGA-J4-A83L-01Z-00-DX1.A9CB32A5-187C-4DC4-BAF5-84F57309DEE1.svs 28159 24091 1 +/data/TCGA/c2d4d931-50d6-489b-9e5f-860dbe8bf43a/TCGA-J4-A83L-01Z-00-DX1.A9CB32A5-187C-4DC4-BAF5-84F57309DEE1.svs 36176 12447 2 +/data/TCGA/c2d4d931-50d6-489b-9e5f-860dbe8bf43a/TCGA-J4-A83L-01Z-00-DX1.A9CB32A5-187C-4DC4-BAF5-84F57309DEE1.svs 61565 48377 3 +/data/TCGA/946f99c0-0bd8-4b9e-80bf-72d838ee742b/TCGA-B0-5084-01Z-00-DX1.550d2568-2aa9-42c8-9b21-fd66aea9c809.svs 32885 18266 0 +/data/TCGA/946f99c0-0bd8-4b9e-80bf-72d838ee742b/TCGA-B0-5084-01Z-00-DX1.550d2568-2aa9-42c8-9b21-fd66aea9c809.svs 13838 13792 1 +/data/TCGA/946f99c0-0bd8-4b9e-80bf-72d838ee742b/TCGA-B0-5084-01Z-00-DX1.550d2568-2aa9-42c8-9b21-fd66aea9c809.svs 45133 37855 2 +/data/TCGA/946f99c0-0bd8-4b9e-80bf-72d838ee742b/TCGA-B0-5084-01Z-00-DX1.550d2568-2aa9-42c8-9b21-fd66aea9c809.svs 33465 51037 3 +/data/TCGA/ad9fc3d4-e33f-4cc3-9e0b-c5f5d46f79d4/TCGA-FJ-A871-01Z-00-DX2.B09F27BF-6786-4CC7-8471-5A73E048A813.svs 31313 12569 0 +/data/TCGA/ad9fc3d4-e33f-4cc3-9e0b-c5f5d46f79d4/TCGA-FJ-A871-01Z-00-DX2.B09F27BF-6786-4CC7-8471-5A73E048A813.svs 95433 52610 1 +/data/TCGA/ad9fc3d4-e33f-4cc3-9e0b-c5f5d46f79d4/TCGA-FJ-A871-01Z-00-DX2.B09F27BF-6786-4CC7-8471-5A73E048A813.svs 61611 25329 2 +/data/TCGA/ad9fc3d4-e33f-4cc3-9e0b-c5f5d46f79d4/TCGA-FJ-A871-01Z-00-DX2.B09F27BF-6786-4CC7-8471-5A73E048A813.svs 56145 38304 3 +/data/TCGA/c12ad2f1-a5bb-46d4-8d13-d1df08842274/TCGA-V4-A9E5-01Z-00-DX1.97279EE1-33FD-46C7-95B3-0E4065DF3069.svs 78726 59389 0 +/data/TCGA/c12ad2f1-a5bb-46d4-8d13-d1df08842274/TCGA-V4-A9E5-01Z-00-DX1.97279EE1-33FD-46C7-95B3-0E4065DF3069.svs 56896 66040 1 +/data/TCGA/c12ad2f1-a5bb-46d4-8d13-d1df08842274/TCGA-V4-A9E5-01Z-00-DX1.97279EE1-33FD-46C7-95B3-0E4065DF3069.svs 9313 51711 2 +/data/TCGA/c12ad2f1-a5bb-46d4-8d13-d1df08842274/TCGA-V4-A9E5-01Z-00-DX1.97279EE1-33FD-46C7-95B3-0E4065DF3069.svs 7003 55343 3 +/data/TCGA/4796b44a-fc7b-41ac-abd6-e7ba53baed07/TCGA-YL-A8SB-01Z-00-DX1.6E3A9961-7A7E-456F-B703-4920FCC79425.svs 23898 52414 0 +/data/TCGA/4796b44a-fc7b-41ac-abd6-e7ba53baed07/TCGA-YL-A8SB-01Z-00-DX1.6E3A9961-7A7E-456F-B703-4920FCC79425.svs 81411 57995 1 +/data/TCGA/4796b44a-fc7b-41ac-abd6-e7ba53baed07/TCGA-YL-A8SB-01Z-00-DX1.6E3A9961-7A7E-456F-B703-4920FCC79425.svs 36558 69538 2 +/data/TCGA/4796b44a-fc7b-41ac-abd6-e7ba53baed07/TCGA-YL-A8SB-01Z-00-DX1.6E3A9961-7A7E-456F-B703-4920FCC79425.svs 688 50889 3 +/data/TCGA/2be84a20-b9e6-432d-8150-ebb727eb7076/TCGA-08-0522-01Z-00-DX1.821f6127-4e41-4f66-b8b5-28ddfb6b77ec.svs 14743 9503 0 +/data/TCGA/2be84a20-b9e6-432d-8150-ebb727eb7076/TCGA-08-0522-01Z-00-DX1.821f6127-4e41-4f66-b8b5-28ddfb6b77ec.svs 9194 10430 1 +/data/TCGA/2be84a20-b9e6-432d-8150-ebb727eb7076/TCGA-08-0522-01Z-00-DX1.821f6127-4e41-4f66-b8b5-28ddfb6b77ec.svs 28248 14973 2 +/data/TCGA/74f35e5c-43ef-4fc5-b6b9-c5b052bf4bc9/TCGA-06-0173-01Z-00-DX1.b7d1b579-797f-4364-bd7d-29522b4fb6aa.svs 4332 5714 0 +/data/TCGA/74f35e5c-43ef-4fc5-b6b9-c5b052bf4bc9/TCGA-06-0173-01Z-00-DX1.b7d1b579-797f-4364-bd7d-29522b4fb6aa.svs 4245 989 1 +/data/TCGA/20ad64a7-07db-4604-80d4-0eaefc237beb/TCGA-MH-A560-01Z-00-DX2.FE12791C-8C7D-4FF6-B79C-EA9D2B3B784F.svs 62055 62863 0 +/data/TCGA/20ad64a7-07db-4604-80d4-0eaefc237beb/TCGA-MH-A560-01Z-00-DX2.FE12791C-8C7D-4FF6-B79C-EA9D2B3B784F.svs 66494 67288 1 +/data/TCGA/20ad64a7-07db-4604-80d4-0eaefc237beb/TCGA-MH-A560-01Z-00-DX2.FE12791C-8C7D-4FF6-B79C-EA9D2B3B784F.svs 32134 24016 2 +/data/TCGA/20ad64a7-07db-4604-80d4-0eaefc237beb/TCGA-MH-A560-01Z-00-DX2.FE12791C-8C7D-4FF6-B79C-EA9D2B3B784F.svs 56409 56663 3 +/data/TCGA/a03f451f-6207-46ab-810e-73a1f9dc929b/TCGA-VM-A8CD-01Z-00-DX2.355165A0-D1C3-4345-B151-B94591102389.svs 25912 67237 0 +/data/TCGA/a03f451f-6207-46ab-810e-73a1f9dc929b/TCGA-VM-A8CD-01Z-00-DX2.355165A0-D1C3-4345-B151-B94591102389.svs 27654 43135 1 +/data/TCGA/a03f451f-6207-46ab-810e-73a1f9dc929b/TCGA-VM-A8CD-01Z-00-DX2.355165A0-D1C3-4345-B151-B94591102389.svs 90391 24187 2 +/data/TCGA/a03f451f-6207-46ab-810e-73a1f9dc929b/TCGA-VM-A8CD-01Z-00-DX2.355165A0-D1C3-4345-B151-B94591102389.svs 32534 31477 3 +/data/TCGA/55011446-8b18-4b58-a46e-3644fe9bc5ed/TCGA-DX-AB2L-01Z-00-DXQ.F3F683DC-37F9-47C8-9AAA-766EE879AC46.svs 37043 36090 0 +/data/TCGA/55011446-8b18-4b58-a46e-3644fe9bc5ed/TCGA-DX-AB2L-01Z-00-DXQ.F3F683DC-37F9-47C8-9AAA-766EE879AC46.svs 16166 59408 1 +/data/TCGA/55011446-8b18-4b58-a46e-3644fe9bc5ed/TCGA-DX-AB2L-01Z-00-DXQ.F3F683DC-37F9-47C8-9AAA-766EE879AC46.svs 18200 38260 2 +/data/TCGA/55011446-8b18-4b58-a46e-3644fe9bc5ed/TCGA-DX-AB2L-01Z-00-DXQ.F3F683DC-37F9-47C8-9AAA-766EE879AC46.svs 39757 51255 3 +/data/TCGA/75404d14-a95b-4aa1-8613-c57b4dcc4f2d/TCGA-HC-7749-01Z-00-DX1.2dbf5d61-954d-406e-9cc3-f1590268597f.svs 5716 4681 0 +/data/TCGA/75404d14-a95b-4aa1-8613-c57b4dcc4f2d/TCGA-HC-7749-01Z-00-DX1.2dbf5d61-954d-406e-9cc3-f1590268597f.svs 11318 16667 1 +/data/TCGA/75404d14-a95b-4aa1-8613-c57b4dcc4f2d/TCGA-HC-7749-01Z-00-DX1.2dbf5d61-954d-406e-9cc3-f1590268597f.svs 8393 10267 2 +/data/TCGA/58fcf589-d4a1-4733-b8a9-75662b770465/TCGA-ED-A97K-01Z-00-DX1.C2B446BC-DD52-4BAE-A098-0FBDADC70445.svs 73149 61796 0 +/data/TCGA/58fcf589-d4a1-4733-b8a9-75662b770465/TCGA-ED-A97K-01Z-00-DX1.C2B446BC-DD52-4BAE-A098-0FBDADC70445.svs 81969 30601 1 +/data/TCGA/58fcf589-d4a1-4733-b8a9-75662b770465/TCGA-ED-A97K-01Z-00-DX1.C2B446BC-DD52-4BAE-A098-0FBDADC70445.svs 90849 74701 2 +/data/TCGA/58fcf589-d4a1-4733-b8a9-75662b770465/TCGA-ED-A97K-01Z-00-DX1.C2B446BC-DD52-4BAE-A098-0FBDADC70445.svs 66011 33727 3 +/data/TCGA/9302d288-11c3-4424-ae75-89f78ae41ec2/TCGA-G2-AA3C-01Z-00-DX2.00AE9115-F979-4DD6-8364-96493CC00835.svs 44275 29601 0 +/data/TCGA/9302d288-11c3-4424-ae75-89f78ae41ec2/TCGA-G2-AA3C-01Z-00-DX2.00AE9115-F979-4DD6-8364-96493CC00835.svs 125312 62732 1 +/data/TCGA/9302d288-11c3-4424-ae75-89f78ae41ec2/TCGA-G2-AA3C-01Z-00-DX2.00AE9115-F979-4DD6-8364-96493CC00835.svs 21732 42750 2 +/data/TCGA/9302d288-11c3-4424-ae75-89f78ae41ec2/TCGA-G2-AA3C-01Z-00-DX2.00AE9115-F979-4DD6-8364-96493CC00835.svs 51372 72155 3 +/data/TCGA/8879a1f5-b2e7-4540-bf47-48ee3a02ff2e/TCGA-ET-A3BS-01Z-00-DX1.2D1A6BE1-99C5-40C3-BD7C-8C064566368E.svs 76376 51268 0 +/data/TCGA/8879a1f5-b2e7-4540-bf47-48ee3a02ff2e/TCGA-ET-A3BS-01Z-00-DX1.2D1A6BE1-99C5-40C3-BD7C-8C064566368E.svs 62071 41305 1 +/data/TCGA/8879a1f5-b2e7-4540-bf47-48ee3a02ff2e/TCGA-ET-A3BS-01Z-00-DX1.2D1A6BE1-99C5-40C3-BD7C-8C064566368E.svs 76574 11524 2 +/data/TCGA/8879a1f5-b2e7-4540-bf47-48ee3a02ff2e/TCGA-ET-A3BS-01Z-00-DX1.2D1A6BE1-99C5-40C3-BD7C-8C064566368E.svs 14662 22317 3 +/data/TCGA/c713f828-2725-4901-a9fe-01d3192edc46/TCGA-GM-A2DB-01Z-00-DX1.9EE36AA6-2594-44C7-B05C-91A0AEC7E511.svs 35432 48249 0 +/data/TCGA/c713f828-2725-4901-a9fe-01d3192edc46/TCGA-GM-A2DB-01Z-00-DX1.9EE36AA6-2594-44C7-B05C-91A0AEC7E511.svs 32808 57302 1 +/data/TCGA/c713f828-2725-4901-a9fe-01d3192edc46/TCGA-GM-A2DB-01Z-00-DX1.9EE36AA6-2594-44C7-B05C-91A0AEC7E511.svs 34268 48749 2 +/data/TCGA/c713f828-2725-4901-a9fe-01d3192edc46/TCGA-GM-A2DB-01Z-00-DX1.9EE36AA6-2594-44C7-B05C-91A0AEC7E511.svs 10366 25409 3 +/data/TCGA/ea9736d6-504b-458a-9361-605ce755aef6/TCGA-NH-A6GC-01Z-00-DX1.29073D7E-5EEF-4BBA-96BE-DC8C69924C42.svs 29297 29996 0 +/data/TCGA/ea9736d6-504b-458a-9361-605ce755aef6/TCGA-NH-A6GC-01Z-00-DX1.29073D7E-5EEF-4BBA-96BE-DC8C69924C42.svs 29989 46176 1 +/data/TCGA/ea9736d6-504b-458a-9361-605ce755aef6/TCGA-NH-A6GC-01Z-00-DX1.29073D7E-5EEF-4BBA-96BE-DC8C69924C42.svs 73339 53901 2 +/data/TCGA/ea9736d6-504b-458a-9361-605ce755aef6/TCGA-NH-A6GC-01Z-00-DX1.29073D7E-5EEF-4BBA-96BE-DC8C69924C42.svs 66712 65702 3 +/data/TCGA/8068cf62-d990-4579-9a73-992a0f3a0082/TCGA-V4-A9F5-01Z-00-DX1.D02E1BC5-7BBC-4931-8E24-72FA101FA24B.svs 13890 25695 0 +/data/TCGA/8068cf62-d990-4579-9a73-992a0f3a0082/TCGA-V4-A9F5-01Z-00-DX1.D02E1BC5-7BBC-4931-8E24-72FA101FA24B.svs 77138 31568 1 +/data/TCGA/8068cf62-d990-4579-9a73-992a0f3a0082/TCGA-V4-A9F5-01Z-00-DX1.D02E1BC5-7BBC-4931-8E24-72FA101FA24B.svs 94625 19433 2 +/data/TCGA/8068cf62-d990-4579-9a73-992a0f3a0082/TCGA-V4-A9F5-01Z-00-DX1.D02E1BC5-7BBC-4931-8E24-72FA101FA24B.svs 69553 49214 3 +/data/TCGA/daf31e53-b707-4541-aae2-eb29946d5a5c/TCGA-QH-A6CV-01Z-00-DX1.9DCB8BF5-AE89-4D03-9892-F689B41320D0.svs 30866 18006 0 +/data/TCGA/daf31e53-b707-4541-aae2-eb29946d5a5c/TCGA-QH-A6CV-01Z-00-DX1.9DCB8BF5-AE89-4D03-9892-F689B41320D0.svs 36952 35326 1 +/data/TCGA/daf31e53-b707-4541-aae2-eb29946d5a5c/TCGA-QH-A6CV-01Z-00-DX1.9DCB8BF5-AE89-4D03-9892-F689B41320D0.svs 71790 14033 2 +/data/TCGA/daf31e53-b707-4541-aae2-eb29946d5a5c/TCGA-QH-A6CV-01Z-00-DX1.9DCB8BF5-AE89-4D03-9892-F689B41320D0.svs 45917 20732 3 +/data/TCGA/ed2368ec-6dc6-4903-b778-77fc3aa7ad1a/TCGA-OR-A5K0-01Z-00-DX4.CA7F8657-5621-4968-A143-E9CD061CF8AE.svs 20975 55795 0 +/data/TCGA/ed2368ec-6dc6-4903-b778-77fc3aa7ad1a/TCGA-OR-A5K0-01Z-00-DX4.CA7F8657-5621-4968-A143-E9CD061CF8AE.svs 99376 21966 1 +/data/TCGA/ed2368ec-6dc6-4903-b778-77fc3aa7ad1a/TCGA-OR-A5K0-01Z-00-DX4.CA7F8657-5621-4968-A143-E9CD061CF8AE.svs 43452 59179 2 +/data/TCGA/ed2368ec-6dc6-4903-b778-77fc3aa7ad1a/TCGA-OR-A5K0-01Z-00-DX4.CA7F8657-5621-4968-A143-E9CD061CF8AE.svs 108532 44861 3 +/data/TCGA/3e52975a-8523-4342-805c-d3ce3cb54d97/TCGA-B8-4619-01Z-00-DX1.2738922d-4a07-45b3-968b-83994e9a0ed6.svs 10091 42877 0 +/data/TCGA/3e52975a-8523-4342-805c-d3ce3cb54d97/TCGA-B8-4619-01Z-00-DX1.2738922d-4a07-45b3-968b-83994e9a0ed6.svs 8409 25031 1 +/data/TCGA/3e52975a-8523-4342-805c-d3ce3cb54d97/TCGA-B8-4619-01Z-00-DX1.2738922d-4a07-45b3-968b-83994e9a0ed6.svs 16906 31886 2 +/data/TCGA/3e52975a-8523-4342-805c-d3ce3cb54d97/TCGA-B8-4619-01Z-00-DX1.2738922d-4a07-45b3-968b-83994e9a0ed6.svs 20176 31353 3 +/data/TCGA/80366f20-13e0-4a39-9d66-b56ddc9076c4/TCGA-DJ-A3VF-01Z-00-DX1.96025060-08FB-457A-838B-008C081AA90C.svs 75680 48579 0 +/data/TCGA/80366f20-13e0-4a39-9d66-b56ddc9076c4/TCGA-DJ-A3VF-01Z-00-DX1.96025060-08FB-457A-838B-008C081AA90C.svs 34065 53002 1 +/data/TCGA/80366f20-13e0-4a39-9d66-b56ddc9076c4/TCGA-DJ-A3VF-01Z-00-DX1.96025060-08FB-457A-838B-008C081AA90C.svs 106143 24330 2 +/data/TCGA/80366f20-13e0-4a39-9d66-b56ddc9076c4/TCGA-DJ-A3VF-01Z-00-DX1.96025060-08FB-457A-838B-008C081AA90C.svs 23327 43324 3 +/data/TCGA/7b5d5572-0613-49d6-9c99-c9d9439246a4/TCGA-78-7153-01Z-00-DX1.5190321a-f1aa-4c6e-b4b9-6767b779682b.svs 62923 59661 0 +/data/TCGA/7b5d5572-0613-49d6-9c99-c9d9439246a4/TCGA-78-7153-01Z-00-DX1.5190321a-f1aa-4c6e-b4b9-6767b779682b.svs 36608 66994 1 +/data/TCGA/7b5d5572-0613-49d6-9c99-c9d9439246a4/TCGA-78-7153-01Z-00-DX1.5190321a-f1aa-4c6e-b4b9-6767b779682b.svs 10891 11718 2 +/data/TCGA/7b5d5572-0613-49d6-9c99-c9d9439246a4/TCGA-78-7153-01Z-00-DX1.5190321a-f1aa-4c6e-b4b9-6767b779682b.svs 21319 15494 3 +/data/TCGA/77609699-3a3b-4add-a2b7-9895fbd9cc56/TCGA-19-A60I-01Z-00-DX6.B8858C6F-BE89-4009-9CCD-57426ABF99FB.svs 33101 20290 0 +/data/TCGA/77609699-3a3b-4add-a2b7-9895fbd9cc56/TCGA-19-A60I-01Z-00-DX6.B8858C6F-BE89-4009-9CCD-57426ABF99FB.svs 13700 39756 1 +/data/TCGA/77609699-3a3b-4add-a2b7-9895fbd9cc56/TCGA-19-A60I-01Z-00-DX6.B8858C6F-BE89-4009-9CCD-57426ABF99FB.svs 24117 23818 2 +/data/TCGA/534007d7-cc8c-435d-903b-69db65df22f9/TCGA-DH-5142-01Z-00-DX1.3C7EAF01-4DC5-4FBE-849D-17DD3A6B5D8D.svs 43689 42324 0 +/data/TCGA/534007d7-cc8c-435d-903b-69db65df22f9/TCGA-DH-5142-01Z-00-DX1.3C7EAF01-4DC5-4FBE-849D-17DD3A6B5D8D.svs 24929 31110 1 +/data/TCGA/534007d7-cc8c-435d-903b-69db65df22f9/TCGA-DH-5142-01Z-00-DX1.3C7EAF01-4DC5-4FBE-849D-17DD3A6B5D8D.svs 38934 36364 2 +/data/TCGA/534007d7-cc8c-435d-903b-69db65df22f9/TCGA-DH-5142-01Z-00-DX1.3C7EAF01-4DC5-4FBE-849D-17DD3A6B5D8D.svs 70211 48455 3 +/data/TCGA/9da3709d-6e3f-42e9-8391-63222151f804/TCGA-DD-A1EB-01Z-00-DX1.705C4FB1-00CA-4726-9589-1F745FCC9729.svs 13251 66242 0 +/data/TCGA/9da3709d-6e3f-42e9-8391-63222151f804/TCGA-DD-A1EB-01Z-00-DX1.705C4FB1-00CA-4726-9589-1F745FCC9729.svs 77065 41596 1 +/data/TCGA/9da3709d-6e3f-42e9-8391-63222151f804/TCGA-DD-A1EB-01Z-00-DX1.705C4FB1-00CA-4726-9589-1F745FCC9729.svs 105927 12839 2 +/data/TCGA/9da3709d-6e3f-42e9-8391-63222151f804/TCGA-DD-A1EB-01Z-00-DX1.705C4FB1-00CA-4726-9589-1F745FCC9729.svs 29986 33617 3 +/data/TCGA/89209e24-0f44-4a26-bd0d-cbc8d8718613/TCGA-94-7943-01Z-00-DX1.361fc645-89ae-4934-8c27-12907bc2a9ee.svs 18793 17484 0 +/data/TCGA/89209e24-0f44-4a26-bd0d-cbc8d8718613/TCGA-94-7943-01Z-00-DX1.361fc645-89ae-4934-8c27-12907bc2a9ee.svs 18684 17104 1 +/data/TCGA/89209e24-0f44-4a26-bd0d-cbc8d8718613/TCGA-94-7943-01Z-00-DX1.361fc645-89ae-4934-8c27-12907bc2a9ee.svs 12501 6311 2 +/data/TCGA/e4b6e830-a308-4262-96b1-4a17b7ce801b/TCGA-2H-A9GL-01Z-00-DX1.8560DF40-122E-4E7F-B2B8-C77769F88ECC.svs 20787 32753 0 +/data/TCGA/e4b6e830-a308-4262-96b1-4a17b7ce801b/TCGA-2H-A9GL-01Z-00-DX1.8560DF40-122E-4E7F-B2B8-C77769F88ECC.svs 24219 42867 1 +/data/TCGA/e4b6e830-a308-4262-96b1-4a17b7ce801b/TCGA-2H-A9GL-01Z-00-DX1.8560DF40-122E-4E7F-B2B8-C77769F88ECC.svs 23065 21615 2 +/data/TCGA/e4b6e830-a308-4262-96b1-4a17b7ce801b/TCGA-2H-A9GL-01Z-00-DX1.8560DF40-122E-4E7F-B2B8-C77769F88ECC.svs 26739 10878 3 +/data/TCGA/78706e29-d806-4352-ba72-25d71d2f9886/TCGA-EY-A1G8-01Z-00-DX1.BAEA251D-F5E8-4A65-945E-926655463F45.svs 56871 8886 0 +/data/TCGA/78706e29-d806-4352-ba72-25d71d2f9886/TCGA-EY-A1G8-01Z-00-DX1.BAEA251D-F5E8-4A65-945E-926655463F45.svs 67686 14830 1 +/data/TCGA/78706e29-d806-4352-ba72-25d71d2f9886/TCGA-EY-A1G8-01Z-00-DX1.BAEA251D-F5E8-4A65-945E-926655463F45.svs 59739 21217 2 +/data/TCGA/78706e29-d806-4352-ba72-25d71d2f9886/TCGA-EY-A1G8-01Z-00-DX1.BAEA251D-F5E8-4A65-945E-926655463F45.svs 58800 23047 3 +/data/TCGA/78fe5ab1-15d3-4701-84d6-7b88beab2f22/TCGA-EW-A2FR-01Z-00-DX1.FF521BBF-F5BA-4B03-9CA1-101A337F4B45.svs 52409 48436 0 +/data/TCGA/78fe5ab1-15d3-4701-84d6-7b88beab2f22/TCGA-EW-A2FR-01Z-00-DX1.FF521BBF-F5BA-4B03-9CA1-101A337F4B45.svs 45527 67857 1 +/data/TCGA/78fe5ab1-15d3-4701-84d6-7b88beab2f22/TCGA-EW-A2FR-01Z-00-DX1.FF521BBF-F5BA-4B03-9CA1-101A337F4B45.svs 28177 43968 2 +/data/TCGA/78fe5ab1-15d3-4701-84d6-7b88beab2f22/TCGA-EW-A2FR-01Z-00-DX1.FF521BBF-F5BA-4B03-9CA1-101A337F4B45.svs 56410 55069 3 +/data/TCGA/2efd0746-94de-4e08-b7f9-e9babfeb84c3/TCGA-CM-4747-01Z-00-DX1.e0fac451-1322-464e-b718-174e9db33f39.svs 8745 26850 0 +/data/TCGA/2efd0746-94de-4e08-b7f9-e9babfeb84c3/TCGA-CM-4747-01Z-00-DX1.e0fac451-1322-464e-b718-174e9db33f39.svs 88081 54761 1 +/data/TCGA/2efd0746-94de-4e08-b7f9-e9babfeb84c3/TCGA-CM-4747-01Z-00-DX1.e0fac451-1322-464e-b718-174e9db33f39.svs 81478 52268 2 +/data/TCGA/2efd0746-94de-4e08-b7f9-e9babfeb84c3/TCGA-CM-4747-01Z-00-DX1.e0fac451-1322-464e-b718-174e9db33f39.svs 55100 12063 3 +/data/TCGA/d74e8e4d-25c4-4e11-911c-9e77abb72854/TCGA-DM-A28K-01Z-00-DX1.766edac4-a5c8-45ef-aff6-73e308c1f442.svs 33728 5319 0 +/data/TCGA/d74e8e4d-25c4-4e11-911c-9e77abb72854/TCGA-DM-A28K-01Z-00-DX1.766edac4-a5c8-45ef-aff6-73e308c1f442.svs 61996 44839 1 +/data/TCGA/d74e8e4d-25c4-4e11-911c-9e77abb72854/TCGA-DM-A28K-01Z-00-DX1.766edac4-a5c8-45ef-aff6-73e308c1f442.svs 64833 42068 2 +/data/TCGA/d74e8e4d-25c4-4e11-911c-9e77abb72854/TCGA-DM-A28K-01Z-00-DX1.766edac4-a5c8-45ef-aff6-73e308c1f442.svs 11906 18103 3 +/data/TCGA/07746bc8-16fc-4884-a0fa-14854db1cdf3/TCGA-DX-A8BH-01Z-00-DX4.402F8A31-FD59-45FB-AAE1-37EE585CF00F.svs 43868 19833 0 +/data/TCGA/07746bc8-16fc-4884-a0fa-14854db1cdf3/TCGA-DX-A8BH-01Z-00-DX4.402F8A31-FD59-45FB-AAE1-37EE585CF00F.svs 81023 28071 1 +/data/TCGA/07746bc8-16fc-4884-a0fa-14854db1cdf3/TCGA-DX-A8BH-01Z-00-DX4.402F8A31-FD59-45FB-AAE1-37EE585CF00F.svs 63352 9435 2 +/data/TCGA/07746bc8-16fc-4884-a0fa-14854db1cdf3/TCGA-DX-A8BH-01Z-00-DX4.402F8A31-FD59-45FB-AAE1-37EE585CF00F.svs 58204 50657 3 +/data/TCGA/a36fac6a-0c70-4917-8f5f-0aa27c01c120/TCGA-02-0052-01Z-00-DX1.93BA650B-4E71-43D8-9974-16185F906EB8.svs 28740 21087 0 +/data/TCGA/a36fac6a-0c70-4917-8f5f-0aa27c01c120/TCGA-02-0052-01Z-00-DX1.93BA650B-4E71-43D8-9974-16185F906EB8.svs 51994 79432 1 +/data/TCGA/a36fac6a-0c70-4917-8f5f-0aa27c01c120/TCGA-02-0052-01Z-00-DX1.93BA650B-4E71-43D8-9974-16185F906EB8.svs 78768 52477 2 +/data/TCGA/a36fac6a-0c70-4917-8f5f-0aa27c01c120/TCGA-02-0052-01Z-00-DX1.93BA650B-4E71-43D8-9974-16185F906EB8.svs 61285 52447 3 +/data/TCGA/0f2dbb86-cd69-46ca-840b-fd5729730e16/TCGA-06-0187-01Z-00-DX3.e8345881-5d2e-4880-b1db-d28ebd302664.svs 652 13406 0 +/data/TCGA/0f2dbb86-cd69-46ca-840b-fd5729730e16/TCGA-06-0187-01Z-00-DX3.e8345881-5d2e-4880-b1db-d28ebd302664.svs 8634 981 1 +/data/TCGA/0f2dbb86-cd69-46ca-840b-fd5729730e16/TCGA-06-0187-01Z-00-DX3.e8345881-5d2e-4880-b1db-d28ebd302664.svs 5932 13534 2 +/data/TCGA/bf2dbebb-99fb-4f7e-8da1-2e894a7d27b5/TCGA-A2-A0YD-01Z-00-DX1.B81FF541-F154-4C49-950B-B6CB723369E2.svs 57115 67729 0 +/data/TCGA/bf2dbebb-99fb-4f7e-8da1-2e894a7d27b5/TCGA-A2-A0YD-01Z-00-DX1.B81FF541-F154-4C49-950B-B6CB723369E2.svs 44592 73371 1 +/data/TCGA/bf2dbebb-99fb-4f7e-8da1-2e894a7d27b5/TCGA-A2-A0YD-01Z-00-DX1.B81FF541-F154-4C49-950B-B6CB723369E2.svs 81365 28780 2 +/data/TCGA/bf2dbebb-99fb-4f7e-8da1-2e894a7d27b5/TCGA-A2-A0YD-01Z-00-DX1.B81FF541-F154-4C49-950B-B6CB723369E2.svs 66380 12886 3 +/data/TCGA/1afd191c-3f03-4d03-8950-6ea25f16297d/TCGA-AR-A24H-01Z-00-DX1.5CFC7E16-3F38-4531-968C-A4E4C9D00659.svs 71980 17827 0 +/data/TCGA/1afd191c-3f03-4d03-8950-6ea25f16297d/TCGA-AR-A24H-01Z-00-DX1.5CFC7E16-3F38-4531-968C-A4E4C9D00659.svs 70133 39467 1 +/data/TCGA/1afd191c-3f03-4d03-8950-6ea25f16297d/TCGA-AR-A24H-01Z-00-DX1.5CFC7E16-3F38-4531-968C-A4E4C9D00659.svs 64213 12891 2 +/data/TCGA/1afd191c-3f03-4d03-8950-6ea25f16297d/TCGA-AR-A24H-01Z-00-DX1.5CFC7E16-3F38-4531-968C-A4E4C9D00659.svs 76285 57470 3 +/data/TCGA/d9ba0533-3f67-40a5-9ebf-171b93f2f4dd/TCGA-06-0152-01Z-00-DX5.d43177f3-75c0-4049-8af7-76c2c12e6411.svs 21058 22929 0 +/data/TCGA/d9ba0533-3f67-40a5-9ebf-171b93f2f4dd/TCGA-06-0152-01Z-00-DX5.d43177f3-75c0-4049-8af7-76c2c12e6411.svs 30447 16576 1 +/data/TCGA/d9ba0533-3f67-40a5-9ebf-171b93f2f4dd/TCGA-06-0152-01Z-00-DX5.d43177f3-75c0-4049-8af7-76c2c12e6411.svs 17714 15774 2 +/data/TCGA/4f5b8cb3-bd2e-4cdf-9ea0-6d06478e8826/TCGA-W5-AA2G-01Z-00-DX1.DA30CC19-6DDF-4A23-8FC6-D800155FAAC5.svs 25190 35770 0 +/data/TCGA/4f5b8cb3-bd2e-4cdf-9ea0-6d06478e8826/TCGA-W5-AA2G-01Z-00-DX1.DA30CC19-6DDF-4A23-8FC6-D800155FAAC5.svs 35398 41070 1 +/data/TCGA/4f5b8cb3-bd2e-4cdf-9ea0-6d06478e8826/TCGA-W5-AA2G-01Z-00-DX1.DA30CC19-6DDF-4A23-8FC6-D800155FAAC5.svs 43032 26339 2 +/data/TCGA/4f5b8cb3-bd2e-4cdf-9ea0-6d06478e8826/TCGA-W5-AA2G-01Z-00-DX1.DA30CC19-6DDF-4A23-8FC6-D800155FAAC5.svs 56854 42263 3 +/data/TCGA/d4417a2e-9a41-4ea5-a5d5-06da7a37c66a/TCGA-AQ-A54O-01Z-00-DX1.85AB0AC4-47BB-4CD8-B7FB-5928108864AC.svs 168308 32024 0 +/data/TCGA/d4417a2e-9a41-4ea5-a5d5-06da7a37c66a/TCGA-AQ-A54O-01Z-00-DX1.85AB0AC4-47BB-4CD8-B7FB-5928108864AC.svs 53767 42135 1 +/data/TCGA/d4417a2e-9a41-4ea5-a5d5-06da7a37c66a/TCGA-AQ-A54O-01Z-00-DX1.85AB0AC4-47BB-4CD8-B7FB-5928108864AC.svs 21223 12177 2 +/data/TCGA/d4417a2e-9a41-4ea5-a5d5-06da7a37c66a/TCGA-AQ-A54O-01Z-00-DX1.85AB0AC4-47BB-4CD8-B7FB-5928108864AC.svs 53471 27403 3 +/data/TCGA/c387719d-3c70-4dd8-b7cd-579ff8ced2d3/TCGA-D3-A2J8-06Z-00-DX1.5FB8E98F-EAFF-491F-856D-49A68542A3E1.svs 8727 15367 0 +/data/TCGA/c387719d-3c70-4dd8-b7cd-579ff8ced2d3/TCGA-D3-A2J8-06Z-00-DX1.5FB8E98F-EAFF-491F-856D-49A68542A3E1.svs 4145 14214 1 +/data/TCGA/c387719d-3c70-4dd8-b7cd-579ff8ced2d3/TCGA-D3-A2J8-06Z-00-DX1.5FB8E98F-EAFF-491F-856D-49A68542A3E1.svs 2973 15212 2 +/data/TCGA/aa76374b-65c0-421a-aafe-c0da580ed32d/TCGA-HC-A48F-01Z-00-DX1.F19F2A8B-7493-420D-8B40-D2C78F6E6184.svs 27577 9425 0 +/data/TCGA/aa76374b-65c0-421a-aafe-c0da580ed32d/TCGA-HC-A48F-01Z-00-DX1.F19F2A8B-7493-420D-8B40-D2C78F6E6184.svs 16652 31518 1 +/data/TCGA/aa76374b-65c0-421a-aafe-c0da580ed32d/TCGA-HC-A48F-01Z-00-DX1.F19F2A8B-7493-420D-8B40-D2C78F6E6184.svs 6271 33188 2 +/data/TCGA/d708a070-d5ce-4522-a7e9-afed9b90891a/TCGA-D3-A51E-06Z-00-DX1.819FF689-47EB-468E-A9C1-5205951F69C0.svs 26073 14444 0 +/data/TCGA/d708a070-d5ce-4522-a7e9-afed9b90891a/TCGA-D3-A51E-06Z-00-DX1.819FF689-47EB-468E-A9C1-5205951F69C0.svs 20134 33064 1 +/data/TCGA/d708a070-d5ce-4522-a7e9-afed9b90891a/TCGA-D3-A51E-06Z-00-DX1.819FF689-47EB-468E-A9C1-5205951F69C0.svs 46186 21883 2 +/data/TCGA/017c7f29-1fbf-45aa-9fc9-7273b49ce0b7/TCGA-D7-8579-01Z-00-DX2.9D40DCA2-2711-426C-B5DD-3D897975F4BF.svs 49884 21597 0 +/data/TCGA/017c7f29-1fbf-45aa-9fc9-7273b49ce0b7/TCGA-D7-8579-01Z-00-DX2.9D40DCA2-2711-426C-B5DD-3D897975F4BF.svs 30246 35315 1 +/data/TCGA/017c7f29-1fbf-45aa-9fc9-7273b49ce0b7/TCGA-D7-8579-01Z-00-DX2.9D40DCA2-2711-426C-B5DD-3D897975F4BF.svs 70068 10719 2 +/data/TCGA/017c7f29-1fbf-45aa-9fc9-7273b49ce0b7/TCGA-D7-8579-01Z-00-DX2.9D40DCA2-2711-426C-B5DD-3D897975F4BF.svs 73665 10571 3 +/data/TCGA/4f51d1b7-1d65-49f0-be3e-cbc1bda418c7/TCGA-A5-A1OG-01Z-00-DX1.DCC0579A-C55E-402F-AD0A-7FCE13CBBFB0.svs 71585 3734 0 +/data/TCGA/4f51d1b7-1d65-49f0-be3e-cbc1bda418c7/TCGA-A5-A1OG-01Z-00-DX1.DCC0579A-C55E-402F-AD0A-7FCE13CBBFB0.svs 102351 56193 1 +/data/TCGA/4f51d1b7-1d65-49f0-be3e-cbc1bda418c7/TCGA-A5-A1OG-01Z-00-DX1.DCC0579A-C55E-402F-AD0A-7FCE13CBBFB0.svs 76130 6253 2 +/data/TCGA/4f51d1b7-1d65-49f0-be3e-cbc1bda418c7/TCGA-A5-A1OG-01Z-00-DX1.DCC0579A-C55E-402F-AD0A-7FCE13CBBFB0.svs 89237 48081 3 +/data/TCGA/c6e6d99a-0dfb-4da6-b2a4-f03e1940bc3a/TCGA-DD-AACG-01Z-00-DX1.7B625854-0DEF-4CD1-9D01-EE685671DE84.svs 17244 39607 0 +/data/TCGA/c6e6d99a-0dfb-4da6-b2a4-f03e1940bc3a/TCGA-DD-AACG-01Z-00-DX1.7B625854-0DEF-4CD1-9D01-EE685671DE84.svs 26333 51443 1 +/data/TCGA/c6e6d99a-0dfb-4da6-b2a4-f03e1940bc3a/TCGA-DD-AACG-01Z-00-DX1.7B625854-0DEF-4CD1-9D01-EE685671DE84.svs 53882 18340 2 +/data/TCGA/c6e6d99a-0dfb-4da6-b2a4-f03e1940bc3a/TCGA-DD-AACG-01Z-00-DX1.7B625854-0DEF-4CD1-9D01-EE685671DE84.svs 23416 35403 3 +/data/TCGA/e058dae6-c2c2-4ec3-a755-45de50cb9812/TCGA-HC-A8D0-01Z-00-DX1.C43B30C6-AC63-4A85-B259-1103621AFBEE.svs 7477 23481 0 +/data/TCGA/e058dae6-c2c2-4ec3-a755-45de50cb9812/TCGA-HC-A8D0-01Z-00-DX1.C43B30C6-AC63-4A85-B259-1103621AFBEE.svs 32762 35165 1 +/data/TCGA/e058dae6-c2c2-4ec3-a755-45de50cb9812/TCGA-HC-A8D0-01Z-00-DX1.C43B30C6-AC63-4A85-B259-1103621AFBEE.svs 29832 4403 2 +/data/TCGA/e058dae6-c2c2-4ec3-a755-45de50cb9812/TCGA-HC-A8D0-01Z-00-DX1.C43B30C6-AC63-4A85-B259-1103621AFBEE.svs 8957 18057 3 +/data/TCGA/f5947833-5fce-4715-abf6-93122d3eaabb/TCGA-DW-7838-01Z-00-DX1.08AE47C1-7A7C-4D7A-A485-13F37341D1AC.svs 42986 5228 0 +/data/TCGA/f5947833-5fce-4715-abf6-93122d3eaabb/TCGA-DW-7838-01Z-00-DX1.08AE47C1-7A7C-4D7A-A485-13F37341D1AC.svs 48390 14085 1 +/data/TCGA/f5947833-5fce-4715-abf6-93122d3eaabb/TCGA-DW-7838-01Z-00-DX1.08AE47C1-7A7C-4D7A-A485-13F37341D1AC.svs 32917 14238 2 +/data/TCGA/5c164e67-7f01-4a11-94d8-0a4ff3037cd6/TCGA-KL-8326-01Z-00-DX1.0fe86143-728f-4447-98a5-4a6d87ef398b.svs 83514 13715 0 +/data/TCGA/5c164e67-7f01-4a11-94d8-0a4ff3037cd6/TCGA-KL-8326-01Z-00-DX1.0fe86143-728f-4447-98a5-4a6d87ef398b.svs 58789 60364 1 +/data/TCGA/5c164e67-7f01-4a11-94d8-0a4ff3037cd6/TCGA-KL-8326-01Z-00-DX1.0fe86143-728f-4447-98a5-4a6d87ef398b.svs 23881 10504 2 +/data/TCGA/5c164e67-7f01-4a11-94d8-0a4ff3037cd6/TCGA-KL-8326-01Z-00-DX1.0fe86143-728f-4447-98a5-4a6d87ef398b.svs 55145 14731 3 +/data/TCGA/0af62107-10ae-4fb8-99f8-85a54aa69408/TCGA-14-1396-01Z-00-DX1.ce29c5a9-6823-41be-9d07-f482a4539dad.svs 25493 6479 0 +/data/TCGA/0af62107-10ae-4fb8-99f8-85a54aa69408/TCGA-14-1396-01Z-00-DX1.ce29c5a9-6823-41be-9d07-f482a4539dad.svs 14287 39965 1 +/data/TCGA/0af62107-10ae-4fb8-99f8-85a54aa69408/TCGA-14-1396-01Z-00-DX1.ce29c5a9-6823-41be-9d07-f482a4539dad.svs 69274 1468 2 +/data/TCGA/0af62107-10ae-4fb8-99f8-85a54aa69408/TCGA-14-1396-01Z-00-DX1.ce29c5a9-6823-41be-9d07-f482a4539dad.svs 7938 29251 3 +/data/TCGA/fc0d6b8a-4638-4ec3-bcd6-8331edfc58d7/TCGA-D1-A16E-01Z-00-DX1.C5BE7CE0-B192-4E7C-AC9D-51854C0FCDB5.svs 92006 53606 0 +/data/TCGA/fc0d6b8a-4638-4ec3-bcd6-8331edfc58d7/TCGA-D1-A16E-01Z-00-DX1.C5BE7CE0-B192-4E7C-AC9D-51854C0FCDB5.svs 85333 10983 1 +/data/TCGA/fc0d6b8a-4638-4ec3-bcd6-8331edfc58d7/TCGA-D1-A16E-01Z-00-DX1.C5BE7CE0-B192-4E7C-AC9D-51854C0FCDB5.svs 106361 36459 2 +/data/TCGA/fc0d6b8a-4638-4ec3-bcd6-8331edfc58d7/TCGA-D1-A16E-01Z-00-DX1.C5BE7CE0-B192-4E7C-AC9D-51854C0FCDB5.svs 49808 56453 3 +/data/TCGA/8a272ee7-5044-4773-93b3-9d68ffa6a82b/TCGA-C5-A8XH-01Z-00-DX1.BF77955E-29C9-4D06-8FD4-A14B089B2BCE.svs 108878 9165 0 +/data/TCGA/8a272ee7-5044-4773-93b3-9d68ffa6a82b/TCGA-C5-A8XH-01Z-00-DX1.BF77955E-29C9-4D06-8FD4-A14B089B2BCE.svs 11331 10355 1 +/data/TCGA/8a272ee7-5044-4773-93b3-9d68ffa6a82b/TCGA-C5-A8XH-01Z-00-DX1.BF77955E-29C9-4D06-8FD4-A14B089B2BCE.svs 58012 10114 2 +/data/TCGA/8a272ee7-5044-4773-93b3-9d68ffa6a82b/TCGA-C5-A8XH-01Z-00-DX1.BF77955E-29C9-4D06-8FD4-A14B089B2BCE.svs 7267 2737 3 +/data/TCGA/e0ad7b6e-d66f-402b-bb54-c527e9362fd2/TCGA-SX-A7SN-01Z-00-DX1.64A4FFA5-6BAF-43F3-AF02-5E2D00572395.svs 25354 37972 0 +/data/TCGA/e0ad7b6e-d66f-402b-bb54-c527e9362fd2/TCGA-SX-A7SN-01Z-00-DX1.64A4FFA5-6BAF-43F3-AF02-5E2D00572395.svs 21576 43401 1 +/data/TCGA/e0ad7b6e-d66f-402b-bb54-c527e9362fd2/TCGA-SX-A7SN-01Z-00-DX1.64A4FFA5-6BAF-43F3-AF02-5E2D00572395.svs 21954 23918 2 +/data/TCGA/e0ad7b6e-d66f-402b-bb54-c527e9362fd2/TCGA-SX-A7SN-01Z-00-DX1.64A4FFA5-6BAF-43F3-AF02-5E2D00572395.svs 14310 40343 3 +/data/TCGA/08968a60-fb74-44de-85be-15938c8b7d59/TCGA-LP-A7HU-01Z-00-DX1.AE8E0ECD-C300-4260-A418-F86EED790E0F.svs 24707 36111 0 +/data/TCGA/08968a60-fb74-44de-85be-15938c8b7d59/TCGA-LP-A7HU-01Z-00-DX1.AE8E0ECD-C300-4260-A418-F86EED790E0F.svs 63403 50369 1 +/data/TCGA/08968a60-fb74-44de-85be-15938c8b7d59/TCGA-LP-A7HU-01Z-00-DX1.AE8E0ECD-C300-4260-A418-F86EED790E0F.svs 27293 15640 2 +/data/TCGA/08968a60-fb74-44de-85be-15938c8b7d59/TCGA-LP-A7HU-01Z-00-DX1.AE8E0ECD-C300-4260-A418-F86EED790E0F.svs 9185 14347 3 +/data/TCGA/bf737cb9-605f-48af-85a4-a042a746a027/TCGA-RT-A6YC-01Z-00-DX1.24E59C44-0063-4F65-87A7-A9EA2B843B05.svs 22416 15963 0 +/data/TCGA/bf737cb9-605f-48af-85a4-a042a746a027/TCGA-RT-A6YC-01Z-00-DX1.24E59C44-0063-4F65-87A7-A9EA2B843B05.svs 48218 24181 1 +/data/TCGA/bf737cb9-605f-48af-85a4-a042a746a027/TCGA-RT-A6YC-01Z-00-DX1.24E59C44-0063-4F65-87A7-A9EA2B843B05.svs 33394 35209 2 +/data/TCGA/bf737cb9-605f-48af-85a4-a042a746a027/TCGA-RT-A6YC-01Z-00-DX1.24E59C44-0063-4F65-87A7-A9EA2B843B05.svs 78484 55480 3 +/data/TCGA/411e68e5-a78e-486d-aba6-fdef038f9082/TCGA-LL-A442-01Z-00-DX1.9275EDBD-1C89-4AF3-B02B-19F613A4E083.svs 71898 14234 0 +/data/TCGA/411e68e5-a78e-486d-aba6-fdef038f9082/TCGA-LL-A442-01Z-00-DX1.9275EDBD-1C89-4AF3-B02B-19F613A4E083.svs 47485 14552 1 +/data/TCGA/411e68e5-a78e-486d-aba6-fdef038f9082/TCGA-LL-A442-01Z-00-DX1.9275EDBD-1C89-4AF3-B02B-19F613A4E083.svs 42470 47625 2 +/data/TCGA/411e68e5-a78e-486d-aba6-fdef038f9082/TCGA-LL-A442-01Z-00-DX1.9275EDBD-1C89-4AF3-B02B-19F613A4E083.svs 60821 56635 3 +/data/TCGA/45771c4b-5340-462c-91db-b5ddf900f96a/TCGA-EM-A2CO-01Z-00-DX1.D4390B8C-50DD-414C-906A-3338C97BAD10.svs 18898 11360 0 +/data/TCGA/45771c4b-5340-462c-91db-b5ddf900f96a/TCGA-EM-A2CO-01Z-00-DX1.D4390B8C-50DD-414C-906A-3338C97BAD10.svs 16574 40124 1 +/data/TCGA/45771c4b-5340-462c-91db-b5ddf900f96a/TCGA-EM-A2CO-01Z-00-DX1.D4390B8C-50DD-414C-906A-3338C97BAD10.svs 22481 31736 2 +/data/TCGA/45771c4b-5340-462c-91db-b5ddf900f96a/TCGA-EM-A2CO-01Z-00-DX1.D4390B8C-50DD-414C-906A-3338C97BAD10.svs 31404 26071 3 +/data/TCGA/1bfd5b0e-52b9-463a-b00e-32fe330ffb19/TCGA-VQ-A91U-01Z-00-DX1.84D19359-4AC3-4C7A-BC5B-7B63173ABB60.svs 29864 30065 0 +/data/TCGA/1bfd5b0e-52b9-463a-b00e-32fe330ffb19/TCGA-VQ-A91U-01Z-00-DX1.84D19359-4AC3-4C7A-BC5B-7B63173ABB60.svs 74736 24416 1 +/data/TCGA/1bfd5b0e-52b9-463a-b00e-32fe330ffb19/TCGA-VQ-A91U-01Z-00-DX1.84D19359-4AC3-4C7A-BC5B-7B63173ABB60.svs 49887 14933 2 +/data/TCGA/1bfd5b0e-52b9-463a-b00e-32fe330ffb19/TCGA-VQ-A91U-01Z-00-DX1.84D19359-4AC3-4C7A-BC5B-7B63173ABB60.svs 7061 11679 3 +/data/TCGA/5b79089a-1c0b-4bf6-908e-e47267d8855b/TCGA-55-8087-01Z-00-DX1.548f2800-8caf-4c0e-a7b5-6d3d28315d9c.svs 38520 18012 0 +/data/TCGA/5b79089a-1c0b-4bf6-908e-e47267d8855b/TCGA-55-8087-01Z-00-DX1.548f2800-8caf-4c0e-a7b5-6d3d28315d9c.svs 14941 27667 1 +/data/TCGA/5b79089a-1c0b-4bf6-908e-e47267d8855b/TCGA-55-8087-01Z-00-DX1.548f2800-8caf-4c0e-a7b5-6d3d28315d9c.svs 24978 9572 2 +/data/TCGA/ec33774e-68a9-4744-a74c-eacdf1538545/TCGA-B6-A0IA-01Z-00-DX1.8A868F0A-6CE2-46A7-AF0C-C5FC5D657D86.svs 22441 54958 0 +/data/TCGA/ec33774e-68a9-4744-a74c-eacdf1538545/TCGA-B6-A0IA-01Z-00-DX1.8A868F0A-6CE2-46A7-AF0C-C5FC5D657D86.svs 72793 83630 1 +/data/TCGA/ec33774e-68a9-4744-a74c-eacdf1538545/TCGA-B6-A0IA-01Z-00-DX1.8A868F0A-6CE2-46A7-AF0C-C5FC5D657D86.svs 25049 45434 2 +/data/TCGA/ec33774e-68a9-4744-a74c-eacdf1538545/TCGA-B6-A0IA-01Z-00-DX1.8A868F0A-6CE2-46A7-AF0C-C5FC5D657D86.svs 47267 33235 3 +/data/TCGA/50e6659e-c5ed-4ae6-8d9d-9a2a1dbb6cd6/TCGA-OR-A5K4-01Z-00-DX5.F453A6FD-EA37-4F16-8F1B-42FAEBBFBCC1.svs 23887 33118 0 +/data/TCGA/50e6659e-c5ed-4ae6-8d9d-9a2a1dbb6cd6/TCGA-OR-A5K4-01Z-00-DX5.F453A6FD-EA37-4F16-8F1B-42FAEBBFBCC1.svs 77192 23420 1 +/data/TCGA/50e6659e-c5ed-4ae6-8d9d-9a2a1dbb6cd6/TCGA-OR-A5K4-01Z-00-DX5.F453A6FD-EA37-4F16-8F1B-42FAEBBFBCC1.svs 23262 48364 2 +/data/TCGA/50e6659e-c5ed-4ae6-8d9d-9a2a1dbb6cd6/TCGA-OR-A5K4-01Z-00-DX5.F453A6FD-EA37-4F16-8F1B-42FAEBBFBCC1.svs 42540 45773 3 +/data/TCGA/699509ba-3e38-4399-9c61-46f468520d73/TCGA-CG-4306-01Z-00-DX1.d4b89854-8529-4fb5-847a-ddb59b163727.svs 30769 22249 0 +/data/TCGA/699509ba-3e38-4399-9c61-46f468520d73/TCGA-CG-4306-01Z-00-DX1.d4b89854-8529-4fb5-847a-ddb59b163727.svs 23486 26169 1 +/data/TCGA/699509ba-3e38-4399-9c61-46f468520d73/TCGA-CG-4306-01Z-00-DX1.d4b89854-8529-4fb5-847a-ddb59b163727.svs 21585 45221 2 +/data/TCGA/699509ba-3e38-4399-9c61-46f468520d73/TCGA-CG-4306-01Z-00-DX1.d4b89854-8529-4fb5-847a-ddb59b163727.svs 11872 33904 3 +/data/TCGA/66421b9b-a4b6-4cf0-ba66-d7ded0abb773/TCGA-FD-A3SR-01Z-00-DX1.7E2FB51A-9562-4B3D-8431-6283342B4311.svs 15731 39669 0 +/data/TCGA/66421b9b-a4b6-4cf0-ba66-d7ded0abb773/TCGA-FD-A3SR-01Z-00-DX1.7E2FB51A-9562-4B3D-8431-6283342B4311.svs 47089 24755 1 +/data/TCGA/66421b9b-a4b6-4cf0-ba66-d7ded0abb773/TCGA-FD-A3SR-01Z-00-DX1.7E2FB51A-9562-4B3D-8431-6283342B4311.svs 71474 33350 2 +/data/TCGA/66421b9b-a4b6-4cf0-ba66-d7ded0abb773/TCGA-FD-A3SR-01Z-00-DX1.7E2FB51A-9562-4B3D-8431-6283342B4311.svs 13309 54092 3 +/data/TCGA/1b188fea-1040-4576-ada5-0e8b5b0a87ce/TCGA-HT-8104-01Z-00-DX1.3E2660DC-5A2A-45C0-8F9B-BD0838002672.svs 111817 29046 0 +/data/TCGA/1b188fea-1040-4576-ada5-0e8b5b0a87ce/TCGA-HT-8104-01Z-00-DX1.3E2660DC-5A2A-45C0-8F9B-BD0838002672.svs 17614 25323 1 +/data/TCGA/1b188fea-1040-4576-ada5-0e8b5b0a87ce/TCGA-HT-8104-01Z-00-DX1.3E2660DC-5A2A-45C0-8F9B-BD0838002672.svs 40056 20079 2 +/data/TCGA/1b188fea-1040-4576-ada5-0e8b5b0a87ce/TCGA-HT-8104-01Z-00-DX1.3E2660DC-5A2A-45C0-8F9B-BD0838002672.svs 5740 6439 3 +/data/TCGA/59e1faeb-efa4-45bf-9db8-cf859226fd02/TCGA-PG-A916-01Z-00-DX1.EE02736A-4198-4880-9791-8AA6899533D1.svs 47184 32731 0 +/data/TCGA/59e1faeb-efa4-45bf-9db8-cf859226fd02/TCGA-PG-A916-01Z-00-DX1.EE02736A-4198-4880-9791-8AA6899533D1.svs 52638 32880 1 +/data/TCGA/59e1faeb-efa4-45bf-9db8-cf859226fd02/TCGA-PG-A916-01Z-00-DX1.EE02736A-4198-4880-9791-8AA6899533D1.svs 17104 17109 2 +/data/TCGA/59e1faeb-efa4-45bf-9db8-cf859226fd02/TCGA-PG-A916-01Z-00-DX1.EE02736A-4198-4880-9791-8AA6899533D1.svs 19651 44062 3 +/data/TCGA/cd16e760-05c8-47cf-a2ed-52953f4a2b41/TCGA-CD-A4MI-01Z-00-DX1.67267177-498C-4835-A95A-FF8C2A9DDB97.svs 36832 44471 0 +/data/TCGA/cd16e760-05c8-47cf-a2ed-52953f4a2b41/TCGA-CD-A4MI-01Z-00-DX1.67267177-498C-4835-A95A-FF8C2A9DDB97.svs 46143 25725 1 +/data/TCGA/cd16e760-05c8-47cf-a2ed-52953f4a2b41/TCGA-CD-A4MI-01Z-00-DX1.67267177-498C-4835-A95A-FF8C2A9DDB97.svs 33845 54296 2 +/data/TCGA/cd16e760-05c8-47cf-a2ed-52953f4a2b41/TCGA-CD-A4MI-01Z-00-DX1.67267177-498C-4835-A95A-FF8C2A9DDB97.svs 33052 2020 3 +/data/TCGA/ee961bbb-27bf-4213-be09-54e6bc89a626/TCGA-AG-3898-01Z-00-DX1.c71a46ab-8ce8-48a6-8b06-f5f7995efc95.svs 19253 44274 0 +/data/TCGA/ee961bbb-27bf-4213-be09-54e6bc89a626/TCGA-AG-3898-01Z-00-DX1.c71a46ab-8ce8-48a6-8b06-f5f7995efc95.svs 19748 31238 1 +/data/TCGA/ee961bbb-27bf-4213-be09-54e6bc89a626/TCGA-AG-3898-01Z-00-DX1.c71a46ab-8ce8-48a6-8b06-f5f7995efc95.svs 19798 7642 2 +/data/TCGA/ee961bbb-27bf-4213-be09-54e6bc89a626/TCGA-AG-3898-01Z-00-DX1.c71a46ab-8ce8-48a6-8b06-f5f7995efc95.svs 17889 49304 3 +/data/TCGA/bfa67e8e-7b1c-4c25-aa06-5e998f5f83b5/TCGA-VS-A8EB-01Z-00-DX1.1272EB5E-4A07-4F3B-B8DA-2574DEC130C5.svs 21792 13306 0 +/data/TCGA/bfa67e8e-7b1c-4c25-aa06-5e998f5f83b5/TCGA-VS-A8EB-01Z-00-DX1.1272EB5E-4A07-4F3B-B8DA-2574DEC130C5.svs 9560 6623 1 +/data/TCGA/bfa67e8e-7b1c-4c25-aa06-5e998f5f83b5/TCGA-VS-A8EB-01Z-00-DX1.1272EB5E-4A07-4F3B-B8DA-2574DEC130C5.svs 11674 11097 2 +/data/TCGA/324dffa4-46f3-451f-b04e-c03fd2ca9b9a/TCGA-A5-A0R6-01Z-00-DX1.4AFF4E99-BAB8-46CE-9F8B-324BAE904573.svs 143436 76881 0 +/data/TCGA/324dffa4-46f3-451f-b04e-c03fd2ca9b9a/TCGA-A5-A0R6-01Z-00-DX1.4AFF4E99-BAB8-46CE-9F8B-324BAE904573.svs 4680 45579 1 +/data/TCGA/324dffa4-46f3-451f-b04e-c03fd2ca9b9a/TCGA-A5-A0R6-01Z-00-DX1.4AFF4E99-BAB8-46CE-9F8B-324BAE904573.svs 58417 34608 2 +/data/TCGA/324dffa4-46f3-451f-b04e-c03fd2ca9b9a/TCGA-A5-A0R6-01Z-00-DX1.4AFF4E99-BAB8-46CE-9F8B-324BAE904573.svs 112314 48125 3 +/data/TCGA/bc165a6d-3bae-4f44-a257-e967e62abfc4/TCGA-66-2753-01Z-00-DX1.ae9d8372-adb8-46f9-a140-2f0a1ddff579.svs 11200 13309 0 +/data/TCGA/bc165a6d-3bae-4f44-a257-e967e62abfc4/TCGA-66-2753-01Z-00-DX1.ae9d8372-adb8-46f9-a140-2f0a1ddff579.svs 10624 16694 1 +/data/TCGA/bc165a6d-3bae-4f44-a257-e967e62abfc4/TCGA-66-2753-01Z-00-DX1.ae9d8372-adb8-46f9-a140-2f0a1ddff579.svs 15320 6380 2 +/data/TCGA/46ac2c39-3826-4247-90db-9c5d25edce00/TCGA-CG-5722-01Z-00-DX1.C1B50B01-0328-4DAF-8EDA-024D2A7EC07F.svs 3265 5169 0 +/data/TCGA/46ac2c39-3826-4247-90db-9c5d25edce00/TCGA-CG-5722-01Z-00-DX1.C1B50B01-0328-4DAF-8EDA-024D2A7EC07F.svs 6011 3865 1 +/data/TCGA/83c0c6d1-8434-4ecc-808c-d9d19d396d65/TCGA-14-1452-01Z-00-DX2.0a482b56-e322-488c-af00-492a7d41caeb.svs 13599 20041 0 +/data/TCGA/83c0c6d1-8434-4ecc-808c-d9d19d396d65/TCGA-14-1452-01Z-00-DX2.0a482b56-e322-488c-af00-492a7d41caeb.svs 24734 11836 1 +/data/TCGA/83c0c6d1-8434-4ecc-808c-d9d19d396d65/TCGA-14-1452-01Z-00-DX2.0a482b56-e322-488c-af00-492a7d41caeb.svs 10995 12105 2 +/data/TCGA/1c1694f9-e8e3-46bb-aaf7-2ca101585e1c/TCGA-EM-A2OW-01Z-00-DX1.8495B3A9-2FD1-4ADF-868C-816C897FAD14.svs 16902 14002 0 +/data/TCGA/1c1694f9-e8e3-46bb-aaf7-2ca101585e1c/TCGA-EM-A2OW-01Z-00-DX1.8495B3A9-2FD1-4ADF-868C-816C897FAD14.svs 15411 18067 1 +/data/TCGA/1c1694f9-e8e3-46bb-aaf7-2ca101585e1c/TCGA-EM-A2OW-01Z-00-DX1.8495B3A9-2FD1-4ADF-868C-816C897FAD14.svs 16731 9128 2 +/data/TCGA/c3366298-e73c-404b-b0be-6c09990e5d80/TCGA-GK-A6C7-01Z-00-DX1.291DEE77-CD13-4D8E-BA35-6EC15F45D264.svs 23022 21111 0 +/data/TCGA/c3366298-e73c-404b-b0be-6c09990e5d80/TCGA-GK-A6C7-01Z-00-DX1.291DEE77-CD13-4D8E-BA35-6EC15F45D264.svs 34556 12147 1 +/data/TCGA/c3366298-e73c-404b-b0be-6c09990e5d80/TCGA-GK-A6C7-01Z-00-DX1.291DEE77-CD13-4D8E-BA35-6EC15F45D264.svs 12793 26153 2 +/data/TCGA/7345935b-4ee0-4f36-b65c-6daf72aad2b2/TCGA-BR-4363-01Z-00-DX1.d2121987-481e-4f39-8cb3-724a9fc18036.svs 1159 13 0 +/data/TCGA/f49ddb4b-47e0-4ea0-914a-9066af8c6649/TCGA-FG-A4MW-01Z-00-DX2.2A441E68-6A73-47F7-A3C8-C5656F9CC658.svs 8493 27493 0 +/data/TCGA/f49ddb4b-47e0-4ea0-914a-9066af8c6649/TCGA-FG-A4MW-01Z-00-DX2.2A441E68-6A73-47F7-A3C8-C5656F9CC658.svs 12251 29236 1 +/data/TCGA/f49ddb4b-47e0-4ea0-914a-9066af8c6649/TCGA-FG-A4MW-01Z-00-DX2.2A441E68-6A73-47F7-A3C8-C5656F9CC658.svs 14509 22291 2 +/data/TCGA/f49ddb4b-47e0-4ea0-914a-9066af8c6649/TCGA-FG-A4MW-01Z-00-DX2.2A441E68-6A73-47F7-A3C8-C5656F9CC658.svs 54482 47021 3 +/data/TCGA/a039cd71-a0f1-4425-a97c-36274d70059d/TCGA-OR-A5K5-01Z-00-DX5.ECB798BF-5EEC-44A4-830F-C0884D40FD22.svs 76825 59775 0 +/data/TCGA/a039cd71-a0f1-4425-a97c-36274d70059d/TCGA-OR-A5K5-01Z-00-DX5.ECB798BF-5EEC-44A4-830F-C0884D40FD22.svs 75398 59561 1 +/data/TCGA/a039cd71-a0f1-4425-a97c-36274d70059d/TCGA-OR-A5K5-01Z-00-DX5.ECB798BF-5EEC-44A4-830F-C0884D40FD22.svs 89581 25871 2 +/data/TCGA/a039cd71-a0f1-4425-a97c-36274d70059d/TCGA-OR-A5K5-01Z-00-DX5.ECB798BF-5EEC-44A4-830F-C0884D40FD22.svs 69348 32185 3 +/data/TCGA/e9399bd6-6ad6-49b1-ad6a-d6bb47eb0bf4/TCGA-BB-4223-01Z-00-DX1.8806b83e-910f-4ee8-aa83-f84e3d13155f.svs 13420 6620 0 +/data/TCGA/e9399bd6-6ad6-49b1-ad6a-d6bb47eb0bf4/TCGA-BB-4223-01Z-00-DX1.8806b83e-910f-4ee8-aa83-f84e3d13155f.svs 113417 27393 1 +/data/TCGA/e9399bd6-6ad6-49b1-ad6a-d6bb47eb0bf4/TCGA-BB-4223-01Z-00-DX1.8806b83e-910f-4ee8-aa83-f84e3d13155f.svs 113963 35234 2 +/data/TCGA/e9399bd6-6ad6-49b1-ad6a-d6bb47eb0bf4/TCGA-BB-4223-01Z-00-DX1.8806b83e-910f-4ee8-aa83-f84e3d13155f.svs 11090 374 3 +/data/TCGA/c8ddaf92-e197-417b-bb4a-316ea043acee/TCGA-06-0178-01Z-00-DX5.7ab03a67-87f7-4e71-82fa-250518378f49.svs 14942 17359 0 +/data/TCGA/c8ddaf92-e197-417b-bb4a-316ea043acee/TCGA-06-0178-01Z-00-DX5.7ab03a67-87f7-4e71-82fa-250518378f49.svs 41878 17896 1 +/data/TCGA/c8ddaf92-e197-417b-bb4a-316ea043acee/TCGA-06-0178-01Z-00-DX5.7ab03a67-87f7-4e71-82fa-250518378f49.svs 46667 19629 2 +/data/TCGA/ac6d620c-bfb4-40a1-90da-931ab51bcbab/TCGA-YL-A9WI-01Z-00-DX2.33951B3A-6591-471C-9F4F-EAAEF761CBEE.svs 14402 23078 0 +/data/TCGA/ac6d620c-bfb4-40a1-90da-931ab51bcbab/TCGA-YL-A9WI-01Z-00-DX2.33951B3A-6591-471C-9F4F-EAAEF761CBEE.svs 65713 70236 1 +/data/TCGA/ac6d620c-bfb4-40a1-90da-931ab51bcbab/TCGA-YL-A9WI-01Z-00-DX2.33951B3A-6591-471C-9F4F-EAAEF761CBEE.svs 46766 37865 2 +/data/TCGA/ac6d620c-bfb4-40a1-90da-931ab51bcbab/TCGA-YL-A9WI-01Z-00-DX2.33951B3A-6591-471C-9F4F-EAAEF761CBEE.svs 61105 25303 3 +/data/TCGA/53eedc41-8059-4cc9-9045-8e3ef41c971a/TCGA-MH-A562-01Z-00-DX1.422B7AF0-DF11-4B89-958D-66D0529ADB84.svs 70861 14868 0 +/data/TCGA/53eedc41-8059-4cc9-9045-8e3ef41c971a/TCGA-MH-A562-01Z-00-DX1.422B7AF0-DF11-4B89-958D-66D0529ADB84.svs 79119 23801 1 +/data/TCGA/53eedc41-8059-4cc9-9045-8e3ef41c971a/TCGA-MH-A562-01Z-00-DX1.422B7AF0-DF11-4B89-958D-66D0529ADB84.svs 86795 30619 2 +/data/TCGA/53eedc41-8059-4cc9-9045-8e3ef41c971a/TCGA-MH-A562-01Z-00-DX1.422B7AF0-DF11-4B89-958D-66D0529ADB84.svs 73662 15597 3 +/data/TCGA/eed47fd2-45bf-4957-abea-e42b15c797d6/TCGA-DX-A8BL-01Z-00-DX1.808E8FE6-9A2C-48FF-9108-D653F09B44B3.svs 18062 44720 0 +/data/TCGA/eed47fd2-45bf-4957-abea-e42b15c797d6/TCGA-DX-A8BL-01Z-00-DX1.808E8FE6-9A2C-48FF-9108-D653F09B44B3.svs 28222 60224 1 +/data/TCGA/eed47fd2-45bf-4957-abea-e42b15c797d6/TCGA-DX-A8BL-01Z-00-DX1.808E8FE6-9A2C-48FF-9108-D653F09B44B3.svs 80525 77348 2 +/data/TCGA/eed47fd2-45bf-4957-abea-e42b15c797d6/TCGA-DX-A8BL-01Z-00-DX1.808E8FE6-9A2C-48FF-9108-D653F09B44B3.svs 83411 61892 3 +/data/TCGA/c04e597a-03db-4a93-93e9-cc74a4716e49/TCGA-02-0033-01Z-00-DX1.3c22d6a0-8b25-4f00-a499-b610d0f3c9a0.svs 31993 12715 0 +/data/TCGA/c04e597a-03db-4a93-93e9-cc74a4716e49/TCGA-02-0033-01Z-00-DX1.3c22d6a0-8b25-4f00-a499-b610d0f3c9a0.svs 30914 20813 1 +/data/TCGA/c04e597a-03db-4a93-93e9-cc74a4716e49/TCGA-02-0033-01Z-00-DX1.3c22d6a0-8b25-4f00-a499-b610d0f3c9a0.svs 7181 25017 2 +/data/TCGA/104d619d-5db3-40b4-a35f-9c3208eb9f88/TCGA-2Z-A9JL-01Z-00-DX1.C99E66C8-3CB7-4F07-B2A4-089187612E38.svs 32551 29647 0 +/data/TCGA/104d619d-5db3-40b4-a35f-9c3208eb9f88/TCGA-2Z-A9JL-01Z-00-DX1.C99E66C8-3CB7-4F07-B2A4-089187612E38.svs 50747 43200 1 +/data/TCGA/104d619d-5db3-40b4-a35f-9c3208eb9f88/TCGA-2Z-A9JL-01Z-00-DX1.C99E66C8-3CB7-4F07-B2A4-089187612E38.svs 20656 7597 2 +/data/TCGA/104d619d-5db3-40b4-a35f-9c3208eb9f88/TCGA-2Z-A9JL-01Z-00-DX1.C99E66C8-3CB7-4F07-B2A4-089187612E38.svs 12780 48009 3 +/data/TCGA/aa84c53f-acc0-422b-99d3-c0faf15d9140/TCGA-E9-A1RC-01Z-00-DX1.8e1008da-b17b-4096-a070-f536fe8ce52d.svs 16953 41939 0 +/data/TCGA/aa84c53f-acc0-422b-99d3-c0faf15d9140/TCGA-E9-A1RC-01Z-00-DX1.8e1008da-b17b-4096-a070-f536fe8ce52d.svs 77209 38716 1 +/data/TCGA/aa84c53f-acc0-422b-99d3-c0faf15d9140/TCGA-E9-A1RC-01Z-00-DX1.8e1008da-b17b-4096-a070-f536fe8ce52d.svs 67033 31737 2 +/data/TCGA/aa84c53f-acc0-422b-99d3-c0faf15d9140/TCGA-E9-A1RC-01Z-00-DX1.8e1008da-b17b-4096-a070-f536fe8ce52d.svs 58295 37035 3 +/data/TCGA/3118cdd9-4d0d-4842-8694-046323f8f4a4/TCGA-55-6543-01Z-00-DX1.08806fe0-84d3-4fd6-8746-6cf557241958.svs 47457 31013 0 +/data/TCGA/3118cdd9-4d0d-4842-8694-046323f8f4a4/TCGA-55-6543-01Z-00-DX1.08806fe0-84d3-4fd6-8746-6cf557241958.svs 18282 25170 1 +/data/TCGA/3118cdd9-4d0d-4842-8694-046323f8f4a4/TCGA-55-6543-01Z-00-DX1.08806fe0-84d3-4fd6-8746-6cf557241958.svs 51304 28294 2 +/data/TCGA/3118cdd9-4d0d-4842-8694-046323f8f4a4/TCGA-55-6543-01Z-00-DX1.08806fe0-84d3-4fd6-8746-6cf557241958.svs 23802 9363 3 +/data/TCGA/8e7abe78-920c-47c4-a894-39618f1b2d35/TCGA-OR-A5JB-01Z-00-DX4.62F46F82-930B-4F4D-A706-CDB8F3F7D0E1.svs 32386 50709 0 +/data/TCGA/8e7abe78-920c-47c4-a894-39618f1b2d35/TCGA-OR-A5JB-01Z-00-DX4.62F46F82-930B-4F4D-A706-CDB8F3F7D0E1.svs 37860 68263 1 +/data/TCGA/8e7abe78-920c-47c4-a894-39618f1b2d35/TCGA-OR-A5JB-01Z-00-DX4.62F46F82-930B-4F4D-A706-CDB8F3F7D0E1.svs 39056 54117 2 +/data/TCGA/8e7abe78-920c-47c4-a894-39618f1b2d35/TCGA-OR-A5JB-01Z-00-DX4.62F46F82-930B-4F4D-A706-CDB8F3F7D0E1.svs 35796 53869 3 +/data/TCGA/da0ccaf4-82fa-4e58-9433-e2ff77e957cd/TCGA-3X-AAVE-01Z-00-DX1.26FC1984-B066-4BE4-9A5A-DFEC74D4C582.svs 117206 63107 0 +/data/TCGA/da0ccaf4-82fa-4e58-9433-e2ff77e957cd/TCGA-3X-AAVE-01Z-00-DX1.26FC1984-B066-4BE4-9A5A-DFEC74D4C582.svs 46837 65616 1 +/data/TCGA/da0ccaf4-82fa-4e58-9433-e2ff77e957cd/TCGA-3X-AAVE-01Z-00-DX1.26FC1984-B066-4BE4-9A5A-DFEC74D4C582.svs 48756 36331 2 +/data/TCGA/da0ccaf4-82fa-4e58-9433-e2ff77e957cd/TCGA-3X-AAVE-01Z-00-DX1.26FC1984-B066-4BE4-9A5A-DFEC74D4C582.svs 41640 70337 3 +/data/TCGA/cb50cb24-f8b2-4003-90ec-10698bd5b245/TCGA-66-2788-01Z-00-DX1.1a57324a-5b00-44ed-912d-9522d0141500.svs 16688 28400 0 +/data/TCGA/cb50cb24-f8b2-4003-90ec-10698bd5b245/TCGA-66-2788-01Z-00-DX1.1a57324a-5b00-44ed-912d-9522d0141500.svs 11656 15946 1 +/data/TCGA/cb50cb24-f8b2-4003-90ec-10698bd5b245/TCGA-66-2788-01Z-00-DX1.1a57324a-5b00-44ed-912d-9522d0141500.svs 25097 13178 2 +/data/TCGA/69b80e9a-f0b0-4047-9e91-627dbcc9c0f7/TCGA-CV-7100-01Z-00-DX1.44DFCAC1-2567-40E7-8F03-AF1FB742B012.svs 52041 7656 0 +/data/TCGA/69b80e9a-f0b0-4047-9e91-627dbcc9c0f7/TCGA-CV-7100-01Z-00-DX1.44DFCAC1-2567-40E7-8F03-AF1FB742B012.svs 71321 39157 1 +/data/TCGA/69b80e9a-f0b0-4047-9e91-627dbcc9c0f7/TCGA-CV-7100-01Z-00-DX1.44DFCAC1-2567-40E7-8F03-AF1FB742B012.svs 63212 58388 2 +/data/TCGA/69b80e9a-f0b0-4047-9e91-627dbcc9c0f7/TCGA-CV-7100-01Z-00-DX1.44DFCAC1-2567-40E7-8F03-AF1FB742B012.svs 91407 19638 3 +/data/TCGA/05300e28-4efa-4a3e-87af-7b85df349ac0/TCGA-85-A4PA-01Z-00-DX1.00AF818F-39BA-4EA7-8873-9B6C4F2D2141.svs 49019 28548 0 +/data/TCGA/05300e28-4efa-4a3e-87af-7b85df349ac0/TCGA-85-A4PA-01Z-00-DX1.00AF818F-39BA-4EA7-8873-9B6C4F2D2141.svs 67904 49684 1 +/data/TCGA/05300e28-4efa-4a3e-87af-7b85df349ac0/TCGA-85-A4PA-01Z-00-DX1.00AF818F-39BA-4EA7-8873-9B6C4F2D2141.svs 13578 54812 2 +/data/TCGA/05300e28-4efa-4a3e-87af-7b85df349ac0/TCGA-85-A4PA-01Z-00-DX1.00AF818F-39BA-4EA7-8873-9B6C4F2D2141.svs 63583 50842 3 +/data/TCGA/26251a1c-1c06-49b9-a3d4-042b000797d1/TCGA-V1-A9OA-01Z-00-DX1.72156A18-EA88-4004-9644-1279CCE895B9.svs 12444 59796 0 +/data/TCGA/26251a1c-1c06-49b9-a3d4-042b000797d1/TCGA-V1-A9OA-01Z-00-DX1.72156A18-EA88-4004-9644-1279CCE895B9.svs 12247 53665 1 +/data/TCGA/26251a1c-1c06-49b9-a3d4-042b000797d1/TCGA-V1-A9OA-01Z-00-DX1.72156A18-EA88-4004-9644-1279CCE895B9.svs 71605 38576 2 +/data/TCGA/26251a1c-1c06-49b9-a3d4-042b000797d1/TCGA-V1-A9OA-01Z-00-DX1.72156A18-EA88-4004-9644-1279CCE895B9.svs 45930 15472 3 +/data/TCGA/e6403fae-13b1-4a23-9f4a-588db50ca429/TCGA-G3-A25W-01Z-00-DX1.F5423764-6A48-46C3-8967-99B845524860.svs 62800 30775 0 +/data/TCGA/e6403fae-13b1-4a23-9f4a-588db50ca429/TCGA-G3-A25W-01Z-00-DX1.F5423764-6A48-46C3-8967-99B845524860.svs 42908 57358 1 +/data/TCGA/e6403fae-13b1-4a23-9f4a-588db50ca429/TCGA-G3-A25W-01Z-00-DX1.F5423764-6A48-46C3-8967-99B845524860.svs 72911 48576 2 +/data/TCGA/e6403fae-13b1-4a23-9f4a-588db50ca429/TCGA-G3-A25W-01Z-00-DX1.F5423764-6A48-46C3-8967-99B845524860.svs 55518 15645 3 +/data/TCGA/f6e75081-256c-489e-a050-f9574b6ce4d3/TCGA-14-0817-01Z-00-DX3.636820c0-c393-4590-bbe6-b56fe29e6b28.svs 20509 27861 0 +/data/TCGA/f6e75081-256c-489e-a050-f9574b6ce4d3/TCGA-14-0817-01Z-00-DX3.636820c0-c393-4590-bbe6-b56fe29e6b28.svs 26948 2076 1 +/data/TCGA/f6e75081-256c-489e-a050-f9574b6ce4d3/TCGA-14-0817-01Z-00-DX3.636820c0-c393-4590-bbe6-b56fe29e6b28.svs 10246 25549 2 +/data/TCGA/6df2ce76-d222-43b2-9dd7-da0a28ad1d87/TCGA-44-A4SU-01Z-00-DX1.AE2607C1-B208-4557-ADB4-6AAF03C6D3A9.svs 106191 13127 0 +/data/TCGA/6df2ce76-d222-43b2-9dd7-da0a28ad1d87/TCGA-44-A4SU-01Z-00-DX1.AE2607C1-B208-4557-ADB4-6AAF03C6D3A9.svs 155512 10852 1 +/data/TCGA/6df2ce76-d222-43b2-9dd7-da0a28ad1d87/TCGA-44-A4SU-01Z-00-DX1.AE2607C1-B208-4557-ADB4-6AAF03C6D3A9.svs 163704 27173 2 +/data/TCGA/6df2ce76-d222-43b2-9dd7-da0a28ad1d87/TCGA-44-A4SU-01Z-00-DX1.AE2607C1-B208-4557-ADB4-6AAF03C6D3A9.svs 161391 20784 3 +/data/TCGA/2f21d4ce-cc8c-4ccb-b91e-3780cce55249/TCGA-AF-2693-01Z-00-DX1.620a9998-65df-4024-b719-f2384b4e7d36.svs 58378 19193 0 +/data/TCGA/2f21d4ce-cc8c-4ccb-b91e-3780cce55249/TCGA-AF-2693-01Z-00-DX1.620a9998-65df-4024-b719-f2384b4e7d36.svs 14493 41989 1 +/data/TCGA/2f21d4ce-cc8c-4ccb-b91e-3780cce55249/TCGA-AF-2693-01Z-00-DX1.620a9998-65df-4024-b719-f2384b4e7d36.svs 6413 32344 2 +/data/TCGA/2f21d4ce-cc8c-4ccb-b91e-3780cce55249/TCGA-AF-2693-01Z-00-DX1.620a9998-65df-4024-b719-f2384b4e7d36.svs 108285 6581 3 +/data/TCGA/52e4875e-bc62-4b9c-9788-efe1d5f08b17/TCGA-CV-7243-01Z-00-DX1.CA696306-9918-43B2-AB96-18C96CF346F0.svs 49852 54411 0 +/data/TCGA/52e4875e-bc62-4b9c-9788-efe1d5f08b17/TCGA-CV-7243-01Z-00-DX1.CA696306-9918-43B2-AB96-18C96CF346F0.svs 52348 46480 1 +/data/TCGA/52e4875e-bc62-4b9c-9788-efe1d5f08b17/TCGA-CV-7243-01Z-00-DX1.CA696306-9918-43B2-AB96-18C96CF346F0.svs 17863 44907 2 +/data/TCGA/52e4875e-bc62-4b9c-9788-efe1d5f08b17/TCGA-CV-7243-01Z-00-DX1.CA696306-9918-43B2-AB96-18C96CF346F0.svs 71865 34754 3 +/data/TCGA/400fea7d-8200-47f5-9df2-5c4e73f8251e/TCGA-V1-A9OQ-01Z-00-DX1.6B57FA2E-B1D8-4CA4-B0E7-401A33ED93B4.svs 38288 67098 0 +/data/TCGA/400fea7d-8200-47f5-9df2-5c4e73f8251e/TCGA-V1-A9OQ-01Z-00-DX1.6B57FA2E-B1D8-4CA4-B0E7-401A33ED93B4.svs 77718 39918 1 +/data/TCGA/400fea7d-8200-47f5-9df2-5c4e73f8251e/TCGA-V1-A9OQ-01Z-00-DX1.6B57FA2E-B1D8-4CA4-B0E7-401A33ED93B4.svs 71180 20627 2 +/data/TCGA/400fea7d-8200-47f5-9df2-5c4e73f8251e/TCGA-V1-A9OQ-01Z-00-DX1.6B57FA2E-B1D8-4CA4-B0E7-401A33ED93B4.svs 56816 51856 3 +/data/TCGA/5eb5b839-54b0-4f0c-8218-3ab7167eb195/TCGA-P5-A735-01Z-00-DX1.BCFB0C97-0D3A-40E0-8925-952CFFAC7084.svs 32684 72457 0 +/data/TCGA/5eb5b839-54b0-4f0c-8218-3ab7167eb195/TCGA-P5-A735-01Z-00-DX1.BCFB0C97-0D3A-40E0-8925-952CFFAC7084.svs 89141 61999 1 +/data/TCGA/5eb5b839-54b0-4f0c-8218-3ab7167eb195/TCGA-P5-A735-01Z-00-DX1.BCFB0C97-0D3A-40E0-8925-952CFFAC7084.svs 11107 43424 2 +/data/TCGA/5eb5b839-54b0-4f0c-8218-3ab7167eb195/TCGA-P5-A735-01Z-00-DX1.BCFB0C97-0D3A-40E0-8925-952CFFAC7084.svs 9805 27568 3 +/data/TCGA/2011bccc-dfb3-43be-b34a-39fff2696aac/TCGA-GV-A3JV-01Z-00-DX1.F071374F-1290-4A36-9466-D6F1F3EBC17E.svs 74826 31139 0 +/data/TCGA/2011bccc-dfb3-43be-b34a-39fff2696aac/TCGA-GV-A3JV-01Z-00-DX1.F071374F-1290-4A36-9466-D6F1F3EBC17E.svs 69390 16508 1 +/data/TCGA/2011bccc-dfb3-43be-b34a-39fff2696aac/TCGA-GV-A3JV-01Z-00-DX1.F071374F-1290-4A36-9466-D6F1F3EBC17E.svs 61544 26265 2 +/data/TCGA/2011bccc-dfb3-43be-b34a-39fff2696aac/TCGA-GV-A3JV-01Z-00-DX1.F071374F-1290-4A36-9466-D6F1F3EBC17E.svs 71474 32059 3 +/data/TCGA/b8fb6bcd-9e90-4081-a20e-6ea83ddaa7f8/TCGA-12-0775-01Z-00-DX2.cc33eab4-0b03-466f-ac91-a8fc77d2c598.svs 2699 36399 0 +/data/TCGA/b8fb6bcd-9e90-4081-a20e-6ea83ddaa7f8/TCGA-12-0775-01Z-00-DX2.cc33eab4-0b03-466f-ac91-a8fc77d2c598.svs 13744 26994 1 +/data/TCGA/b8fb6bcd-9e90-4081-a20e-6ea83ddaa7f8/TCGA-12-0775-01Z-00-DX2.cc33eab4-0b03-466f-ac91-a8fc77d2c598.svs 3410 1189 2 +/data/TCGA/dfd5251e-3d1c-4418-aa33-32e3dd9bc421/TCGA-QR-A6GZ-01Z-00-DX1.BAF6842F-B2DC-4B0A-9894-23A21DA06737.svs 76961 27703 0 +/data/TCGA/dfd5251e-3d1c-4418-aa33-32e3dd9bc421/TCGA-QR-A6GZ-01Z-00-DX1.BAF6842F-B2DC-4B0A-9894-23A21DA06737.svs 75498 38579 1 +/data/TCGA/dfd5251e-3d1c-4418-aa33-32e3dd9bc421/TCGA-QR-A6GZ-01Z-00-DX1.BAF6842F-B2DC-4B0A-9894-23A21DA06737.svs 25640 39731 2 +/data/TCGA/dfd5251e-3d1c-4418-aa33-32e3dd9bc421/TCGA-QR-A6GZ-01Z-00-DX1.BAF6842F-B2DC-4B0A-9894-23A21DA06737.svs 20086 9055 3 +/data/TCGA/c98ac35c-202a-484a-90fa-67fe3af9d96b/TCGA-BS-A0WQ-01Z-00-DX1.44C7712D-E8FF-452A-A9E4-626EA888EF6E.svs 23910 18895 0 +/data/TCGA/c98ac35c-202a-484a-90fa-67fe3af9d96b/TCGA-BS-A0WQ-01Z-00-DX1.44C7712D-E8FF-452A-A9E4-626EA888EF6E.svs 105256 3511 1 +/data/TCGA/c98ac35c-202a-484a-90fa-67fe3af9d96b/TCGA-BS-A0WQ-01Z-00-DX1.44C7712D-E8FF-452A-A9E4-626EA888EF6E.svs 21305 75296 2 +/data/TCGA/c98ac35c-202a-484a-90fa-67fe3af9d96b/TCGA-BS-A0WQ-01Z-00-DX1.44C7712D-E8FF-452A-A9E4-626EA888EF6E.svs 91034 52778 3 +/data/TCGA/a03c1632-9d71-443f-9e6f-f4c40e628270/TCGA-4X-A9F9-01Z-00-DX5.FD3E746D-9242-4A74-85DB-3FE7B6759343.svs 16627 41738 0 +/data/TCGA/a03c1632-9d71-443f-9e6f-f4c40e628270/TCGA-4X-A9F9-01Z-00-DX5.FD3E746D-9242-4A74-85DB-3FE7B6759343.svs 53343 67840 1 +/data/TCGA/a03c1632-9d71-443f-9e6f-f4c40e628270/TCGA-4X-A9F9-01Z-00-DX5.FD3E746D-9242-4A74-85DB-3FE7B6759343.svs 36423 7238 2 +/data/TCGA/a03c1632-9d71-443f-9e6f-f4c40e628270/TCGA-4X-A9F9-01Z-00-DX5.FD3E746D-9242-4A74-85DB-3FE7B6759343.svs 74558 36088 3 +/data/TCGA/021307ef-f6e9-4816-ac34-16f20112119a/TCGA-CQ-7065-01Z-00-DX1.083ed2a3-9074-4e48-b950-7255ca54ce77.svs 31894 35414 0 +/data/TCGA/021307ef-f6e9-4816-ac34-16f20112119a/TCGA-CQ-7065-01Z-00-DX1.083ed2a3-9074-4e48-b950-7255ca54ce77.svs 48303 27274 1 +/data/TCGA/021307ef-f6e9-4816-ac34-16f20112119a/TCGA-CQ-7065-01Z-00-DX1.083ed2a3-9074-4e48-b950-7255ca54ce77.svs 9314 14079 2 +/data/TCGA/16f5b6fd-2784-4cd7-bf84-8fc063783d64/TCGA-ER-A19P-01Z-00-DX1.5B9541C0-0651-4E35-B2CB-0F6E52E6BACA.svs 67732 44773 0 +/data/TCGA/16f5b6fd-2784-4cd7-bf84-8fc063783d64/TCGA-ER-A19P-01Z-00-DX1.5B9541C0-0651-4E35-B2CB-0F6E52E6BACA.svs 32109 11446 1 +/data/TCGA/16f5b6fd-2784-4cd7-bf84-8fc063783d64/TCGA-ER-A19P-01Z-00-DX1.5B9541C0-0651-4E35-B2CB-0F6E52E6BACA.svs 77212 72969 2 +/data/TCGA/16f5b6fd-2784-4cd7-bf84-8fc063783d64/TCGA-ER-A19P-01Z-00-DX1.5B9541C0-0651-4E35-B2CB-0F6E52E6BACA.svs 88359 29784 3 +/data/TCGA/ebc80dc8-4954-43dd-87ad-8e128ed5688a/TCGA-J8-A4HW-01Z-00-DX1.51EEBB5E-DD1E-4071-9885-C100581AD924.svs 77477 13055 0 +/data/TCGA/ebc80dc8-4954-43dd-87ad-8e128ed5688a/TCGA-J8-A4HW-01Z-00-DX1.51EEBB5E-DD1E-4071-9885-C100581AD924.svs 53192 37194 1 +/data/TCGA/ebc80dc8-4954-43dd-87ad-8e128ed5688a/TCGA-J8-A4HW-01Z-00-DX1.51EEBB5E-DD1E-4071-9885-C100581AD924.svs 55073 48857 2 +/data/TCGA/ebc80dc8-4954-43dd-87ad-8e128ed5688a/TCGA-J8-A4HW-01Z-00-DX1.51EEBB5E-DD1E-4071-9885-C100581AD924.svs 53174 12186 3 +/data/TCGA/f1c9d035-fdcd-44f9-9a8f-ae320dd492c0/TCGA-DX-A6YU-01Z-00-DX2.F7731784-D39C-4896-80B3-F4625927269E.svs 92442 66763 0 +/data/TCGA/f1c9d035-fdcd-44f9-9a8f-ae320dd492c0/TCGA-DX-A6YU-01Z-00-DX2.F7731784-D39C-4896-80B3-F4625927269E.svs 86352 63628 1 +/data/TCGA/f1c9d035-fdcd-44f9-9a8f-ae320dd492c0/TCGA-DX-A6YU-01Z-00-DX2.F7731784-D39C-4896-80B3-F4625927269E.svs 20747 46011 2 +/data/TCGA/f1c9d035-fdcd-44f9-9a8f-ae320dd492c0/TCGA-DX-A6YU-01Z-00-DX2.F7731784-D39C-4896-80B3-F4625927269E.svs 49313 52444 3 +/data/TCGA/3e9c706f-1c7a-471c-b0c7-12664d79b784/TCGA-CV-7099-01Z-00-DX1.7FECEF6F-9690-4331-A80C-ABACC8E5BC31.svs 66239 36163 0 +/data/TCGA/3e9c706f-1c7a-471c-b0c7-12664d79b784/TCGA-CV-7099-01Z-00-DX1.7FECEF6F-9690-4331-A80C-ABACC8E5BC31.svs 66002 10734 1 +/data/TCGA/3e9c706f-1c7a-471c-b0c7-12664d79b784/TCGA-CV-7099-01Z-00-DX1.7FECEF6F-9690-4331-A80C-ABACC8E5BC31.svs 56721 22028 2 +/data/TCGA/3e9c706f-1c7a-471c-b0c7-12664d79b784/TCGA-CV-7099-01Z-00-DX1.7FECEF6F-9690-4331-A80C-ABACC8E5BC31.svs 11160 13785 3 +/data/TCGA/2bd9bf05-e9ce-4c21-b261-2d0f4c5dee5c/TCGA-PD-A5DF-01Z-00-DX1.B7E4EDA0-1168-45E4-A18E-5BD247D7DEA6.svs 40320 16212 0 +/data/TCGA/2bd9bf05-e9ce-4c21-b261-2d0f4c5dee5c/TCGA-PD-A5DF-01Z-00-DX1.B7E4EDA0-1168-45E4-A18E-5BD247D7DEA6.svs 6745 28836 1 +/data/TCGA/2bd9bf05-e9ce-4c21-b261-2d0f4c5dee5c/TCGA-PD-A5DF-01Z-00-DX1.B7E4EDA0-1168-45E4-A18E-5BD247D7DEA6.svs 24453 11777 2 +/data/TCGA/2bd9bf05-e9ce-4c21-b261-2d0f4c5dee5c/TCGA-PD-A5DF-01Z-00-DX1.B7E4EDA0-1168-45E4-A18E-5BD247D7DEA6.svs 42832 9124 3 +/data/TCGA/2d9ce6c5-b484-4d2a-ac03-91965f4cad76/TCGA-AC-A8OQ-01Z-00-DX1.15946A44-711C-4765-AB46-5CFB7BD11E42.svs 34246 15892 0 +/data/TCGA/2d9ce6c5-b484-4d2a-ac03-91965f4cad76/TCGA-AC-A8OQ-01Z-00-DX1.15946A44-711C-4765-AB46-5CFB7BD11E42.svs 45393 46697 1 +/data/TCGA/2d9ce6c5-b484-4d2a-ac03-91965f4cad76/TCGA-AC-A8OQ-01Z-00-DX1.15946A44-711C-4765-AB46-5CFB7BD11E42.svs 49522 41096 2 +/data/TCGA/2d9ce6c5-b484-4d2a-ac03-91965f4cad76/TCGA-AC-A8OQ-01Z-00-DX1.15946A44-711C-4765-AB46-5CFB7BD11E42.svs 33924 35349 3 +/data/TCGA/468a0892-8e7f-4fb4-a559-59d7d245db20/TCGA-QR-A6GY-01Z-00-DX1.26952E33-1102-4B00-9124-D367D505480F.svs 74483 36638 0 +/data/TCGA/468a0892-8e7f-4fb4-a559-59d7d245db20/TCGA-QR-A6GY-01Z-00-DX1.26952E33-1102-4B00-9124-D367D505480F.svs 58018 58388 1 +/data/TCGA/468a0892-8e7f-4fb4-a559-59d7d245db20/TCGA-QR-A6GY-01Z-00-DX1.26952E33-1102-4B00-9124-D367D505480F.svs 43411 16737 2 +/data/TCGA/468a0892-8e7f-4fb4-a559-59d7d245db20/TCGA-QR-A6GY-01Z-00-DX1.26952E33-1102-4B00-9124-D367D505480F.svs 52271 15763 3 +/data/TCGA/de953cbb-0204-4e2a-90e4-85d52c05fae8/TCGA-SI-A71O-01Z-00-DX4.C708238B-27A8-4947-ABBA-3566A07830CF.svs 102075 37966 0 +/data/TCGA/de953cbb-0204-4e2a-90e4-85d52c05fae8/TCGA-SI-A71O-01Z-00-DX4.C708238B-27A8-4947-ABBA-3566A07830CF.svs 77539 17239 1 +/data/TCGA/de953cbb-0204-4e2a-90e4-85d52c05fae8/TCGA-SI-A71O-01Z-00-DX4.C708238B-27A8-4947-ABBA-3566A07830CF.svs 75282 55409 2 +/data/TCGA/de953cbb-0204-4e2a-90e4-85d52c05fae8/TCGA-SI-A71O-01Z-00-DX4.C708238B-27A8-4947-ABBA-3566A07830CF.svs 83919 33792 3 +/data/TCGA/dd256db7-c923-400f-8ed0-c6784bc00fca/TCGA-BJ-A0ZC-01Z-00-DX1.1E22C86F-CE70-4D3C-8D13-9DAAE07DAE12.svs 108953 40517 0 +/data/TCGA/dd256db7-c923-400f-8ed0-c6784bc00fca/TCGA-BJ-A0ZC-01Z-00-DX1.1E22C86F-CE70-4D3C-8D13-9DAAE07DAE12.svs 86854 31421 1 +/data/TCGA/dd256db7-c923-400f-8ed0-c6784bc00fca/TCGA-BJ-A0ZC-01Z-00-DX1.1E22C86F-CE70-4D3C-8D13-9DAAE07DAE12.svs 42462 33576 2 +/data/TCGA/dd256db7-c923-400f-8ed0-c6784bc00fca/TCGA-BJ-A0ZC-01Z-00-DX1.1E22C86F-CE70-4D3C-8D13-9DAAE07DAE12.svs 103186 15813 3 +/data/TCGA/cc8a5f81-ae95-4dab-9f66-cfbc79e21b03/TCGA-D9-A4Z5-01Z-00-DX1.88AC8735-B520-4FCE-BC0B-AA6A611CE2D7.svs 70981 47723 0 +/data/TCGA/cc8a5f81-ae95-4dab-9f66-cfbc79e21b03/TCGA-D9-A4Z5-01Z-00-DX1.88AC8735-B520-4FCE-BC0B-AA6A611CE2D7.svs 50578 40757 1 +/data/TCGA/cc8a5f81-ae95-4dab-9f66-cfbc79e21b03/TCGA-D9-A4Z5-01Z-00-DX1.88AC8735-B520-4FCE-BC0B-AA6A611CE2D7.svs 43918 11745 2 +/data/TCGA/cc8a5f81-ae95-4dab-9f66-cfbc79e21b03/TCGA-D9-A4Z5-01Z-00-DX1.88AC8735-B520-4FCE-BC0B-AA6A611CE2D7.svs 55200 33328 3 +/data/TCGA/f89ccebb-fa19-49cd-adf3-0117726181f6/TCGA-C4-A0EZ-01Z-00-DX1.993A12F0-9687-4E56-B887-13C9453A7E63.svs 12422 39227 0 +/data/TCGA/f89ccebb-fa19-49cd-adf3-0117726181f6/TCGA-C4-A0EZ-01Z-00-DX1.993A12F0-9687-4E56-B887-13C9453A7E63.svs 16011 37720 1 +/data/TCGA/f89ccebb-fa19-49cd-adf3-0117726181f6/TCGA-C4-A0EZ-01Z-00-DX1.993A12F0-9687-4E56-B887-13C9453A7E63.svs 6349 7489 2 +/data/TCGA/28410694-cefe-46c5-813f-7b2b3bda7be8/TCGA-CJ-4876-01Z-00-DX1.CE682056-925D-456B-AD68-53975CC082D5.svs 38829 24379 0 +/data/TCGA/28410694-cefe-46c5-813f-7b2b3bda7be8/TCGA-CJ-4876-01Z-00-DX1.CE682056-925D-456B-AD68-53975CC082D5.svs 18014 62091 1 +/data/TCGA/28410694-cefe-46c5-813f-7b2b3bda7be8/TCGA-CJ-4876-01Z-00-DX1.CE682056-925D-456B-AD68-53975CC082D5.svs 29115 21842 2 +/data/TCGA/28410694-cefe-46c5-813f-7b2b3bda7be8/TCGA-CJ-4876-01Z-00-DX1.CE682056-925D-456B-AD68-53975CC082D5.svs 19679 12244 3 +/data/TCGA/a7ec1676-b8c8-4c16-be7b-7c3a37064349/TCGA-12-0776-01Z-00-DX2.7b121b0e-50f2-4dac-99e8-0cdbb81b473a.svs 39250 30995 0 +/data/TCGA/a7ec1676-b8c8-4c16-be7b-7c3a37064349/TCGA-12-0776-01Z-00-DX2.7b121b0e-50f2-4dac-99e8-0cdbb81b473a.svs 72047 32028 1 +/data/TCGA/a7ec1676-b8c8-4c16-be7b-7c3a37064349/TCGA-12-0776-01Z-00-DX2.7b121b0e-50f2-4dac-99e8-0cdbb81b473a.svs 52812 30048 2 +/data/TCGA/55eb1c6a-2290-4458-afa2-f259d80e6395/TCGA-LL-A5YN-01Z-00-DX1.F221939B-3680-4B95-93A9-BE8599550E87.svs 14341 71945 0 +/data/TCGA/55eb1c6a-2290-4458-afa2-f259d80e6395/TCGA-LL-A5YN-01Z-00-DX1.F221939B-3680-4B95-93A9-BE8599550E87.svs 55425 75966 1 +/data/TCGA/55eb1c6a-2290-4458-afa2-f259d80e6395/TCGA-LL-A5YN-01Z-00-DX1.F221939B-3680-4B95-93A9-BE8599550E87.svs 66495 13100 2 +/data/TCGA/55eb1c6a-2290-4458-afa2-f259d80e6395/TCGA-LL-A5YN-01Z-00-DX1.F221939B-3680-4B95-93A9-BE8599550E87.svs 43509 15198 3 +/data/TCGA/a70ba77f-da3a-4f7b-bbce-dd7f11892c3f/TCGA-BH-A42T-01Z-00-DX1.6E4609B9-BE7E-4CA9-A1C0-A77A7DEFBB2B.svs 38391 44552 0 +/data/TCGA/a70ba77f-da3a-4f7b-bbce-dd7f11892c3f/TCGA-BH-A42T-01Z-00-DX1.6E4609B9-BE7E-4CA9-A1C0-A77A7DEFBB2B.svs 75193 38998 1 +/data/TCGA/a70ba77f-da3a-4f7b-bbce-dd7f11892c3f/TCGA-BH-A42T-01Z-00-DX1.6E4609B9-BE7E-4CA9-A1C0-A77A7DEFBB2B.svs 83175 73992 2 +/data/TCGA/a70ba77f-da3a-4f7b-bbce-dd7f11892c3f/TCGA-BH-A42T-01Z-00-DX1.6E4609B9-BE7E-4CA9-A1C0-A77A7DEFBB2B.svs 66480 56578 3 +/data/TCGA/d96d0ecd-dfa0-44df-8741-166d3a304c01/TCGA-AR-A0TT-01Z-00-DX1.127C2A4F-62AC-4E83-99DB-13519BD2949D.svs 22545 48796 0 +/data/TCGA/d96d0ecd-dfa0-44df-8741-166d3a304c01/TCGA-AR-A0TT-01Z-00-DX1.127C2A4F-62AC-4E83-99DB-13519BD2949D.svs 56411 50468 1 +/data/TCGA/d96d0ecd-dfa0-44df-8741-166d3a304c01/TCGA-AR-A0TT-01Z-00-DX1.127C2A4F-62AC-4E83-99DB-13519BD2949D.svs 46441 27336 2 +/data/TCGA/d96d0ecd-dfa0-44df-8741-166d3a304c01/TCGA-AR-A0TT-01Z-00-DX1.127C2A4F-62AC-4E83-99DB-13519BD2949D.svs 22536 36764 3 +/data/TCGA/59e57f1d-9bca-4bcc-9dd6-90565d487deb/TCGA-06-0197-01Z-00-DX1.8b3d8c3f-2320-4ab4-a9aa-e3b8a68d267f.svs 8931 15832 0 +/data/TCGA/59e57f1d-9bca-4bcc-9dd6-90565d487deb/TCGA-06-0197-01Z-00-DX1.8b3d8c3f-2320-4ab4-a9aa-e3b8a68d267f.svs 22126 23925 1 +/data/TCGA/59e57f1d-9bca-4bcc-9dd6-90565d487deb/TCGA-06-0197-01Z-00-DX1.8b3d8c3f-2320-4ab4-a9aa-e3b8a68d267f.svs 9375 9933 2 +/data/TCGA/d98df6d2-927e-4988-97ca-ba9a237f962e/TCGA-FZ-5921-01Z-00-DX1.1120F4F2-EBDD-436F-B83F-D524C9BA887D.svs 31244 15624 0 +/data/TCGA/d98df6d2-927e-4988-97ca-ba9a237f962e/TCGA-FZ-5921-01Z-00-DX1.1120F4F2-EBDD-436F-B83F-D524C9BA887D.svs 36125 70635 1 +/data/TCGA/d98df6d2-927e-4988-97ca-ba9a237f962e/TCGA-FZ-5921-01Z-00-DX1.1120F4F2-EBDD-436F-B83F-D524C9BA887D.svs 64683 57113 2 +/data/TCGA/d98df6d2-927e-4988-97ca-ba9a237f962e/TCGA-FZ-5921-01Z-00-DX1.1120F4F2-EBDD-436F-B83F-D524C9BA887D.svs 29688 54704 3 +/data/TCGA/cdc3b920-928f-4fdb-acc3-2bb2bffe0190/TCGA-CV-7261-01Z-00-DX1.3D2FFD24-B6EE-4FA3-ACCB-5D02215B35BA.svs 28224 49878 0 +/data/TCGA/cdc3b920-928f-4fdb-acc3-2bb2bffe0190/TCGA-CV-7261-01Z-00-DX1.3D2FFD24-B6EE-4FA3-ACCB-5D02215B35BA.svs 26792 39708 1 +/data/TCGA/cdc3b920-928f-4fdb-acc3-2bb2bffe0190/TCGA-CV-7261-01Z-00-DX1.3D2FFD24-B6EE-4FA3-ACCB-5D02215B35BA.svs 31324 29370 2 +/data/TCGA/cdc3b920-928f-4fdb-acc3-2bb2bffe0190/TCGA-CV-7261-01Z-00-DX1.3D2FFD24-B6EE-4FA3-ACCB-5D02215B35BA.svs 58139 26634 3 +/data/TCGA/a2496bb4-3af8-45f4-a75e-701973fa5141/TCGA-EL-A3T0-01Z-00-DX1.CB54731B-689F-473D-B7DE-2109197CC1CA.svs 60062 44532 0 +/data/TCGA/a2496bb4-3af8-45f4-a75e-701973fa5141/TCGA-EL-A3T0-01Z-00-DX1.CB54731B-689F-473D-B7DE-2109197CC1CA.svs 58997 19117 1 +/data/TCGA/a2496bb4-3af8-45f4-a75e-701973fa5141/TCGA-EL-A3T0-01Z-00-DX1.CB54731B-689F-473D-B7DE-2109197CC1CA.svs 71804 12931 2 +/data/TCGA/a2496bb4-3af8-45f4-a75e-701973fa5141/TCGA-EL-A3T0-01Z-00-DX1.CB54731B-689F-473D-B7DE-2109197CC1CA.svs 57764 59314 3 +/data/TCGA/fd2189dd-7b08-49b5-9791-c2129059e25c/TCGA-VD-A8KE-01Z-00-DX1.E1611C2F-76E9-48E3-BADF-FA5FAA613746.svs 39846 20108 0 +/data/TCGA/fd2189dd-7b08-49b5-9791-c2129059e25c/TCGA-VD-A8KE-01Z-00-DX1.E1611C2F-76E9-48E3-BADF-FA5FAA613746.svs 6845 31306 1 +/data/TCGA/fd2189dd-7b08-49b5-9791-c2129059e25c/TCGA-VD-A8KE-01Z-00-DX1.E1611C2F-76E9-48E3-BADF-FA5FAA613746.svs 37366 4429 2 +/data/TCGA/90a3bc8f-20d9-41b5-a092-24727574be53/TCGA-D3-A2JC-06Z-00-DX1.C5D339EB-672E-41B5-BB6F-008D22E84E1B.svs 18029 8491 0 +/data/TCGA/90a3bc8f-20d9-41b5-a092-24727574be53/TCGA-D3-A2JC-06Z-00-DX1.C5D339EB-672E-41B5-BB6F-008D22E84E1B.svs 34232 8524 1 +/data/TCGA/90a3bc8f-20d9-41b5-a092-24727574be53/TCGA-D3-A2JC-06Z-00-DX1.C5D339EB-672E-41B5-BB6F-008D22E84E1B.svs 27334 30723 2 +/data/TCGA/47f5d311-5d71-4659-84eb-e0ac29d55e3d/TCGA-DI-A1NN-01Z-00-DX1.D95D5127-9E1D-4B26-BE00-60F7C3B09B4F.svs 33395 28612 0 +/data/TCGA/47f5d311-5d71-4659-84eb-e0ac29d55e3d/TCGA-DI-A1NN-01Z-00-DX1.D95D5127-9E1D-4B26-BE00-60F7C3B09B4F.svs 40821 25709 1 +/data/TCGA/47f5d311-5d71-4659-84eb-e0ac29d55e3d/TCGA-DI-A1NN-01Z-00-DX1.D95D5127-9E1D-4B26-BE00-60F7C3B09B4F.svs 58689 39407 2 +/data/TCGA/47f5d311-5d71-4659-84eb-e0ac29d55e3d/TCGA-DI-A1NN-01Z-00-DX1.D95D5127-9E1D-4B26-BE00-60F7C3B09B4F.svs 30950 14513 3 +/data/TCGA/73ecb0cf-3ffd-41a8-8a2b-87f40d3fb52e/TCGA-GU-A42Q-01Z-00-DX2.91D8B0D2-538F-4411-9B3C-0E1FAE1A0606.svs 68938 20376 0 +/data/TCGA/73ecb0cf-3ffd-41a8-8a2b-87f40d3fb52e/TCGA-GU-A42Q-01Z-00-DX2.91D8B0D2-538F-4411-9B3C-0E1FAE1A0606.svs 81339 37055 1 +/data/TCGA/73ecb0cf-3ffd-41a8-8a2b-87f40d3fb52e/TCGA-GU-A42Q-01Z-00-DX2.91D8B0D2-538F-4411-9B3C-0E1FAE1A0606.svs 82592 16193 2 +/data/TCGA/73ecb0cf-3ffd-41a8-8a2b-87f40d3fb52e/TCGA-GU-A42Q-01Z-00-DX2.91D8B0D2-538F-4411-9B3C-0E1FAE1A0606.svs 34682 47948 3 +/data/TCGA/6627c046-20d1-4bdb-b3e8-b7e04e04d8e9/TCGA-VM-A8CB-01Z-00-DX3.4DAB7FB0-0C2E-43D8-9E4F-F5C1720AA78F.svs 78653 36553 0 +/data/TCGA/6627c046-20d1-4bdb-b3e8-b7e04e04d8e9/TCGA-VM-A8CB-01Z-00-DX3.4DAB7FB0-0C2E-43D8-9E4F-F5C1720AA78F.svs 94423 25052 1 +/data/TCGA/6627c046-20d1-4bdb-b3e8-b7e04e04d8e9/TCGA-VM-A8CB-01Z-00-DX3.4DAB7FB0-0C2E-43D8-9E4F-F5C1720AA78F.svs 45827 80423 2 +/data/TCGA/6627c046-20d1-4bdb-b3e8-b7e04e04d8e9/TCGA-VM-A8CB-01Z-00-DX3.4DAB7FB0-0C2E-43D8-9E4F-F5C1720AA78F.svs 48622 74840 3 +/data/TCGA/b2f68a40-3bda-41f2-80d5-328427aeffcb/TCGA-77-8154-01Z-00-DX1.5ca9afa5-e5d8-46d7-b542-c27649bd214e.svs 15473 49662 0 +/data/TCGA/b2f68a40-3bda-41f2-80d5-328427aeffcb/TCGA-77-8154-01Z-00-DX1.5ca9afa5-e5d8-46d7-b542-c27649bd214e.svs 60199 40281 1 +/data/TCGA/b2f68a40-3bda-41f2-80d5-328427aeffcb/TCGA-77-8154-01Z-00-DX1.5ca9afa5-e5d8-46d7-b542-c27649bd214e.svs 61203 16808 2 +/data/TCGA/b2f68a40-3bda-41f2-80d5-328427aeffcb/TCGA-77-8154-01Z-00-DX1.5ca9afa5-e5d8-46d7-b542-c27649bd214e.svs 13573 44781 3 +/data/TCGA/55cfce5e-3972-42e7-ab90-0c41e7c35a1e/TCGA-XD-AAUI-01Z-00-DX2.2B58D278-0405-4829-A01D-A058C7DF5887.svs 52980 36819 0 +/data/TCGA/55cfce5e-3972-42e7-ab90-0c41e7c35a1e/TCGA-XD-AAUI-01Z-00-DX2.2B58D278-0405-4829-A01D-A058C7DF5887.svs 21146 38103 1 +/data/TCGA/55cfce5e-3972-42e7-ab90-0c41e7c35a1e/TCGA-XD-AAUI-01Z-00-DX2.2B58D278-0405-4829-A01D-A058C7DF5887.svs 16626 16108 2 +/data/TCGA/55cfce5e-3972-42e7-ab90-0c41e7c35a1e/TCGA-XD-AAUI-01Z-00-DX2.2B58D278-0405-4829-A01D-A058C7DF5887.svs 56619 17160 3 +/data/TCGA/15e6bdca-4b99-4f3f-a7fc-efeeac411015/TCGA-CH-5752-01Z-00-DX1.3a204644-6fa2-4bbd-a2b0-d40f13385dcf.svs 29806 23977 0 +/data/TCGA/15e6bdca-4b99-4f3f-a7fc-efeeac411015/TCGA-CH-5752-01Z-00-DX1.3a204644-6fa2-4bbd-a2b0-d40f13385dcf.svs 71280 27729 1 +/data/TCGA/15e6bdca-4b99-4f3f-a7fc-efeeac411015/TCGA-CH-5752-01Z-00-DX1.3a204644-6fa2-4bbd-a2b0-d40f13385dcf.svs 49871 9962 2 +/data/TCGA/15e6bdca-4b99-4f3f-a7fc-efeeac411015/TCGA-CH-5752-01Z-00-DX1.3a204644-6fa2-4bbd-a2b0-d40f13385dcf.svs 68258 12475 3 +/data/TCGA/1635baee-047c-431a-8fcb-712f734c572f/TCGA-QT-A5XJ-01Z-00-DX1.496EBB8D-BC20-4FDD-877F-AF7CCD9B3C3A.svs 66285 77104 0 +/data/TCGA/1635baee-047c-431a-8fcb-712f734c572f/TCGA-QT-A5XJ-01Z-00-DX1.496EBB8D-BC20-4FDD-877F-AF7CCD9B3C3A.svs 56682 36048 1 +/data/TCGA/1635baee-047c-431a-8fcb-712f734c572f/TCGA-QT-A5XJ-01Z-00-DX1.496EBB8D-BC20-4FDD-877F-AF7CCD9B3C3A.svs 94496 50572 2 +/data/TCGA/1635baee-047c-431a-8fcb-712f734c572f/TCGA-QT-A5XJ-01Z-00-DX1.496EBB8D-BC20-4FDD-877F-AF7CCD9B3C3A.svs 49308 56892 3 +/data/TCGA/bcd2ace3-e917-43dd-acfa-8fe1d5262e37/TCGA-BP-4759-01Z-00-DX1.077e7051-ed46-4cf6-9ede-c08a2b635279.svs 27587 57761 0 +/data/TCGA/bcd2ace3-e917-43dd-acfa-8fe1d5262e37/TCGA-BP-4759-01Z-00-DX1.077e7051-ed46-4cf6-9ede-c08a2b635279.svs 9557 16640 1 +/data/TCGA/bcd2ace3-e917-43dd-acfa-8fe1d5262e37/TCGA-BP-4759-01Z-00-DX1.077e7051-ed46-4cf6-9ede-c08a2b635279.svs 12169 35601 2 +/data/TCGA/bcd2ace3-e917-43dd-acfa-8fe1d5262e37/TCGA-BP-4759-01Z-00-DX1.077e7051-ed46-4cf6-9ede-c08a2b635279.svs 39160 12325 3 +/data/TCGA/f51f1618-a90f-461e-9f55-b0a1f91c9350/TCGA-AG-3593-01Z-00-DX1.d3086414-77f4-483f-bac8-d7cb29a0689e.svs 32972 72089 0 +/data/TCGA/f51f1618-a90f-461e-9f55-b0a1f91c9350/TCGA-AG-3593-01Z-00-DX1.d3086414-77f4-483f-bac8-d7cb29a0689e.svs 26032 6712 1 +/data/TCGA/f51f1618-a90f-461e-9f55-b0a1f91c9350/TCGA-AG-3593-01Z-00-DX1.d3086414-77f4-483f-bac8-d7cb29a0689e.svs 37778 17213 2 +/data/TCGA/f51f1618-a90f-461e-9f55-b0a1f91c9350/TCGA-AG-3593-01Z-00-DX1.d3086414-77f4-483f-bac8-d7cb29a0689e.svs 41089 41793 3 +/data/TCGA/8bb9896d-ef4a-4050-9699-dafe404724a6/TCGA-AA-3952-01Z-00-DX1.6a51a689-74cb-4204-9f7a-f5e3fc55fb2d.svs 7125 14928 0 +/data/TCGA/8bb9896d-ef4a-4050-9699-dafe404724a6/TCGA-AA-3952-01Z-00-DX1.6a51a689-74cb-4204-9f7a-f5e3fc55fb2d.svs 20101 14598 1 +/data/TCGA/8bb9896d-ef4a-4050-9699-dafe404724a6/TCGA-AA-3952-01Z-00-DX1.6a51a689-74cb-4204-9f7a-f5e3fc55fb2d.svs 20604 16529 2 +/data/TCGA/8bb9896d-ef4a-4050-9699-dafe404724a6/TCGA-AA-3952-01Z-00-DX1.6a51a689-74cb-4204-9f7a-f5e3fc55fb2d.svs 19478 15088 3 +/data/TCGA/8637c8c2-87ee-4dad-980f-427b4d5b4958/TCGA-CV-6433-01Z-00-DX1.069ACB4F-226C-40B6-A141-0E2A1788E68E.svs 60011 55648 0 +/data/TCGA/8637c8c2-87ee-4dad-980f-427b4d5b4958/TCGA-CV-6433-01Z-00-DX1.069ACB4F-226C-40B6-A141-0E2A1788E68E.svs 22517 37370 1 +/data/TCGA/8637c8c2-87ee-4dad-980f-427b4d5b4958/TCGA-CV-6433-01Z-00-DX1.069ACB4F-226C-40B6-A141-0E2A1788E68E.svs 44748 65808 2 +/data/TCGA/8637c8c2-87ee-4dad-980f-427b4d5b4958/TCGA-CV-6433-01Z-00-DX1.069ACB4F-226C-40B6-A141-0E2A1788E68E.svs 62079 16241 3 +/data/TCGA/20ceea6c-99f3-4053-ae49-6da60d3526c1/TCGA-AR-A1AP-01Z-00-DX1.F163EED5-0385-41AA-BA35-54E4910CD99E.svs 39293 27843 0 +/data/TCGA/20ceea6c-99f3-4053-ae49-6da60d3526c1/TCGA-AR-A1AP-01Z-00-DX1.F163EED5-0385-41AA-BA35-54E4910CD99E.svs 10408 36910 1 +/data/TCGA/20ceea6c-99f3-4053-ae49-6da60d3526c1/TCGA-AR-A1AP-01Z-00-DX1.F163EED5-0385-41AA-BA35-54E4910CD99E.svs 31771 35080 2 +/data/TCGA/20ceea6c-99f3-4053-ae49-6da60d3526c1/TCGA-AR-A1AP-01Z-00-DX1.F163EED5-0385-41AA-BA35-54E4910CD99E.svs 7366 11943 3 +/data/TCGA/033ca180-8ae6-4219-9978-29c828ea3ac3/TCGA-56-A49D-01Z-00-DX1.1ECF40A0-1490-42B3-8924-A80E4ED35F93.svs 77741 52495 0 +/data/TCGA/033ca180-8ae6-4219-9978-29c828ea3ac3/TCGA-56-A49D-01Z-00-DX1.1ECF40A0-1490-42B3-8924-A80E4ED35F93.svs 40165 30727 1 +/data/TCGA/033ca180-8ae6-4219-9978-29c828ea3ac3/TCGA-56-A49D-01Z-00-DX1.1ECF40A0-1490-42B3-8924-A80E4ED35F93.svs 42003 8835 2 +/data/TCGA/033ca180-8ae6-4219-9978-29c828ea3ac3/TCGA-56-A49D-01Z-00-DX1.1ECF40A0-1490-42B3-8924-A80E4ED35F93.svs 72171 28283 3 +/data/TCGA/a6f67f61-3c77-4b7d-be80-7f510a985d3c/TCGA-B8-4146-01Z-00-DX1.0F0EECE2-3ECC-4CEB-AAAC-DCE2AAF8E7CA.svs 82173 34336 0 +/data/TCGA/a6f67f61-3c77-4b7d-be80-7f510a985d3c/TCGA-B8-4146-01Z-00-DX1.0F0EECE2-3ECC-4CEB-AAAC-DCE2AAF8E7CA.svs 65027 32328 1 +/data/TCGA/a6f67f61-3c77-4b7d-be80-7f510a985d3c/TCGA-B8-4146-01Z-00-DX1.0F0EECE2-3ECC-4CEB-AAAC-DCE2AAF8E7CA.svs 28124 34560 2 +/data/TCGA/a6f67f61-3c77-4b7d-be80-7f510a985d3c/TCGA-B8-4146-01Z-00-DX1.0F0EECE2-3ECC-4CEB-AAAC-DCE2AAF8E7CA.svs 12211 21323 3 +/data/TCGA/d9bddf2b-971c-4289-b36a-536849ee3df8/TCGA-ND-A4WA-01Z-00-DX2.071A8B48-72E2-4872-AB73-47B5F5F76440.svs 5062 35492 0 +/data/TCGA/d9bddf2b-971c-4289-b36a-536849ee3df8/TCGA-ND-A4WA-01Z-00-DX2.071A8B48-72E2-4872-AB73-47B5F5F76440.svs 55046 76787 1 +/data/TCGA/d9bddf2b-971c-4289-b36a-536849ee3df8/TCGA-ND-A4WA-01Z-00-DX2.071A8B48-72E2-4872-AB73-47B5F5F76440.svs 70328 59996 2 +/data/TCGA/d9bddf2b-971c-4289-b36a-536849ee3df8/TCGA-ND-A4WA-01Z-00-DX2.071A8B48-72E2-4872-AB73-47B5F5F76440.svs 56720 44559 3 +/data/TCGA/0df98250-46e9-4440-a518-7a27cc9a2a22/TCGA-VM-A8C8-01Z-00-DX9.07AAC35A-A609-479F-843E-1E759A922AFA.svs 27548 17112 0 +/data/TCGA/0df98250-46e9-4440-a518-7a27cc9a2a22/TCGA-VM-A8C8-01Z-00-DX9.07AAC35A-A609-479F-843E-1E759A922AFA.svs 16062 9752 1 +/data/TCGA/0df98250-46e9-4440-a518-7a27cc9a2a22/TCGA-VM-A8C8-01Z-00-DX9.07AAC35A-A609-479F-843E-1E759A922AFA.svs 5222 4451 2 +/data/TCGA/23944f66-e85d-48b9-b2ba-e78d933637da/TCGA-YL-A8HM-01Z-00-DX1.FE98403B-ABE4-4E5E-B036-FD590741FB11.svs 40202 7756 0 +/data/TCGA/23944f66-e85d-48b9-b2ba-e78d933637da/TCGA-YL-A8HM-01Z-00-DX1.FE98403B-ABE4-4E5E-B036-FD590741FB11.svs 74663 42351 1 +/data/TCGA/23944f66-e85d-48b9-b2ba-e78d933637da/TCGA-YL-A8HM-01Z-00-DX1.FE98403B-ABE4-4E5E-B036-FD590741FB11.svs 67480 51754 2 +/data/TCGA/23944f66-e85d-48b9-b2ba-e78d933637da/TCGA-YL-A8HM-01Z-00-DX1.FE98403B-ABE4-4E5E-B036-FD590741FB11.svs 37502 7665 3 +/data/TCGA/471a8da1-a4a0-4d44-9c73-4f64207f2eba/TCGA-K4-A6MB-01Z-00-DX1.4A6009D3-05D9-4E8B-8EB2-4A52B5B6FED8.svs 51143 49721 0 +/data/TCGA/471a8da1-a4a0-4d44-9c73-4f64207f2eba/TCGA-K4-A6MB-01Z-00-DX1.4A6009D3-05D9-4E8B-8EB2-4A52B5B6FED8.svs 44988 28834 1 +/data/TCGA/471a8da1-a4a0-4d44-9c73-4f64207f2eba/TCGA-K4-A6MB-01Z-00-DX1.4A6009D3-05D9-4E8B-8EB2-4A52B5B6FED8.svs 22335 27019 2 +/data/TCGA/471a8da1-a4a0-4d44-9c73-4f64207f2eba/TCGA-K4-A6MB-01Z-00-DX1.4A6009D3-05D9-4E8B-8EB2-4A52B5B6FED8.svs 57472 50253 3 +/data/TCGA/2cf2dcfa-339f-44fa-9ae4-c872b54ce821/TCGA-CQ-7071-01Z-00-DX1.AEFEDFCA-0D2F-42AE-8D3F-8D9DD42F5E2D.svs 14759 15706 0 +/data/TCGA/2cf2dcfa-339f-44fa-9ae4-c872b54ce821/TCGA-CQ-7071-01Z-00-DX1.AEFEDFCA-0D2F-42AE-8D3F-8D9DD42F5E2D.svs 30484 5020 1 +/data/TCGA/2cf2dcfa-339f-44fa-9ae4-c872b54ce821/TCGA-CQ-7071-01Z-00-DX1.AEFEDFCA-0D2F-42AE-8D3F-8D9DD42F5E2D.svs 22381 6507 2 +/data/TCGA/0fb798df-02e1-4973-9161-f773d4028b17/TCGA-CN-6018-01Z-00-DX1.77855643-92a9-40a7-b4a8-0e32b89fc597.svs 29191 25466 0 +/data/TCGA/0fb798df-02e1-4973-9161-f773d4028b17/TCGA-CN-6018-01Z-00-DX1.77855643-92a9-40a7-b4a8-0e32b89fc597.svs 9977 14119 1 +/data/TCGA/0fb798df-02e1-4973-9161-f773d4028b17/TCGA-CN-6018-01Z-00-DX1.77855643-92a9-40a7-b4a8-0e32b89fc597.svs 24609 14244 2 +/data/TCGA/0fb798df-02e1-4973-9161-f773d4028b17/TCGA-CN-6018-01Z-00-DX1.77855643-92a9-40a7-b4a8-0e32b89fc597.svs 15185 7015 3 +/data/TCGA/e84eb97d-f0bf-4664-9748-28999b9053f8/TCGA-CV-7101-01Z-00-DX1.0EBF4A94-904A-416D-ACB3-A7E2581AD832.svs 57007 26518 0 +/data/TCGA/e84eb97d-f0bf-4664-9748-28999b9053f8/TCGA-CV-7101-01Z-00-DX1.0EBF4A94-904A-416D-ACB3-A7E2581AD832.svs 61929 22738 1 +/data/TCGA/e84eb97d-f0bf-4664-9748-28999b9053f8/TCGA-CV-7101-01Z-00-DX1.0EBF4A94-904A-416D-ACB3-A7E2581AD832.svs 70818 50413 2 +/data/TCGA/e84eb97d-f0bf-4664-9748-28999b9053f8/TCGA-CV-7101-01Z-00-DX1.0EBF4A94-904A-416D-ACB3-A7E2581AD832.svs 83767 33325 3 +/data/TCGA/8d0e593f-adbb-4b56-a5e0-3821cf2a6f50/TCGA-GV-A40E-01Z-00-DX1.6313DD1A-6E65-4775-82DC-58AD4EF81D32.svs 31918 60091 0 +/data/TCGA/8d0e593f-adbb-4b56-a5e0-3821cf2a6f50/TCGA-GV-A40E-01Z-00-DX1.6313DD1A-6E65-4775-82DC-58AD4EF81D32.svs 81921 32953 1 +/data/TCGA/8d0e593f-adbb-4b56-a5e0-3821cf2a6f50/TCGA-GV-A40E-01Z-00-DX1.6313DD1A-6E65-4775-82DC-58AD4EF81D32.svs 36992 59896 2 +/data/TCGA/8d0e593f-adbb-4b56-a5e0-3821cf2a6f50/TCGA-GV-A40E-01Z-00-DX1.6313DD1A-6E65-4775-82DC-58AD4EF81D32.svs 73079 35718 3 +/data/TCGA/e5b413a1-62a2-4ee7-8f23-c9db6478ef3c/TCGA-DJ-A2Q2-01Z-00-DX1.3CA0FEAB-FFA1-46C6-9558-E98F7746B451.svs 64685 82074 0 +/data/TCGA/e5b413a1-62a2-4ee7-8f23-c9db6478ef3c/TCGA-DJ-A2Q2-01Z-00-DX1.3CA0FEAB-FFA1-46C6-9558-E98F7746B451.svs 88060 26880 1 +/data/TCGA/e5b413a1-62a2-4ee7-8f23-c9db6478ef3c/TCGA-DJ-A2Q2-01Z-00-DX1.3CA0FEAB-FFA1-46C6-9558-E98F7746B451.svs 20125 51096 2 +/data/TCGA/e5b413a1-62a2-4ee7-8f23-c9db6478ef3c/TCGA-DJ-A2Q2-01Z-00-DX1.3CA0FEAB-FFA1-46C6-9558-E98F7746B451.svs 55785 39608 3 +/data/TCGA/73f56900-3347-471e-a135-3ed548899916/TCGA-DY-A1DD-01Z-00-DX1.0F175E9D-FB44-4F06-B052-4D747D1AF820.svs 47202 59073 0 +/data/TCGA/73f56900-3347-471e-a135-3ed548899916/TCGA-DY-A1DD-01Z-00-DX1.0F175E9D-FB44-4F06-B052-4D747D1AF820.svs 34941 62533 1 +/data/TCGA/73f56900-3347-471e-a135-3ed548899916/TCGA-DY-A1DD-01Z-00-DX1.0F175E9D-FB44-4F06-B052-4D747D1AF820.svs 30981 22090 2 +/data/TCGA/73f56900-3347-471e-a135-3ed548899916/TCGA-DY-A1DD-01Z-00-DX1.0F175E9D-FB44-4F06-B052-4D747D1AF820.svs 18559 8920 3 +/data/TCGA/e74d2fd1-9218-4a79-a749-4f3947a4cf81/TCGA-FI-A2EW-01Z-00-DX1.93D21AD2-076D-4685-A027-623C294974A5.svs 37457 32586 0 +/data/TCGA/e74d2fd1-9218-4a79-a749-4f3947a4cf81/TCGA-FI-A2EW-01Z-00-DX1.93D21AD2-076D-4685-A027-623C294974A5.svs 90991 61848 1 +/data/TCGA/e74d2fd1-9218-4a79-a749-4f3947a4cf81/TCGA-FI-A2EW-01Z-00-DX1.93D21AD2-076D-4685-A027-623C294974A5.svs 34130 54271 2 +/data/TCGA/e74d2fd1-9218-4a79-a749-4f3947a4cf81/TCGA-FI-A2EW-01Z-00-DX1.93D21AD2-076D-4685-A027-623C294974A5.svs 53260 14930 3 +/data/TCGA/11bc5de7-4ceb-4141-b1c7-66200c203838/TCGA-CJ-5689-01Z-00-DX1.1CA26D07-2719-4EE4-98F8-01E0551E937C.svs 36826 14841 0 +/data/TCGA/11bc5de7-4ceb-4141-b1c7-66200c203838/TCGA-CJ-5689-01Z-00-DX1.1CA26D07-2719-4EE4-98F8-01E0551E937C.svs 44119 5320 1 +/data/TCGA/11bc5de7-4ceb-4141-b1c7-66200c203838/TCGA-CJ-5689-01Z-00-DX1.1CA26D07-2719-4EE4-98F8-01E0551E937C.svs 12453 9656 2 +/data/TCGA/11bc5de7-4ceb-4141-b1c7-66200c203838/TCGA-CJ-5689-01Z-00-DX1.1CA26D07-2719-4EE4-98F8-01E0551E937C.svs 60655 5198 3 +/data/TCGA/d14d5041-6ea8-431a-82e7-ba3f98e88711/TCGA-05-4403-01Z-00-DX1.fee8e988-956c-42a2-a6c5-06b6d6736295.svs 75331 32225 0 +/data/TCGA/d14d5041-6ea8-431a-82e7-ba3f98e88711/TCGA-05-4403-01Z-00-DX1.fee8e988-956c-42a2-a6c5-06b6d6736295.svs 59893 22890 1 +/data/TCGA/d14d5041-6ea8-431a-82e7-ba3f98e88711/TCGA-05-4403-01Z-00-DX1.fee8e988-956c-42a2-a6c5-06b6d6736295.svs 56035 19938 2 +/data/TCGA/d14d5041-6ea8-431a-82e7-ba3f98e88711/TCGA-05-4403-01Z-00-DX1.fee8e988-956c-42a2-a6c5-06b6d6736295.svs 59592 20994 3 +/data/TCGA/1eeb07a9-ded0-45c0-bc60-427c838bca96/TCGA-ET-A39S-01Z-00-DX1.078746BC-33B7-47A2-A6D8-F5B2E6180E30.svs 56961 36076 0 +/data/TCGA/1eeb07a9-ded0-45c0-bc60-427c838bca96/TCGA-ET-A39S-01Z-00-DX1.078746BC-33B7-47A2-A6D8-F5B2E6180E30.svs 46030 26233 1 +/data/TCGA/1eeb07a9-ded0-45c0-bc60-427c838bca96/TCGA-ET-A39S-01Z-00-DX1.078746BC-33B7-47A2-A6D8-F5B2E6180E30.svs 52791 15386 2 +/data/TCGA/1eeb07a9-ded0-45c0-bc60-427c838bca96/TCGA-ET-A39S-01Z-00-DX1.078746BC-33B7-47A2-A6D8-F5B2E6180E30.svs 56712 18038 3 +/data/TCGA/4435d738-8b91-4ea3-929a-62185303382c/TCGA-12-1602-01Z-00-DX2.35505B4C-3613-4536-9B8D-36283BDD9E9C.svs 46069 31774 0 +/data/TCGA/4435d738-8b91-4ea3-929a-62185303382c/TCGA-12-1602-01Z-00-DX2.35505B4C-3613-4536-9B8D-36283BDD9E9C.svs 23346 19315 1 +/data/TCGA/4435d738-8b91-4ea3-929a-62185303382c/TCGA-12-1602-01Z-00-DX2.35505B4C-3613-4536-9B8D-36283BDD9E9C.svs 24502 18801 2 +/data/TCGA/03a3b15b-74cd-4290-8114-690332ca41e9/TCGA-OR-A5K4-01Z-00-DX4.695A41ED-E745-4473-99E0-95A103774905.svs 7103 59626 0 +/data/TCGA/03a3b15b-74cd-4290-8114-690332ca41e9/TCGA-OR-A5K4-01Z-00-DX4.695A41ED-E745-4473-99E0-95A103774905.svs 30325 78521 1 +/data/TCGA/03a3b15b-74cd-4290-8114-690332ca41e9/TCGA-OR-A5K4-01Z-00-DX4.695A41ED-E745-4473-99E0-95A103774905.svs 12322 55543 2 +/data/TCGA/03a3b15b-74cd-4290-8114-690332ca41e9/TCGA-OR-A5K4-01Z-00-DX4.695A41ED-E745-4473-99E0-95A103774905.svs 15827 32933 3 +/data/TCGA/e4e08050-868e-40a6-a197-19b274bcb7c1/TCGA-BR-4253-01Z-00-DX1.1541e883-de6a-4cd3-a6f5-6866fd5f3439.svs 681 816 0 +/data/TCGA/b740c836-c964-4fa0-b82b-f061919bebb6/TCGA-HU-A4GJ-01Z-00-DX1.31E71066-5B7B-4866-97A0-0B7B03E6B4B6.svs 11601 22806 0 +/data/TCGA/b740c836-c964-4fa0-b82b-f061919bebb6/TCGA-HU-A4GJ-01Z-00-DX1.31E71066-5B7B-4866-97A0-0B7B03E6B4B6.svs 12593 22651 1 +/data/TCGA/b740c836-c964-4fa0-b82b-f061919bebb6/TCGA-HU-A4GJ-01Z-00-DX1.31E71066-5B7B-4866-97A0-0B7B03E6B4B6.svs 8727 12046 2 +/data/TCGA/01fe54a6-9ec6-41b8-b625-df0e213262b8/TCGA-55-1596-01Z-00-DX1.de65522d-92ab-408e-9b7e-24210d386b97.svs 33926 17477 0 +/data/TCGA/01fe54a6-9ec6-41b8-b625-df0e213262b8/TCGA-55-1596-01Z-00-DX1.de65522d-92ab-408e-9b7e-24210d386b97.svs 101283 37200 1 +/data/TCGA/01fe54a6-9ec6-41b8-b625-df0e213262b8/TCGA-55-1596-01Z-00-DX1.de65522d-92ab-408e-9b7e-24210d386b97.svs 106295 50067 2 +/data/TCGA/01fe54a6-9ec6-41b8-b625-df0e213262b8/TCGA-55-1596-01Z-00-DX1.de65522d-92ab-408e-9b7e-24210d386b97.svs 115251 34965 3 +/data/TCGA/73441874-00ec-46f7-8ffc-c2f1b3692436/TCGA-CV-7416-01Z-00-DX1.6084AAA1-CBB4-448D-A902-6ADCE3D4936F.svs 25229 32677 0 +/data/TCGA/73441874-00ec-46f7-8ffc-c2f1b3692436/TCGA-CV-7416-01Z-00-DX1.6084AAA1-CBB4-448D-A902-6ADCE3D4936F.svs 27017 11221 1 +/data/TCGA/73441874-00ec-46f7-8ffc-c2f1b3692436/TCGA-CV-7416-01Z-00-DX1.6084AAA1-CBB4-448D-A902-6ADCE3D4936F.svs 12879 32494 2 +/data/TCGA/73441874-00ec-46f7-8ffc-c2f1b3692436/TCGA-CV-7416-01Z-00-DX1.6084AAA1-CBB4-448D-A902-6ADCE3D4936F.svs 31218 26031 3 +/data/TCGA/17280bdc-b51f-4929-8cd0-19e7dca7b583/TCGA-FG-A4MT-02Z-00-DX5.BC137126-2035-4629-BCCF-EDDD39CC7178.svs 48171 53767 0 +/data/TCGA/17280bdc-b51f-4929-8cd0-19e7dca7b583/TCGA-FG-A4MT-02Z-00-DX5.BC137126-2035-4629-BCCF-EDDD39CC7178.svs 58765 8194 1 +/data/TCGA/17280bdc-b51f-4929-8cd0-19e7dca7b583/TCGA-FG-A4MT-02Z-00-DX5.BC137126-2035-4629-BCCF-EDDD39CC7178.svs 13246 48964 2 +/data/TCGA/17280bdc-b51f-4929-8cd0-19e7dca7b583/TCGA-FG-A4MT-02Z-00-DX5.BC137126-2035-4629-BCCF-EDDD39CC7178.svs 58573 18713 3 +/data/TCGA/693f08b6-64da-4709-9de3-05323df5f7b3/TCGA-DX-A6YX-01Z-00-DX3.88F898BE-E478-466F-A532-5256601D3E0F.svs 69387 31282 0 +/data/TCGA/693f08b6-64da-4709-9de3-05323df5f7b3/TCGA-DX-A6YX-01Z-00-DX3.88F898BE-E478-466F-A532-5256601D3E0F.svs 84576 68883 1 +/data/TCGA/693f08b6-64da-4709-9de3-05323df5f7b3/TCGA-DX-A6YX-01Z-00-DX3.88F898BE-E478-466F-A532-5256601D3E0F.svs 23584 45873 2 +/data/TCGA/693f08b6-64da-4709-9de3-05323df5f7b3/TCGA-DX-A6YX-01Z-00-DX3.88F898BE-E478-466F-A532-5256601D3E0F.svs 78748 25500 3 +/data/TCGA/d3f90a7f-eafb-40d3-9477-98bce179b328/TCGA-DX-A2J1-01Z-00-DX1.51522171-EBCA-4A16-8F39-E794211F8B94.svs 19876 60703 0 +/data/TCGA/d3f90a7f-eafb-40d3-9477-98bce179b328/TCGA-DX-A2J1-01Z-00-DX1.51522171-EBCA-4A16-8F39-E794211F8B94.svs 23339 62561 1 +/data/TCGA/d3f90a7f-eafb-40d3-9477-98bce179b328/TCGA-DX-A2J1-01Z-00-DX1.51522171-EBCA-4A16-8F39-E794211F8B94.svs 13874 40348 2 +/data/TCGA/d3f90a7f-eafb-40d3-9477-98bce179b328/TCGA-DX-A2J1-01Z-00-DX1.51522171-EBCA-4A16-8F39-E794211F8B94.svs 15561 20057 3 +/data/TCGA/8c68a1f6-e43d-4bd1-80c3-262312bf1e71/TCGA-DU-A7TD-01Z-00-DX1.CDC41902-3673-4FDA-B4A5-4A453CF1362C.svs 21208 5222 0 +/data/TCGA/8c68a1f6-e43d-4bd1-80c3-262312bf1e71/TCGA-DU-A7TD-01Z-00-DX1.CDC41902-3673-4FDA-B4A5-4A453CF1362C.svs 16088 15146 1 +/data/TCGA/8c68a1f6-e43d-4bd1-80c3-262312bf1e71/TCGA-DU-A7TD-01Z-00-DX1.CDC41902-3673-4FDA-B4A5-4A453CF1362C.svs 17423 4255 2 +/data/TCGA/48d0502c-877d-4d92-9a6e-4719a21524cf/TCGA-XU-AAXW-01Z-00-DX1.10122AB7-4541-4AC7-994F-AE25AF190DD5.svs 41147 57342 0 +/data/TCGA/48d0502c-877d-4d92-9a6e-4719a21524cf/TCGA-XU-AAXW-01Z-00-DX1.10122AB7-4541-4AC7-994F-AE25AF190DD5.svs 98084 23314 1 +/data/TCGA/48d0502c-877d-4d92-9a6e-4719a21524cf/TCGA-XU-AAXW-01Z-00-DX1.10122AB7-4541-4AC7-994F-AE25AF190DD5.svs 90881 39487 2 +/data/TCGA/48d0502c-877d-4d92-9a6e-4719a21524cf/TCGA-XU-AAXW-01Z-00-DX1.10122AB7-4541-4AC7-994F-AE25AF190DD5.svs 69074 16180 3 +/data/TCGA/73258aa9-4391-4d96-ad64-67f2080417f4/TCGA-14-1401-01Z-00-DX3.9c8079a8-47b1-4c85-8dc7-96c3a3229eab.svs 28784 11547 0 +/data/TCGA/73258aa9-4391-4d96-ad64-67f2080417f4/TCGA-14-1401-01Z-00-DX3.9c8079a8-47b1-4c85-8dc7-96c3a3229eab.svs 25451 10001 1 +/data/TCGA/73258aa9-4391-4d96-ad64-67f2080417f4/TCGA-14-1401-01Z-00-DX3.9c8079a8-47b1-4c85-8dc7-96c3a3229eab.svs 27808 20356 2 +/data/TCGA/e2a873ef-535b-4d4c-be97-0e9be9a4cdf1/TCGA-Z6-A8JD-01Z-00-DX1.6BB5BC5F-B96F-4548-96E8-84891F36B0B3.svs 31301 26799 0 +/data/TCGA/e2a873ef-535b-4d4c-be97-0e9be9a4cdf1/TCGA-Z6-A8JD-01Z-00-DX1.6BB5BC5F-B96F-4548-96E8-84891F36B0B3.svs 11449 15870 1 +/data/TCGA/e2a873ef-535b-4d4c-be97-0e9be9a4cdf1/TCGA-Z6-A8JD-01Z-00-DX1.6BB5BC5F-B96F-4548-96E8-84891F36B0B3.svs 15201 61604 2 +/data/TCGA/e2a873ef-535b-4d4c-be97-0e9be9a4cdf1/TCGA-Z6-A8JD-01Z-00-DX1.6BB5BC5F-B96F-4548-96E8-84891F36B0B3.svs 27644 21528 3 +/data/TCGA/9d647d80-da58-4cae-a67e-9a73a59cf0c8/TCGA-AF-6655-01Z-00-DX1.c7c5a2ca-1954-4c72-b99f-3b543566f325.svs 18558 2068 0 +/data/TCGA/9d647d80-da58-4cae-a67e-9a73a59cf0c8/TCGA-AF-6655-01Z-00-DX1.c7c5a2ca-1954-4c72-b99f-3b543566f325.svs 18643 12946 1 +/data/TCGA/9d647d80-da58-4cae-a67e-9a73a59cf0c8/TCGA-AF-6655-01Z-00-DX1.c7c5a2ca-1954-4c72-b99f-3b543566f325.svs 99848 19282 2 +/data/TCGA/9d647d80-da58-4cae-a67e-9a73a59cf0c8/TCGA-AF-6655-01Z-00-DX1.c7c5a2ca-1954-4c72-b99f-3b543566f325.svs 93381 22608 3 +/data/TCGA/75df0722-d8bc-4519-9c44-e9b4b0d9882f/TCGA-RC-A6M4-01Z-00-DX1.94EFD979-FEEF-406D-8253-EC9969682615.svs 17192 11595 0 +/data/TCGA/75df0722-d8bc-4519-9c44-e9b4b0d9882f/TCGA-RC-A6M4-01Z-00-DX1.94EFD979-FEEF-406D-8253-EC9969682615.svs 45644 4607 1 +/data/TCGA/75df0722-d8bc-4519-9c44-e9b4b0d9882f/TCGA-RC-A6M4-01Z-00-DX1.94EFD979-FEEF-406D-8253-EC9969682615.svs 83472 38473 2 +/data/TCGA/75df0722-d8bc-4519-9c44-e9b4b0d9882f/TCGA-RC-A6M4-01Z-00-DX1.94EFD979-FEEF-406D-8253-EC9969682615.svs 42948 7647 3 +/data/TCGA/f1322cb6-00bd-412c-9756-141810010b76/TCGA-KL-8332-01Z-00-DX1.3a375f5f-38e4-4022-8b36-5d8547870417.svs 95499 576 0 +/data/TCGA/f1322cb6-00bd-412c-9756-141810010b76/TCGA-KL-8332-01Z-00-DX1.3a375f5f-38e4-4022-8b36-5d8547870417.svs 33073 7332 1 +/data/TCGA/f1322cb6-00bd-412c-9756-141810010b76/TCGA-KL-8332-01Z-00-DX1.3a375f5f-38e4-4022-8b36-5d8547870417.svs 13872 72256 2 +/data/TCGA/f1322cb6-00bd-412c-9756-141810010b76/TCGA-KL-8332-01Z-00-DX1.3a375f5f-38e4-4022-8b36-5d8547870417.svs 16645 25874 3 +/data/TCGA/4fb60901-faaa-4fca-b3ca-6e5be4f0ecf6/TCGA-DJ-A13V-01Z-00-DX1.88661EBD-6B7A-4EF3-95B1-9CAF38B4BCF2.svs 61585 26470 0 +/data/TCGA/4fb60901-faaa-4fca-b3ca-6e5be4f0ecf6/TCGA-DJ-A13V-01Z-00-DX1.88661EBD-6B7A-4EF3-95B1-9CAF38B4BCF2.svs 91844 4017 1 +/data/TCGA/4fb60901-faaa-4fca-b3ca-6e5be4f0ecf6/TCGA-DJ-A13V-01Z-00-DX1.88661EBD-6B7A-4EF3-95B1-9CAF38B4BCF2.svs 69704 60565 2 +/data/TCGA/4fb60901-faaa-4fca-b3ca-6e5be4f0ecf6/TCGA-DJ-A13V-01Z-00-DX1.88661EBD-6B7A-4EF3-95B1-9CAF38B4BCF2.svs 65595 13506 3 +/data/TCGA/14a9f1fa-3ec1-4b42-bbf4-9290b0382f92/TCGA-BH-A0DS-01Z-00-DX1.38E82A1F-21B9-4B97-A304-15B886EA68A0.svs 91470 54178 0 +/data/TCGA/14a9f1fa-3ec1-4b42-bbf4-9290b0382f92/TCGA-BH-A0DS-01Z-00-DX1.38E82A1F-21B9-4B97-A304-15B886EA68A0.svs 59220 69128 1 +/data/TCGA/14a9f1fa-3ec1-4b42-bbf4-9290b0382f92/TCGA-BH-A0DS-01Z-00-DX1.38E82A1F-21B9-4B97-A304-15B886EA68A0.svs 68892 48114 2 +/data/TCGA/14a9f1fa-3ec1-4b42-bbf4-9290b0382f92/TCGA-BH-A0DS-01Z-00-DX1.38E82A1F-21B9-4B97-A304-15B886EA68A0.svs 53848 41543 3 +/data/TCGA/8f139e90-b100-4d64-92d8-11f6b2704067/TCGA-LA-A7SW-01Z-00-DX1.A65863F5-EA8F-46F5-A4D1-52FAD3D93E26.svs 64319 37886 0 +/data/TCGA/8f139e90-b100-4d64-92d8-11f6b2704067/TCGA-LA-A7SW-01Z-00-DX1.A65863F5-EA8F-46F5-A4D1-52FAD3D93E26.svs 44289 59394 1 +/data/TCGA/8f139e90-b100-4d64-92d8-11f6b2704067/TCGA-LA-A7SW-01Z-00-DX1.A65863F5-EA8F-46F5-A4D1-52FAD3D93E26.svs 69425 22366 2 +/data/TCGA/8f139e90-b100-4d64-92d8-11f6b2704067/TCGA-LA-A7SW-01Z-00-DX1.A65863F5-EA8F-46F5-A4D1-52FAD3D93E26.svs 59299 34555 3 +/data/TCGA/b0098ada-75cf-4cbb-9868-1bae2652c26f/TCGA-BP-4801-01Z-00-DX1.69e0e4d9-dc88-4010-acec-15183034b356.svs 38255 13513 0 +/data/TCGA/b0098ada-75cf-4cbb-9868-1bae2652c26f/TCGA-BP-4801-01Z-00-DX1.69e0e4d9-dc88-4010-acec-15183034b356.svs 24521 7226 1 +/data/TCGA/b0098ada-75cf-4cbb-9868-1bae2652c26f/TCGA-BP-4801-01Z-00-DX1.69e0e4d9-dc88-4010-acec-15183034b356.svs 77554 50347 2 +/data/TCGA/b0098ada-75cf-4cbb-9868-1bae2652c26f/TCGA-BP-4801-01Z-00-DX1.69e0e4d9-dc88-4010-acec-15183034b356.svs 40185 6444 3 +/data/TCGA/db76f842-7d3c-4b40-ae16-50c6c312b7ca/TCGA-14-1795-01Z-00-DX1.ef38b022-4f63-4ec2-a26b-3900d6bc73fc.svs 60976 12970 0 +/data/TCGA/db76f842-7d3c-4b40-ae16-50c6c312b7ca/TCGA-14-1795-01Z-00-DX1.ef38b022-4f63-4ec2-a26b-3900d6bc73fc.svs 15482 2027 1 +/data/TCGA/db76f842-7d3c-4b40-ae16-50c6c312b7ca/TCGA-14-1795-01Z-00-DX1.ef38b022-4f63-4ec2-a26b-3900d6bc73fc.svs 1454 17978 2 +/data/TCGA/db76f842-7d3c-4b40-ae16-50c6c312b7ca/TCGA-14-1795-01Z-00-DX1.ef38b022-4f63-4ec2-a26b-3900d6bc73fc.svs 8366 14661 3 +/data/TCGA/7543669d-a832-480e-84b5-b619148c6bfa/TCGA-AN-A0XS-01Z-00-DX1.B4D4B73E-2912-4B2E-B18A-FBC35F8160D3.svs 23719 14278 0 +/data/TCGA/7543669d-a832-480e-84b5-b619148c6bfa/TCGA-AN-A0XS-01Z-00-DX1.B4D4B73E-2912-4B2E-B18A-FBC35F8160D3.svs 40195 26946 1 +/data/TCGA/7543669d-a832-480e-84b5-b619148c6bfa/TCGA-AN-A0XS-01Z-00-DX1.B4D4B73E-2912-4B2E-B18A-FBC35F8160D3.svs 36717 12028 2 +/data/TCGA/7543669d-a832-480e-84b5-b619148c6bfa/TCGA-AN-A0XS-01Z-00-DX1.B4D4B73E-2912-4B2E-B18A-FBC35F8160D3.svs 39795 13874 3 +/data/TCGA/016f10ac-1ea2-4c07-8291-b9ef62fd7567/TCGA-ER-A2NE-01Z-00-DX1.C015AF50-4603-46C7-BF1E-B0258A049BFF.svs 39693 75753 0 +/data/TCGA/016f10ac-1ea2-4c07-8291-b9ef62fd7567/TCGA-ER-A2NE-01Z-00-DX1.C015AF50-4603-46C7-BF1E-B0258A049BFF.svs 88663 27347 1 +/data/TCGA/016f10ac-1ea2-4c07-8291-b9ef62fd7567/TCGA-ER-A2NE-01Z-00-DX1.C015AF50-4603-46C7-BF1E-B0258A049BFF.svs 28094 63417 2 +/data/TCGA/016f10ac-1ea2-4c07-8291-b9ef62fd7567/TCGA-ER-A2NE-01Z-00-DX1.C015AF50-4603-46C7-BF1E-B0258A049BFF.svs 39094 69438 3 +/data/TCGA/9afc99b8-4e7c-4607-a9ee-9b10c939f43d/TCGA-DA-A1I4-01Z-00-DX1.F88976CE-0707-47C8-8625-13D5D6F27594.svs 174219 9331 0 +/data/TCGA/9afc99b8-4e7c-4607-a9ee-9b10c939f43d/TCGA-DA-A1I4-01Z-00-DX1.F88976CE-0707-47C8-8625-13D5D6F27594.svs 119322 8282 1 +/data/TCGA/9afc99b8-4e7c-4607-a9ee-9b10c939f43d/TCGA-DA-A1I4-01Z-00-DX1.F88976CE-0707-47C8-8625-13D5D6F27594.svs 7474 5998 2 +/data/TCGA/9ae7a58b-02b5-435f-a6e2-4c650d16e647/TCGA-MA-AA42-01Z-00-DX1.060491AB-E11F-44DC-91CA-0AE68DE8C900.svs 32242 64008 0 +/data/TCGA/9ae7a58b-02b5-435f-a6e2-4c650d16e647/TCGA-MA-AA42-01Z-00-DX1.060491AB-E11F-44DC-91CA-0AE68DE8C900.svs 44699 62808 1 +/data/TCGA/9ae7a58b-02b5-435f-a6e2-4c650d16e647/TCGA-MA-AA42-01Z-00-DX1.060491AB-E11F-44DC-91CA-0AE68DE8C900.svs 79516 24201 2 +/data/TCGA/9ae7a58b-02b5-435f-a6e2-4c650d16e647/TCGA-MA-AA42-01Z-00-DX1.060491AB-E11F-44DC-91CA-0AE68DE8C900.svs 73926 45503 3 +/data/TCGA/dfb59480-6878-4a3c-ba61-5079eeff5fbc/TCGA-TS-A7P8-01Z-00-DX1.25E9AFA9-6C12-4F18-BE79-2F4F19887ECD.svs 41271 9256 0 +/data/TCGA/dfb59480-6878-4a3c-ba61-5079eeff5fbc/TCGA-TS-A7P8-01Z-00-DX1.25E9AFA9-6C12-4F18-BE79-2F4F19887ECD.svs 10540 26938 1 +/data/TCGA/dfb59480-6878-4a3c-ba61-5079eeff5fbc/TCGA-TS-A7P8-01Z-00-DX1.25E9AFA9-6C12-4F18-BE79-2F4F19887ECD.svs 13302 31218 2 +/data/TCGA/dfb59480-6878-4a3c-ba61-5079eeff5fbc/TCGA-TS-A7P8-01Z-00-DX1.25E9AFA9-6C12-4F18-BE79-2F4F19887ECD.svs 26075 29439 3 +/data/TCGA/32268fd4-3c70-4906-97ac-c480f76fd00c/TCGA-CM-5349-01Z-00-DX1.d893eb9a-0321-4052-acfc-8c9a6e463921.svs 47827 11707 0 +/data/TCGA/32268fd4-3c70-4906-97ac-c480f76fd00c/TCGA-CM-5349-01Z-00-DX1.d893eb9a-0321-4052-acfc-8c9a6e463921.svs 69895 81819 1 +/data/TCGA/32268fd4-3c70-4906-97ac-c480f76fd00c/TCGA-CM-5349-01Z-00-DX1.d893eb9a-0321-4052-acfc-8c9a6e463921.svs 85184 63278 2 +/data/TCGA/32268fd4-3c70-4906-97ac-c480f76fd00c/TCGA-CM-5349-01Z-00-DX1.d893eb9a-0321-4052-acfc-8c9a6e463921.svs 43588 28016 3 +/data/TCGA/adf9c7cb-b854-4046-a307-740b9c6f15b1/TCGA-DU-8161-01Z-00-DX1.f8fa74fe-4793-47dc-9dc1-10e636835536.svs 19359 15311 0 +/data/TCGA/adf9c7cb-b854-4046-a307-740b9c6f15b1/TCGA-DU-8161-01Z-00-DX1.f8fa74fe-4793-47dc-9dc1-10e636835536.svs 12098 13134 1 +/data/TCGA/adf9c7cb-b854-4046-a307-740b9c6f15b1/TCGA-DU-8161-01Z-00-DX1.f8fa74fe-4793-47dc-9dc1-10e636835536.svs 19646 17194 2 +/data/TCGA/f9cbd939-dc64-43cb-8046-33bc0a971b83/TCGA-DA-A3F8-01Z-00-DX1.ACE3310A-0BB5-4243-82EF-92CABB53830C.svs 6988 8725 0 +/data/TCGA/f9cbd939-dc64-43cb-8046-33bc0a971b83/TCGA-DA-A3F8-01Z-00-DX1.ACE3310A-0BB5-4243-82EF-92CABB53830C.svs 63836 2753 1 +/data/TCGA/f9cbd939-dc64-43cb-8046-33bc0a971b83/TCGA-DA-A3F8-01Z-00-DX1.ACE3310A-0BB5-4243-82EF-92CABB53830C.svs 122023 2434 2 +/data/TCGA/f9cbd939-dc64-43cb-8046-33bc0a971b83/TCGA-DA-A3F8-01Z-00-DX1.ACE3310A-0BB5-4243-82EF-92CABB53830C.svs 63970 2747 3 +/data/TCGA/1ee98f01-6e86-49e4-8f12-1448d9f61176/TCGA-B0-4706-01Z-00-DX1.a29630d2-be74-4245-8d47-2e1694bea5e4.svs 33344 58727 0 +/data/TCGA/1ee98f01-6e86-49e4-8f12-1448d9f61176/TCGA-B0-4706-01Z-00-DX1.a29630d2-be74-4245-8d47-2e1694bea5e4.svs 48765 5014 1 +/data/TCGA/1ee98f01-6e86-49e4-8f12-1448d9f61176/TCGA-B0-4706-01Z-00-DX1.a29630d2-be74-4245-8d47-2e1694bea5e4.svs 53006 56457 2 +/data/TCGA/1ee98f01-6e86-49e4-8f12-1448d9f61176/TCGA-B0-4706-01Z-00-DX1.a29630d2-be74-4245-8d47-2e1694bea5e4.svs 34888 64329 3 +/data/TCGA/60b06123-e94a-4fab-bb14-f83a4c6a654c/TCGA-EY-A2OM-01Z-00-DX1.A704D5CF-011B-4A17-AA5D-1634556CC719.svs 19834 42368 0 +/data/TCGA/60b06123-e94a-4fab-bb14-f83a4c6a654c/TCGA-EY-A2OM-01Z-00-DX1.A704D5CF-011B-4A17-AA5D-1634556CC719.svs 65933 15941 1 +/data/TCGA/60b06123-e94a-4fab-bb14-f83a4c6a654c/TCGA-EY-A2OM-01Z-00-DX1.A704D5CF-011B-4A17-AA5D-1634556CC719.svs 44449 38321 2 +/data/TCGA/60b06123-e94a-4fab-bb14-f83a4c6a654c/TCGA-EY-A2OM-01Z-00-DX1.A704D5CF-011B-4A17-AA5D-1634556CC719.svs 41625 59056 3 +/data/TCGA/b4c80cba-c2cd-4724-bb4d-461579b19f29/TCGA-DX-A7EI-01Z-00-DX2.7CAF2DEA-34A2-4841-94BE-C4B814D479CD.svs 95149 77933 0 +/data/TCGA/b4c80cba-c2cd-4724-bb4d-461579b19f29/TCGA-DX-A7EI-01Z-00-DX2.7CAF2DEA-34A2-4841-94BE-C4B814D479CD.svs 94054 18547 1 +/data/TCGA/b4c80cba-c2cd-4724-bb4d-461579b19f29/TCGA-DX-A7EI-01Z-00-DX2.7CAF2DEA-34A2-4841-94BE-C4B814D479CD.svs 45722 48818 2 +/data/TCGA/b4c80cba-c2cd-4724-bb4d-461579b19f29/TCGA-DX-A7EI-01Z-00-DX2.7CAF2DEA-34A2-4841-94BE-C4B814D479CD.svs 67493 83313 3 +/data/TCGA/c819298a-a097-4523-861c-3611459f84a4/TCGA-66-2758-01Z-00-DX1.23611c66-bd21-47d1-abb0-2f3da38c377f.svs 63818 24341 0 +/data/TCGA/c819298a-a097-4523-861c-3611459f84a4/TCGA-66-2758-01Z-00-DX1.23611c66-bd21-47d1-abb0-2f3da38c377f.svs 26780 20282 1 +/data/TCGA/c819298a-a097-4523-861c-3611459f84a4/TCGA-66-2758-01Z-00-DX1.23611c66-bd21-47d1-abb0-2f3da38c377f.svs 63040 21229 2 +/data/TCGA/c819298a-a097-4523-861c-3611459f84a4/TCGA-66-2758-01Z-00-DX1.23611c66-bd21-47d1-abb0-2f3da38c377f.svs 16209 19649 3 +/data/TCGA/070defff-1f5d-49e7-85b9-de4508e8a0c9/TCGA-05-4396-01Z-00-DX1.49DD5F68-7473-4945-B384-EA6D5AE383CB.svs 53341 16372 0 +/data/TCGA/070defff-1f5d-49e7-85b9-de4508e8a0c9/TCGA-05-4396-01Z-00-DX1.49DD5F68-7473-4945-B384-EA6D5AE383CB.svs 46374 29933 1 +/data/TCGA/070defff-1f5d-49e7-85b9-de4508e8a0c9/TCGA-05-4396-01Z-00-DX1.49DD5F68-7473-4945-B384-EA6D5AE383CB.svs 35000 30309 2 +/data/TCGA/070defff-1f5d-49e7-85b9-de4508e8a0c9/TCGA-05-4396-01Z-00-DX1.49DD5F68-7473-4945-B384-EA6D5AE383CB.svs 36564 23417 3 +/data/TCGA/b6ab6199-0960-4f6a-ba69-2e79d7961551/TCGA-06-0178-01Z-00-DX1.6102d1a4-610b-4c5e-abc8-17dce6b84911.svs 29036 18683 0 +/data/TCGA/b6ab6199-0960-4f6a-ba69-2e79d7961551/TCGA-06-0178-01Z-00-DX1.6102d1a4-610b-4c5e-abc8-17dce6b84911.svs 24548 12090 1 +/data/TCGA/b6ab6199-0960-4f6a-ba69-2e79d7961551/TCGA-06-0178-01Z-00-DX1.6102d1a4-610b-4c5e-abc8-17dce6b84911.svs 18016 3657 2 +/data/TCGA/9c3b38ac-e7a2-4e83-a160-bcf951b5e67f/TCGA-QH-A6X8-01Z-00-DX1.9FB9444F-980D-4C73-8241-11D44C61CCE6.svs 90683 56613 0 +/data/TCGA/9c3b38ac-e7a2-4e83-a160-bcf951b5e67f/TCGA-QH-A6X8-01Z-00-DX1.9FB9444F-980D-4C73-8241-11D44C61CCE6.svs 82223 50925 1 +/data/TCGA/9c3b38ac-e7a2-4e83-a160-bcf951b5e67f/TCGA-QH-A6X8-01Z-00-DX1.9FB9444F-980D-4C73-8241-11D44C61CCE6.svs 89023 36209 2 +/data/TCGA/9c3b38ac-e7a2-4e83-a160-bcf951b5e67f/TCGA-QH-A6X8-01Z-00-DX1.9FB9444F-980D-4C73-8241-11D44C61CCE6.svs 88027 41287 3 +/data/TCGA/61276d6c-58c8-4813-9173-36ea5f2a2f1c/TCGA-4X-A9F9-01Z-00-DX9.5845DB22-E934-4619-81B5-367A751B87FC.svs 49404 62094 0 +/data/TCGA/61276d6c-58c8-4813-9173-36ea5f2a2f1c/TCGA-4X-A9F9-01Z-00-DX9.5845DB22-E934-4619-81B5-367A751B87FC.svs 64147 30415 1 +/data/TCGA/61276d6c-58c8-4813-9173-36ea5f2a2f1c/TCGA-4X-A9F9-01Z-00-DX9.5845DB22-E934-4619-81B5-367A751B87FC.svs 79386 43768 2 +/data/TCGA/61276d6c-58c8-4813-9173-36ea5f2a2f1c/TCGA-4X-A9F9-01Z-00-DX9.5845DB22-E934-4619-81B5-367A751B87FC.svs 100232 30680 3 +/data/TCGA/6cb269b5-5ecd-4613-93c1-7b32eb1b5ae2/TCGA-DX-AATS-01Z-00-DX1.402B0309-AF1B-4D10-BF98-5A3CECDEBAEF.svs 20542 63218 0 +/data/TCGA/6cb269b5-5ecd-4613-93c1-7b32eb1b5ae2/TCGA-DX-AATS-01Z-00-DX1.402B0309-AF1B-4D10-BF98-5A3CECDEBAEF.svs 17256 62019 1 +/data/TCGA/6cb269b5-5ecd-4613-93c1-7b32eb1b5ae2/TCGA-DX-AATS-01Z-00-DX1.402B0309-AF1B-4D10-BF98-5A3CECDEBAEF.svs 57015 51936 2 +/data/TCGA/6cb269b5-5ecd-4613-93c1-7b32eb1b5ae2/TCGA-DX-AATS-01Z-00-DX1.402B0309-AF1B-4D10-BF98-5A3CECDEBAEF.svs 39249 23216 3 +/data/TCGA/4c8d6211-2fac-44ad-b81d-762144f8dccb/TCGA-AJ-A3BK-01Z-00-DX1.A35F188F-43AB-410F-B5F1-DCE8D6669CF0.svs 16439 5375 0 +/data/TCGA/4c8d6211-2fac-44ad-b81d-762144f8dccb/TCGA-AJ-A3BK-01Z-00-DX1.A35F188F-43AB-410F-B5F1-DCE8D6669CF0.svs 21799 16590 1 +/data/TCGA/4c8d6211-2fac-44ad-b81d-762144f8dccb/TCGA-AJ-A3BK-01Z-00-DX1.A35F188F-43AB-410F-B5F1-DCE8D6669CF0.svs 17400 7300 2 +/data/TCGA/cf6e3c38-1e41-41cb-8802-3311a9867982/TCGA-46-3768-01Z-00-DX1.226f6cbc-f1f4-4df8-8366-c94fd78e037b.svs 13356 22525 0 +/data/TCGA/cf6e3c38-1e41-41cb-8802-3311a9867982/TCGA-46-3768-01Z-00-DX1.226f6cbc-f1f4-4df8-8366-c94fd78e037b.svs 24786 28475 1 +/data/TCGA/cf6e3c38-1e41-41cb-8802-3311a9867982/TCGA-46-3768-01Z-00-DX1.226f6cbc-f1f4-4df8-8366-c94fd78e037b.svs 3768 14029 2 +/data/TCGA/cf6e3c38-1e41-41cb-8802-3311a9867982/TCGA-46-3768-01Z-00-DX1.226f6cbc-f1f4-4df8-8366-c94fd78e037b.svs 121318 16780 3 +/data/TCGA/8afc3e55-fcaf-4328-9b5a-a01bcee181cc/TCGA-EJ-7789-01Z-00-DX1.1fe607cd-e166-4c16-8fc0-74bcca9b5975.svs 14810 56489 0 +/data/TCGA/8afc3e55-fcaf-4328-9b5a-a01bcee181cc/TCGA-EJ-7789-01Z-00-DX1.1fe607cd-e166-4c16-8fc0-74bcca9b5975.svs 65147 20972 1 +/data/TCGA/8afc3e55-fcaf-4328-9b5a-a01bcee181cc/TCGA-EJ-7789-01Z-00-DX1.1fe607cd-e166-4c16-8fc0-74bcca9b5975.svs 15514 16728 2 +/data/TCGA/8afc3e55-fcaf-4328-9b5a-a01bcee181cc/TCGA-EJ-7789-01Z-00-DX1.1fe607cd-e166-4c16-8fc0-74bcca9b5975.svs 54548 16891 3 +/data/TCGA/dbc41286-8b62-4f1b-b993-4632f7f24601/TCGA-EB-A3XB-01Z-00-DX1.65EB6648-0EA6-4010-8B71-DE9FF803B1A7.svs 26063 19117 0 +/data/TCGA/dbc41286-8b62-4f1b-b993-4632f7f24601/TCGA-EB-A3XB-01Z-00-DX1.65EB6648-0EA6-4010-8B71-DE9FF803B1A7.svs 61438 41186 1 +/data/TCGA/dbc41286-8b62-4f1b-b993-4632f7f24601/TCGA-EB-A3XB-01Z-00-DX1.65EB6648-0EA6-4010-8B71-DE9FF803B1A7.svs 51470 43033 2 +/data/TCGA/dbc41286-8b62-4f1b-b993-4632f7f24601/TCGA-EB-A3XB-01Z-00-DX1.65EB6648-0EA6-4010-8B71-DE9FF803B1A7.svs 54062 52185 3 +/data/TCGA/402c4ba5-fa7e-4e0e-be3e-092970caf5f8/TCGA-PK-A5HC-01Z-00-DX1.B409A43D-39A4-4335-BBFB-9771F8FD9CC7.svs 27682 5296 0 +/data/TCGA/402c4ba5-fa7e-4e0e-be3e-092970caf5f8/TCGA-PK-A5HC-01Z-00-DX1.B409A43D-39A4-4335-BBFB-9771F8FD9CC7.svs 34040 27764 1 +/data/TCGA/402c4ba5-fa7e-4e0e-be3e-092970caf5f8/TCGA-PK-A5HC-01Z-00-DX1.B409A43D-39A4-4335-BBFB-9771F8FD9CC7.svs 30127 23307 2 +/data/TCGA/32b30174-2ede-4fd4-a95b-e6fd169de4ac/TCGA-DX-A8BU-01Z-00-DX4.25EC8835-3E47-4298-92E6-A35130E7E936.svs 37607 15366 0 +/data/TCGA/32b30174-2ede-4fd4-a95b-e6fd169de4ac/TCGA-DX-A8BU-01Z-00-DX4.25EC8835-3E47-4298-92E6-A35130E7E936.svs 32549 26661 1 +/data/TCGA/32b30174-2ede-4fd4-a95b-e6fd169de4ac/TCGA-DX-A8BU-01Z-00-DX4.25EC8835-3E47-4298-92E6-A35130E7E936.svs 41940 15952 2 +/data/TCGA/32b30174-2ede-4fd4-a95b-e6fd169de4ac/TCGA-DX-A8BU-01Z-00-DX4.25EC8835-3E47-4298-92E6-A35130E7E936.svs 9584 8594 3 +/data/TCGA/c2d98513-2d9d-4867-8129-929ff164b203/TCGA-B8-A54D-01Z-00-DX1.DCD17375-918C-4AEA-96F0-7FF8FCF4D00B.svs 37542 7596 0 +/data/TCGA/c2d98513-2d9d-4867-8129-929ff164b203/TCGA-B8-A54D-01Z-00-DX1.DCD17375-918C-4AEA-96F0-7FF8FCF4D00B.svs 9614 27417 1 +/data/TCGA/c2d98513-2d9d-4867-8129-929ff164b203/TCGA-B8-A54D-01Z-00-DX1.DCD17375-918C-4AEA-96F0-7FF8FCF4D00B.svs 113378 4747 2 +/data/TCGA/c2d98513-2d9d-4867-8129-929ff164b203/TCGA-B8-A54D-01Z-00-DX1.DCD17375-918C-4AEA-96F0-7FF8FCF4D00B.svs 127551 7948 3 +/data/TCGA/758f39c9-6353-4748-a09c-338d96efc636/TCGA-E1-A7YM-01Z-00-DX1.4F454CC1-2AA5-40BF-ACBB-AF80B740311A.svs 81271 22905 0 +/data/TCGA/758f39c9-6353-4748-a09c-338d96efc636/TCGA-E1-A7YM-01Z-00-DX1.4F454CC1-2AA5-40BF-ACBB-AF80B740311A.svs 48932 16915 1 +/data/TCGA/758f39c9-6353-4748-a09c-338d96efc636/TCGA-E1-A7YM-01Z-00-DX1.4F454CC1-2AA5-40BF-ACBB-AF80B740311A.svs 36805 14691 2 +/data/TCGA/758f39c9-6353-4748-a09c-338d96efc636/TCGA-E1-A7YM-01Z-00-DX1.4F454CC1-2AA5-40BF-ACBB-AF80B740311A.svs 35437 67902 3 +/data/TCGA/6359535c-ece1-422f-a111-41cfa24f9a99/TCGA-FD-A5C1-01Z-00-DX1.EAD87C49-A25C-4D37-AF27-E27F7016E065.svs 34981 49261 0 +/data/TCGA/6359535c-ece1-422f-a111-41cfa24f9a99/TCGA-FD-A5C1-01Z-00-DX1.EAD87C49-A25C-4D37-AF27-E27F7016E065.svs 24670 31091 1 +/data/TCGA/6359535c-ece1-422f-a111-41cfa24f9a99/TCGA-FD-A5C1-01Z-00-DX1.EAD87C49-A25C-4D37-AF27-E27F7016E065.svs 22881 68724 2 +/data/TCGA/6359535c-ece1-422f-a111-41cfa24f9a99/TCGA-FD-A5C1-01Z-00-DX1.EAD87C49-A25C-4D37-AF27-E27F7016E065.svs 100170 38955 3 +/data/TCGA/7fe08fdc-f28b-4306-a99e-651f3af76638/TCGA-MR-A520-01Z-00-DX1.2F323BAC-56C9-4A0C-9C1B-2B4F776056B4.svs 5091 5201 0 +/data/TCGA/7fe08fdc-f28b-4306-a99e-651f3af76638/TCGA-MR-A520-01Z-00-DX1.2F323BAC-56C9-4A0C-9C1B-2B4F776056B4.svs 9014 12593 1 +/data/TCGA/7fe08fdc-f28b-4306-a99e-651f3af76638/TCGA-MR-A520-01Z-00-DX1.2F323BAC-56C9-4A0C-9C1B-2B4F776056B4.svs 7774 17681 2 +/data/TCGA/811acf84-0d52-4c24-ac52-8686780725de/TCGA-FP-8210-01Z-00-DX1.0ef0fd3f-5968-48ce-9e69-eaae83c29004.svs 10446 16357 0 +/data/TCGA/811acf84-0d52-4c24-ac52-8686780725de/TCGA-FP-8210-01Z-00-DX1.0ef0fd3f-5968-48ce-9e69-eaae83c29004.svs 26494 15166 1 +/data/TCGA/811acf84-0d52-4c24-ac52-8686780725de/TCGA-FP-8210-01Z-00-DX1.0ef0fd3f-5968-48ce-9e69-eaae83c29004.svs 25329 8158 2 +/data/TCGA/a5c727f8-1cd5-44e8-8cfd-e4d30bd86997/TCGA-HT-7610-01Z-00-DX2.FA27FEBA-2400-451A-9E7E-492D150AAAA7.svs 36420 10465 0 +/data/TCGA/a5c727f8-1cd5-44e8-8cfd-e4d30bd86997/TCGA-HT-7610-01Z-00-DX2.FA27FEBA-2400-451A-9E7E-492D150AAAA7.svs 9303 58188 1 +/data/TCGA/a5c727f8-1cd5-44e8-8cfd-e4d30bd86997/TCGA-HT-7610-01Z-00-DX2.FA27FEBA-2400-451A-9E7E-492D150AAAA7.svs 22533 64849 2 +/data/TCGA/a5c727f8-1cd5-44e8-8cfd-e4d30bd86997/TCGA-HT-7610-01Z-00-DX2.FA27FEBA-2400-451A-9E7E-492D150AAAA7.svs 48601 46159 3 +/data/TCGA/f970abcc-56aa-4224-a14c-3d1e87d7c5e7/TCGA-CN-5360-01Z-00-DX1.d3657b07-9ea0-41fc-b858-c9a1497340c8.svs 19357 23604 0 +/data/TCGA/f970abcc-56aa-4224-a14c-3d1e87d7c5e7/TCGA-CN-5360-01Z-00-DX1.d3657b07-9ea0-41fc-b858-c9a1497340c8.svs 12792 22182 1 +/data/TCGA/f970abcc-56aa-4224-a14c-3d1e87d7c5e7/TCGA-CN-5360-01Z-00-DX1.d3657b07-9ea0-41fc-b858-c9a1497340c8.svs 8415 15481 2 +/data/TCGA/f970abcc-56aa-4224-a14c-3d1e87d7c5e7/TCGA-CN-5360-01Z-00-DX1.d3657b07-9ea0-41fc-b858-c9a1497340c8.svs 29066 22414 3 +/data/TCGA/bbb031f6-c276-4c24-bc1f-7657c14cc767/TCGA-CV-7254-01Z-00-DX1.ACCE315D-AA82-462C-A84E-5ECE487A179A.svs 67724 24610 0 +/data/TCGA/bbb031f6-c276-4c24-bc1f-7657c14cc767/TCGA-CV-7254-01Z-00-DX1.ACCE315D-AA82-462C-A84E-5ECE487A179A.svs 75203 29101 1 +/data/TCGA/bbb031f6-c276-4c24-bc1f-7657c14cc767/TCGA-CV-7254-01Z-00-DX1.ACCE315D-AA82-462C-A84E-5ECE487A179A.svs 56460 37886 2 +/data/TCGA/bbb031f6-c276-4c24-bc1f-7657c14cc767/TCGA-CV-7254-01Z-00-DX1.ACCE315D-AA82-462C-A84E-5ECE487A179A.svs 75733 23668 3 +/data/TCGA/c7ea8939-29de-45e6-81aa-8d022765e5c3/TCGA-23-1027-01Z-00-DX1.53F9DFF4-6811-4184-B2FD-1F6706B948FD.svs 79020 62637 0 +/data/TCGA/c7ea8939-29de-45e6-81aa-8d022765e5c3/TCGA-23-1027-01Z-00-DX1.53F9DFF4-6811-4184-B2FD-1F6706B948FD.svs 79787 32940 1 +/data/TCGA/c7ea8939-29de-45e6-81aa-8d022765e5c3/TCGA-23-1027-01Z-00-DX1.53F9DFF4-6811-4184-B2FD-1F6706B948FD.svs 51223 13071 2 +/data/TCGA/c7ea8939-29de-45e6-81aa-8d022765e5c3/TCGA-23-1027-01Z-00-DX1.53F9DFF4-6811-4184-B2FD-1F6706B948FD.svs 7602 35699 3 +/data/TCGA/d3086ef5-7c37-4227-9732-d1daa759bc33/TCGA-MB-A8JK-01Z-00-DX1.15EE305B-4B08-44E6-B043-01ABA8610255.svs 26116 22497 0 +/data/TCGA/d3086ef5-7c37-4227-9732-d1daa759bc33/TCGA-MB-A8JK-01Z-00-DX1.15EE305B-4B08-44E6-B043-01ABA8610255.svs 8091 18919 1 +/data/TCGA/d3086ef5-7c37-4227-9732-d1daa759bc33/TCGA-MB-A8JK-01Z-00-DX1.15EE305B-4B08-44E6-B043-01ABA8610255.svs 45798 34363 2 +/data/TCGA/d3086ef5-7c37-4227-9732-d1daa759bc33/TCGA-MB-A8JK-01Z-00-DX1.15EE305B-4B08-44E6-B043-01ABA8610255.svs 26056 30619 3 +/data/TCGA/4f6d0d91-047b-48a3-8ecc-2db37b762611/TCGA-UD-AAC7-01Z-00-DX1.A72102D3-0FEC-4F9B-AE49-5D6A5262A35F.svs 34102 34033 0 +/data/TCGA/4f6d0d91-047b-48a3-8ecc-2db37b762611/TCGA-UD-AAC7-01Z-00-DX1.A72102D3-0FEC-4F9B-AE49-5D6A5262A35F.svs 19723 40643 1 +/data/TCGA/4f6d0d91-047b-48a3-8ecc-2db37b762611/TCGA-UD-AAC7-01Z-00-DX1.A72102D3-0FEC-4F9B-AE49-5D6A5262A35F.svs 32052 39068 2 +/data/TCGA/4f6d0d91-047b-48a3-8ecc-2db37b762611/TCGA-UD-AAC7-01Z-00-DX1.A72102D3-0FEC-4F9B-AE49-5D6A5262A35F.svs 20327 12503 3 +/data/TCGA/66bd71a8-47ec-4c2a-9277-3100cb27f816/TCGA-IB-AAUU-01Z-00-DX1.83137319-8229-4682-8BD3-9B9A5C6C997A.svs 15595 77783 0 +/data/TCGA/66bd71a8-47ec-4c2a-9277-3100cb27f816/TCGA-IB-AAUU-01Z-00-DX1.83137319-8229-4682-8BD3-9B9A5C6C997A.svs 50688 29732 1 +/data/TCGA/66bd71a8-47ec-4c2a-9277-3100cb27f816/TCGA-IB-AAUU-01Z-00-DX1.83137319-8229-4682-8BD3-9B9A5C6C997A.svs 40465 13950 2 +/data/TCGA/66bd71a8-47ec-4c2a-9277-3100cb27f816/TCGA-IB-AAUU-01Z-00-DX1.83137319-8229-4682-8BD3-9B9A5C6C997A.svs 13102 68022 3 +/data/TCGA/81b4b499-53a8-4aa7-9e00-3142a91bcd01/TCGA-BG-A0M3-01Z-00-DX1.F9043C31-B3BC-460E-9ED8-C4481FE31541.svs 102190 47315 0 +/data/TCGA/81b4b499-53a8-4aa7-9e00-3142a91bcd01/TCGA-BG-A0M3-01Z-00-DX1.F9043C31-B3BC-460E-9ED8-C4481FE31541.svs 34102 43851 1 +/data/TCGA/81b4b499-53a8-4aa7-9e00-3142a91bcd01/TCGA-BG-A0M3-01Z-00-DX1.F9043C31-B3BC-460E-9ED8-C4481FE31541.svs 85796 41631 2 +/data/TCGA/81b4b499-53a8-4aa7-9e00-3142a91bcd01/TCGA-BG-A0M3-01Z-00-DX1.F9043C31-B3BC-460E-9ED8-C4481FE31541.svs 24036 8840 3 +/data/TCGA/b2d06eb0-3cfe-4591-89d4-ecb7fb60d2fb/TCGA-4X-A9FC-01Z-00-DX3.E2E9D117-F6EE-4658-9D5F-B2BAE40A82F6.svs 124117 20502 0 +/data/TCGA/b2d06eb0-3cfe-4591-89d4-ecb7fb60d2fb/TCGA-4X-A9FC-01Z-00-DX3.E2E9D117-F6EE-4658-9D5F-B2BAE40A82F6.svs 117730 12440 1 +/data/TCGA/b2d06eb0-3cfe-4591-89d4-ecb7fb60d2fb/TCGA-4X-A9FC-01Z-00-DX3.E2E9D117-F6EE-4658-9D5F-B2BAE40A82F6.svs 73086 63764 2 +/data/TCGA/b2d06eb0-3cfe-4591-89d4-ecb7fb60d2fb/TCGA-4X-A9FC-01Z-00-DX3.E2E9D117-F6EE-4658-9D5F-B2BAE40A82F6.svs 52804 13316 3 +/data/TCGA/a0389f42-258f-41fe-90c3-34d224f3c90b/TCGA-4R-AA8I-01Z-00-DX1.99273858-6CCB-4AD3-8FFF-9E47293F0CD6.svs 67493 54594 0 +/data/TCGA/a0389f42-258f-41fe-90c3-34d224f3c90b/TCGA-4R-AA8I-01Z-00-DX1.99273858-6CCB-4AD3-8FFF-9E47293F0CD6.svs 71161 38106 1 +/data/TCGA/a0389f42-258f-41fe-90c3-34d224f3c90b/TCGA-4R-AA8I-01Z-00-DX1.99273858-6CCB-4AD3-8FFF-9E47293F0CD6.svs 23318 13675 2 +/data/TCGA/a0389f42-258f-41fe-90c3-34d224f3c90b/TCGA-4R-AA8I-01Z-00-DX1.99273858-6CCB-4AD3-8FFF-9E47293F0CD6.svs 82228 46997 3 +/data/TCGA/65aaaa75-f8ae-4e2c-aaa0-0f3464ca73cf/TCGA-DD-A3A6-01Z-00-DX1.FCF4A7E7-A0F9-4B5D-B751-D990703EA261.svs 14758 24396 0 +/data/TCGA/65aaaa75-f8ae-4e2c-aaa0-0f3464ca73cf/TCGA-DD-A3A6-01Z-00-DX1.FCF4A7E7-A0F9-4B5D-B751-D990703EA261.svs 20177 44748 1 +/data/TCGA/65aaaa75-f8ae-4e2c-aaa0-0f3464ca73cf/TCGA-DD-A3A6-01Z-00-DX1.FCF4A7E7-A0F9-4B5D-B751-D990703EA261.svs 65119 63353 2 +/data/TCGA/65aaaa75-f8ae-4e2c-aaa0-0f3464ca73cf/TCGA-DD-A3A6-01Z-00-DX1.FCF4A7E7-A0F9-4B5D-B751-D990703EA261.svs 86293 31664 3 +/data/TCGA/910b5349-046d-483e-8277-fcaa07cb35ca/TCGA-MS-A51U-01Z-00-DX1.490DE85A-ECE5-4E2A-9657-841BE6FFCCA0.svs 9369 4745 0 +/data/TCGA/910b5349-046d-483e-8277-fcaa07cb35ca/TCGA-MS-A51U-01Z-00-DX1.490DE85A-ECE5-4E2A-9657-841BE6FFCCA0.svs 4354 7794 1 +/data/TCGA/910b5349-046d-483e-8277-fcaa07cb35ca/TCGA-MS-A51U-01Z-00-DX1.490DE85A-ECE5-4E2A-9657-841BE6FFCCA0.svs 7340 12492 2 +/data/TCGA/a2b326ec-6f81-4197-9a97-7db4b5b638d1/TCGA-BH-A0HI-01Z-00-DX1.89DB9F79-0DCC-4C65-831E-96AE026C2C4E.svs 48230 43036 0 +/data/TCGA/a2b326ec-6f81-4197-9a97-7db4b5b638d1/TCGA-BH-A0HI-01Z-00-DX1.89DB9F79-0DCC-4C65-831E-96AE026C2C4E.svs 40660 52383 1 +/data/TCGA/a2b326ec-6f81-4197-9a97-7db4b5b638d1/TCGA-BH-A0HI-01Z-00-DX1.89DB9F79-0DCC-4C65-831E-96AE026C2C4E.svs 45689 39658 2 +/data/TCGA/a2b326ec-6f81-4197-9a97-7db4b5b638d1/TCGA-BH-A0HI-01Z-00-DX1.89DB9F79-0DCC-4C65-831E-96AE026C2C4E.svs 73207 31115 3 +/data/TCGA/bd75ca83-b4f9-4e54-b4a0-bcf501650988/TCGA-AX-A06D-01Z-00-DX1.66E3E077-8973-4D8B-BD71-D38DBC35E36E.svs 42849 68845 0 +/data/TCGA/bd75ca83-b4f9-4e54-b4a0-bcf501650988/TCGA-AX-A06D-01Z-00-DX1.66E3E077-8973-4D8B-BD71-D38DBC35E36E.svs 66420 31671 1 +/data/TCGA/bd75ca83-b4f9-4e54-b4a0-bcf501650988/TCGA-AX-A06D-01Z-00-DX1.66E3E077-8973-4D8B-BD71-D38DBC35E36E.svs 54270 25548 2 +/data/TCGA/bd75ca83-b4f9-4e54-b4a0-bcf501650988/TCGA-AX-A06D-01Z-00-DX1.66E3E077-8973-4D8B-BD71-D38DBC35E36E.svs 91587 22676 3 +/data/TCGA/4bb75285-9b4a-416e-a669-440ca4f8fd43/TCGA-A8-A08G-01Z-00-DX1.C3BB7FEC-91B7-4B45-8DFC-36CABCC0FD57.svs 31744 21227 0 +/data/TCGA/4bb75285-9b4a-416e-a669-440ca4f8fd43/TCGA-A8-A08G-01Z-00-DX1.C3BB7FEC-91B7-4B45-8DFC-36CABCC0FD57.svs 29832 9707 1 +/data/TCGA/4bb75285-9b4a-416e-a669-440ca4f8fd43/TCGA-A8-A08G-01Z-00-DX1.C3BB7FEC-91B7-4B45-8DFC-36CABCC0FD57.svs 35987 15109 2 +/data/TCGA/4bb75285-9b4a-416e-a669-440ca4f8fd43/TCGA-A8-A08G-01Z-00-DX1.C3BB7FEC-91B7-4B45-8DFC-36CABCC0FD57.svs 25991 36412 3 +/data/TCGA/d7539c2a-21e3-437b-9070-b840b3083645/TCGA-E2-A1LL-01Z-00-DX1.D1AA1613-902C-4579-9612-48A76042B0AE.svs 39939 10816 0 +/data/TCGA/d7539c2a-21e3-437b-9070-b840b3083645/TCGA-E2-A1LL-01Z-00-DX1.D1AA1613-902C-4579-9612-48A76042B0AE.svs 18104 28063 1 +/data/TCGA/d7539c2a-21e3-437b-9070-b840b3083645/TCGA-E2-A1LL-01Z-00-DX1.D1AA1613-902C-4579-9612-48A76042B0AE.svs 34120 19758 2 +/data/TCGA/d7539c2a-21e3-437b-9070-b840b3083645/TCGA-E2-A1LL-01Z-00-DX1.D1AA1613-902C-4579-9612-48A76042B0AE.svs 6987 6556 3 +/data/TCGA/0edfc16d-25cc-403d-8862-38ec9c90060a/TCGA-50-6597-01Z-00-DX1.ec7fc0b2-78a1-4384-bddd-e89f02ee5eb6.svs 16225 53994 0 +/data/TCGA/0edfc16d-25cc-403d-8862-38ec9c90060a/TCGA-50-6597-01Z-00-DX1.ec7fc0b2-78a1-4384-bddd-e89f02ee5eb6.svs 25083 13781 1 +/data/TCGA/0edfc16d-25cc-403d-8862-38ec9c90060a/TCGA-50-6597-01Z-00-DX1.ec7fc0b2-78a1-4384-bddd-e89f02ee5eb6.svs 5379 39542 2 +/data/TCGA/0edfc16d-25cc-403d-8862-38ec9c90060a/TCGA-50-6597-01Z-00-DX1.ec7fc0b2-78a1-4384-bddd-e89f02ee5eb6.svs 33572 42634 3 +/data/TCGA/97728553-6d05-4754-be0f-a989c29bf627/TCGA-LN-A5U7-01Z-00-DX1.9397E01B-C88B-4A79-A09A-DBCF65BBADBB.svs 36755 12526 0 +/data/TCGA/97728553-6d05-4754-be0f-a989c29bf627/TCGA-LN-A5U7-01Z-00-DX1.9397E01B-C88B-4A79-A09A-DBCF65BBADBB.svs 43830 26805 1 +/data/TCGA/97728553-6d05-4754-be0f-a989c29bf627/TCGA-LN-A5U7-01Z-00-DX1.9397E01B-C88B-4A79-A09A-DBCF65BBADBB.svs 37692 10110 2 +/data/TCGA/97728553-6d05-4754-be0f-a989c29bf627/TCGA-LN-A5U7-01Z-00-DX1.9397E01B-C88B-4A79-A09A-DBCF65BBADBB.svs 54874 15628 3 +/data/TCGA/4ab5b1d6-21c4-4b7f-89a9-21214f53e658/TCGA-12-0619-01Z-00-DX3.bfb91928-1b12-46dc-a734-dd87ae164c13.svs 17412 33482 0 +/data/TCGA/4ab5b1d6-21c4-4b7f-89a9-21214f53e658/TCGA-12-0619-01Z-00-DX3.bfb91928-1b12-46dc-a734-dd87ae164c13.svs 12634 3431 1 +/data/TCGA/4ab5b1d6-21c4-4b7f-89a9-21214f53e658/TCGA-12-0619-01Z-00-DX3.bfb91928-1b12-46dc-a734-dd87ae164c13.svs 43994 21328 2 +/data/TCGA/ef7fcc3a-ae85-4753-8ee3-a8e999eee196/TCGA-DD-A73A-01Z-00-DX1.6B409977-53A6-4DD9-9763-2094E5B83942.svs 62800 41990 0 +/data/TCGA/ef7fcc3a-ae85-4753-8ee3-a8e999eee196/TCGA-DD-A73A-01Z-00-DX1.6B409977-53A6-4DD9-9763-2094E5B83942.svs 20705 29106 1 +/data/TCGA/ef7fcc3a-ae85-4753-8ee3-a8e999eee196/TCGA-DD-A73A-01Z-00-DX1.6B409977-53A6-4DD9-9763-2094E5B83942.svs 29733 40229 2 +/data/TCGA/ef7fcc3a-ae85-4753-8ee3-a8e999eee196/TCGA-DD-A73A-01Z-00-DX1.6B409977-53A6-4DD9-9763-2094E5B83942.svs 9475 24824 3 +/data/TCGA/e5659a71-6088-4aad-b97a-d3db0a4e5fa3/TCGA-WK-A8XT-01Z-00-DX4.039EE11A-1347-4325-8649-C4B12237CB94.svs 77343 25051 0 +/data/TCGA/e5659a71-6088-4aad-b97a-d3db0a4e5fa3/TCGA-WK-A8XT-01Z-00-DX4.039EE11A-1347-4325-8649-C4B12237CB94.svs 86054 65150 1 +/data/TCGA/e5659a71-6088-4aad-b97a-d3db0a4e5fa3/TCGA-WK-A8XT-01Z-00-DX4.039EE11A-1347-4325-8649-C4B12237CB94.svs 83264 41507 2 +/data/TCGA/e5659a71-6088-4aad-b97a-d3db0a4e5fa3/TCGA-WK-A8XT-01Z-00-DX4.039EE11A-1347-4325-8649-C4B12237CB94.svs 60032 35824 3 +/data/TCGA/8ff9cdfd-02b5-414f-b5f8-f0361ada40f4/TCGA-DU-6406-01Z-00-DX1.ad212563-154d-4090-b86c-40d91b4d9e48.svs 65663 16499 0 +/data/TCGA/8ff9cdfd-02b5-414f-b5f8-f0361ada40f4/TCGA-DU-6406-01Z-00-DX1.ad212563-154d-4090-b86c-40d91b4d9e48.svs 2866 24826 1 +/data/TCGA/8ff9cdfd-02b5-414f-b5f8-f0361ada40f4/TCGA-DU-6406-01Z-00-DX1.ad212563-154d-4090-b86c-40d91b4d9e48.svs 11765 19774 2 +/data/TCGA/8ff9cdfd-02b5-414f-b5f8-f0361ada40f4/TCGA-DU-6406-01Z-00-DX1.ad212563-154d-4090-b86c-40d91b4d9e48.svs 64107 20119 3 +/data/TCGA/50ca679d-dbba-43a0-b1c6-1c9436e88a30/TCGA-3A-A9IX-01Z-00-DX1.08369AC8-78D3-4E4C-8D8D-7CA4B1993734.svs 50756 52241 0 +/data/TCGA/50ca679d-dbba-43a0-b1c6-1c9436e88a30/TCGA-3A-A9IX-01Z-00-DX1.08369AC8-78D3-4E4C-8D8D-7CA4B1993734.svs 43746 52954 1 +/data/TCGA/50ca679d-dbba-43a0-b1c6-1c9436e88a30/TCGA-3A-A9IX-01Z-00-DX1.08369AC8-78D3-4E4C-8D8D-7CA4B1993734.svs 5620 36671 2 +/data/TCGA/50ca679d-dbba-43a0-b1c6-1c9436e88a30/TCGA-3A-A9IX-01Z-00-DX1.08369AC8-78D3-4E4C-8D8D-7CA4B1993734.svs 58631 22575 3 +/data/TCGA/05d65a4b-59c7-44fa-907e-a8c811b6906f/TCGA-23-1809-01Z-00-DX1.A8767DEC-EB1A-4EDC-906E-C0560A30455F.svs 51643 44609 0 +/data/TCGA/05d65a4b-59c7-44fa-907e-a8c811b6906f/TCGA-23-1809-01Z-00-DX1.A8767DEC-EB1A-4EDC-906E-C0560A30455F.svs 58129 33353 1 +/data/TCGA/05d65a4b-59c7-44fa-907e-a8c811b6906f/TCGA-23-1809-01Z-00-DX1.A8767DEC-EB1A-4EDC-906E-C0560A30455F.svs 25646 28500 2 +/data/TCGA/05d65a4b-59c7-44fa-907e-a8c811b6906f/TCGA-23-1809-01Z-00-DX1.A8767DEC-EB1A-4EDC-906E-C0560A30455F.svs 83194 28405 3 +/data/TCGA/6f2fa6e0-1e06-413c-a5ea-e3cddf24f1be/TCGA-A7-A2KD-01Z-00-DX1.BFF2DFC8-1D95-4DC2-98FC-5BD7D7C6CDF5.svs 144502 29111 0 +/data/TCGA/6f2fa6e0-1e06-413c-a5ea-e3cddf24f1be/TCGA-A7-A2KD-01Z-00-DX1.BFF2DFC8-1D95-4DC2-98FC-5BD7D7C6CDF5.svs 79805 20127 1 +/data/TCGA/6f2fa6e0-1e06-413c-a5ea-e3cddf24f1be/TCGA-A7-A2KD-01Z-00-DX1.BFF2DFC8-1D95-4DC2-98FC-5BD7D7C6CDF5.svs 72597 24716 2 +/data/TCGA/6f2fa6e0-1e06-413c-a5ea-e3cddf24f1be/TCGA-A7-A2KD-01Z-00-DX1.BFF2DFC8-1D95-4DC2-98FC-5BD7D7C6CDF5.svs 75804 22299 3 +/data/TCGA/31fe0eff-5824-4ca4-9829-f42695fd8aca/TCGA-BF-A1PU-01Z-00-DX1.CB0A52E3-16A9-46B2-BBE1-149A6CAAB9CF.svs 10042 10729 0 +/data/TCGA/31fe0eff-5824-4ca4-9829-f42695fd8aca/TCGA-BF-A1PU-01Z-00-DX1.CB0A52E3-16A9-46B2-BBE1-149A6CAAB9CF.svs 28143 5481 1 +/data/TCGA/31fe0eff-5824-4ca4-9829-f42695fd8aca/TCGA-BF-A1PU-01Z-00-DX1.CB0A52E3-16A9-46B2-BBE1-149A6CAAB9CF.svs 10973 11326 2 +/data/TCGA/2dcc76cb-def9-4a2c-846d-a0de5093ed68/TCGA-E8-A2EA-01Z-00-DX1.12EF1A77-B87D-4B85-9356-3836F0459EDE.svs 35747 32779 0 +/data/TCGA/2dcc76cb-def9-4a2c-846d-a0de5093ed68/TCGA-E8-A2EA-01Z-00-DX1.12EF1A77-B87D-4B85-9356-3836F0459EDE.svs 35445 23899 1 +/data/TCGA/2dcc76cb-def9-4a2c-846d-a0de5093ed68/TCGA-E8-A2EA-01Z-00-DX1.12EF1A77-B87D-4B85-9356-3836F0459EDE.svs 5849 10383 2 +/data/TCGA/31488f1c-5b07-464e-b04a-5f34226291eb/TCGA-D3-A3MO-06Z-00-DX1.F375C5A1-723B-4F61-B1AB-6AF1B944A327.svs 24017 33806 0 +/data/TCGA/31488f1c-5b07-464e-b04a-5f34226291eb/TCGA-D3-A3MO-06Z-00-DX1.F375C5A1-723B-4F61-B1AB-6AF1B944A327.svs 36521 11457 1 +/data/TCGA/31488f1c-5b07-464e-b04a-5f34226291eb/TCGA-D3-A3MO-06Z-00-DX1.F375C5A1-723B-4F61-B1AB-6AF1B944A327.svs 26881 28332 2 +/data/TCGA/48d97a77-c003-4daf-a17d-bc911744e962/TCGA-DS-A1O9-01Z-00-DX1.6A00B44C-75A7-4949-8331-645EEA70DE91.svs 57896 46538 0 +/data/TCGA/48d97a77-c003-4daf-a17d-bc911744e962/TCGA-DS-A1O9-01Z-00-DX1.6A00B44C-75A7-4949-8331-645EEA70DE91.svs 96750 44097 1 +/data/TCGA/48d97a77-c003-4daf-a17d-bc911744e962/TCGA-DS-A1O9-01Z-00-DX1.6A00B44C-75A7-4949-8331-645EEA70DE91.svs 29742 23952 2 +/data/TCGA/48d97a77-c003-4daf-a17d-bc911744e962/TCGA-DS-A1O9-01Z-00-DX1.6A00B44C-75A7-4949-8331-645EEA70DE91.svs 40770 15785 3 +/data/TCGA/13fe5bd8-978e-40cf-9ff2-c8f6eaa10b92/TCGA-IG-A3YC-01Z-00-DX1.71785237-8DA6-4034-9CDA-9BE227D53A49.svs 86373 35880 0 +/data/TCGA/13fe5bd8-978e-40cf-9ff2-c8f6eaa10b92/TCGA-IG-A3YC-01Z-00-DX1.71785237-8DA6-4034-9CDA-9BE227D53A49.svs 49339 24714 1 +/data/TCGA/13fe5bd8-978e-40cf-9ff2-c8f6eaa10b92/TCGA-IG-A3YC-01Z-00-DX1.71785237-8DA6-4034-9CDA-9BE227D53A49.svs 70313 24972 2 +/data/TCGA/13fe5bd8-978e-40cf-9ff2-c8f6eaa10b92/TCGA-IG-A3YC-01Z-00-DX1.71785237-8DA6-4034-9CDA-9BE227D53A49.svs 71350 43154 3 +/data/TCGA/55807610-a8ac-4333-b893-c74c2b59d973/TCGA-DD-A4ND-01Z-00-DX1.55D61F34-B93A-4555-8348-3EDD40B01066.svs 47968 15553 0 +/data/TCGA/55807610-a8ac-4333-b893-c74c2b59d973/TCGA-DD-A4ND-01Z-00-DX1.55D61F34-B93A-4555-8348-3EDD40B01066.svs 45887 27968 1 +/data/TCGA/55807610-a8ac-4333-b893-c74c2b59d973/TCGA-DD-A4ND-01Z-00-DX1.55D61F34-B93A-4555-8348-3EDD40B01066.svs 37401 19071 2 +/data/TCGA/55807610-a8ac-4333-b893-c74c2b59d973/TCGA-DD-A4ND-01Z-00-DX1.55D61F34-B93A-4555-8348-3EDD40B01066.svs 51732 47964 3 +/data/TCGA/cc78ab7c-a334-4dfb-bbeb-5bcd6947cbb6/TCGA-B0-4810-01Z-00-DX1.c3874ffc-31ff-41c3-a474-48e2ff90783c.svs 32558 44016 0 +/data/TCGA/cc78ab7c-a334-4dfb-bbeb-5bcd6947cbb6/TCGA-B0-4810-01Z-00-DX1.c3874ffc-31ff-41c3-a474-48e2ff90783c.svs 19613 37667 1 +/data/TCGA/cc78ab7c-a334-4dfb-bbeb-5bcd6947cbb6/TCGA-B0-4810-01Z-00-DX1.c3874ffc-31ff-41c3-a474-48e2ff90783c.svs 89665 28986 2 +/data/TCGA/cc78ab7c-a334-4dfb-bbeb-5bcd6947cbb6/TCGA-B0-4810-01Z-00-DX1.c3874ffc-31ff-41c3-a474-48e2ff90783c.svs 44884 46618 3 +/data/TCGA/6199dc0f-bdc2-49e0-b891-51ef13169aa0/TCGA-AJ-A4ZG-01Z-00-DX1.6EC032CB-9951-46C3-A0A6-B8F433F28A5D.svs 19195 11539 0 +/data/TCGA/6199dc0f-bdc2-49e0-b891-51ef13169aa0/TCGA-AJ-A4ZG-01Z-00-DX1.6EC032CB-9951-46C3-A0A6-B8F433F28A5D.svs 1821 11536 1 +/data/TCGA/6199dc0f-bdc2-49e0-b891-51ef13169aa0/TCGA-AJ-A4ZG-01Z-00-DX1.6EC032CB-9951-46C3-A0A6-B8F433F28A5D.svs 7928 20754 2 +/data/TCGA/54e55d74-b18d-47e2-ac66-fd8f9e1f6094/TCGA-22-4599-01Z-00-DX1.2178D5C0-A444-44F5-B878-F5D1FB2943C9.svs 71132 54462 0 +/data/TCGA/54e55d74-b18d-47e2-ac66-fd8f9e1f6094/TCGA-22-4599-01Z-00-DX1.2178D5C0-A444-44F5-B878-F5D1FB2943C9.svs 12875 27876 1 +/data/TCGA/54e55d74-b18d-47e2-ac66-fd8f9e1f6094/TCGA-22-4599-01Z-00-DX1.2178D5C0-A444-44F5-B878-F5D1FB2943C9.svs 61046 38492 2 +/data/TCGA/54e55d74-b18d-47e2-ac66-fd8f9e1f6094/TCGA-22-4599-01Z-00-DX1.2178D5C0-A444-44F5-B878-F5D1FB2943C9.svs 65311 12172 3 +/data/TCGA/eb374ebb-2032-46b5-b01b-679e75c7309f/TCGA-HT-7879-01Z-00-DX1.4ACC4CED-056B-4F63-86E6-D08206991030.svs 83097 24595 0 +/data/TCGA/eb374ebb-2032-46b5-b01b-679e75c7309f/TCGA-HT-7879-01Z-00-DX1.4ACC4CED-056B-4F63-86E6-D08206991030.svs 41328 17412 1 +/data/TCGA/eb374ebb-2032-46b5-b01b-679e75c7309f/TCGA-HT-7879-01Z-00-DX1.4ACC4CED-056B-4F63-86E6-D08206991030.svs 58030 17621 2 +/data/TCGA/eb374ebb-2032-46b5-b01b-679e75c7309f/TCGA-HT-7879-01Z-00-DX1.4ACC4CED-056B-4F63-86E6-D08206991030.svs 59696 7923 3 +/data/TCGA/52a289a7-26ff-4305-a119-140b6a41f489/TCGA-X6-A8C7-01Z-00-DX5.8C4E6818-B110-49DB-9C20-74B7B52DB97F.svs 23437 38067 0 +/data/TCGA/52a289a7-26ff-4305-a119-140b6a41f489/TCGA-X6-A8C7-01Z-00-DX5.8C4E6818-B110-49DB-9C20-74B7B52DB97F.svs 30845 52252 1 +/data/TCGA/52a289a7-26ff-4305-a119-140b6a41f489/TCGA-X6-A8C7-01Z-00-DX5.8C4E6818-B110-49DB-9C20-74B7B52DB97F.svs 71094 52658 2 +/data/TCGA/52a289a7-26ff-4305-a119-140b6a41f489/TCGA-X6-A8C7-01Z-00-DX5.8C4E6818-B110-49DB-9C20-74B7B52DB97F.svs 27649 76145 3 +/data/TCGA/472884cf-6b0e-477a-80b0-75920fecd48a/TCGA-IG-A8O2-01Z-00-DX1.FABD0323-82D9-44F2-87B5-E5A93FEB64DE.svs 40943 63163 0 +/data/TCGA/472884cf-6b0e-477a-80b0-75920fecd48a/TCGA-IG-A8O2-01Z-00-DX1.FABD0323-82D9-44F2-87B5-E5A93FEB64DE.svs 29492 60923 1 +/data/TCGA/472884cf-6b0e-477a-80b0-75920fecd48a/TCGA-IG-A8O2-01Z-00-DX1.FABD0323-82D9-44F2-87B5-E5A93FEB64DE.svs 25608 22550 2 +/data/TCGA/472884cf-6b0e-477a-80b0-75920fecd48a/TCGA-IG-A8O2-01Z-00-DX1.FABD0323-82D9-44F2-87B5-E5A93FEB64DE.svs 20564 25703 3 +/data/TCGA/f17e5487-7212-4c75-8f1f-2a7401eb051f/TCGA-A5-A1OF-01Z-00-DX1.4FACCD45-8937-4688-BEC6-A5B0909753A5.svs 51471 39774 0 +/data/TCGA/f17e5487-7212-4c75-8f1f-2a7401eb051f/TCGA-A5-A1OF-01Z-00-DX1.4FACCD45-8937-4688-BEC6-A5B0909753A5.svs 23151 88398 1 +/data/TCGA/f17e5487-7212-4c75-8f1f-2a7401eb051f/TCGA-A5-A1OF-01Z-00-DX1.4FACCD45-8937-4688-BEC6-A5B0909753A5.svs 83894 60527 2 +/data/TCGA/f17e5487-7212-4c75-8f1f-2a7401eb051f/TCGA-A5-A1OF-01Z-00-DX1.4FACCD45-8937-4688-BEC6-A5B0909753A5.svs 16299 11070 3 +/data/TCGA/0de078d1-27d2-43fc-8173-ee9cf8e42e42/TCGA-02-0001-01Z-00-DX1.83fce43e-42ac-4dcd-b156-2908e75f2e47.svs 12482 26510 0 +/data/TCGA/0de078d1-27d2-43fc-8173-ee9cf8e42e42/TCGA-02-0001-01Z-00-DX1.83fce43e-42ac-4dcd-b156-2908e75f2e47.svs 21419 6845 1 +/data/TCGA/0de078d1-27d2-43fc-8173-ee9cf8e42e42/TCGA-02-0001-01Z-00-DX1.83fce43e-42ac-4dcd-b156-2908e75f2e47.svs 17961 15340 2 +/data/TCGA/ffa3249f-a607-45b5-bdb9-848d18c337eb/TCGA-FK-A4UB-01Z-00-DX1.7D9BFA84-A8EE-494F-B97C-35199782C750.svs 45586 32628 0 +/data/TCGA/ffa3249f-a607-45b5-bdb9-848d18c337eb/TCGA-FK-A4UB-01Z-00-DX1.7D9BFA84-A8EE-494F-B97C-35199782C750.svs 6440 35460 1 +/data/TCGA/ffa3249f-a607-45b5-bdb9-848d18c337eb/TCGA-FK-A4UB-01Z-00-DX1.7D9BFA84-A8EE-494F-B97C-35199782C750.svs 44660 44277 2 +/data/TCGA/ffa3249f-a607-45b5-bdb9-848d18c337eb/TCGA-FK-A4UB-01Z-00-DX1.7D9BFA84-A8EE-494F-B97C-35199782C750.svs 2576 29103 3 +/data/TCGA/8e498844-a6a1-4ebf-b7a8-458f5ccdd51d/TCGA-EI-6885-01Z-00-DX1.ffb69ea3-047f-4ec5-b54c-e4f0ef3bf370.svs 132910 11251 0 +/data/TCGA/8e498844-a6a1-4ebf-b7a8-458f5ccdd51d/TCGA-EI-6885-01Z-00-DX1.ffb69ea3-047f-4ec5-b54c-e4f0ef3bf370.svs 18038 9828 1 +/data/TCGA/8e498844-a6a1-4ebf-b7a8-458f5ccdd51d/TCGA-EI-6885-01Z-00-DX1.ffb69ea3-047f-4ec5-b54c-e4f0ef3bf370.svs 6152 19577 2 +/data/TCGA/8e498844-a6a1-4ebf-b7a8-458f5ccdd51d/TCGA-EI-6885-01Z-00-DX1.ffb69ea3-047f-4ec5-b54c-e4f0ef3bf370.svs 73010 8033 3 +/data/TCGA/82583ba0-73b8-4ce2-a8f5-912566b8b92b/TCGA-5P-A9KF-01Z-00-DX1.E35ED527-BD60-4534-B23A-D4DDACA2EB6D.svs 75093 59319 0 +/data/TCGA/82583ba0-73b8-4ce2-a8f5-912566b8b92b/TCGA-5P-A9KF-01Z-00-DX1.E35ED527-BD60-4534-B23A-D4DDACA2EB6D.svs 77236 74316 1 +/data/TCGA/82583ba0-73b8-4ce2-a8f5-912566b8b92b/TCGA-5P-A9KF-01Z-00-DX1.E35ED527-BD60-4534-B23A-D4DDACA2EB6D.svs 90918 112869 2 +/data/TCGA/82583ba0-73b8-4ce2-a8f5-912566b8b92b/TCGA-5P-A9KF-01Z-00-DX1.E35ED527-BD60-4534-B23A-D4DDACA2EB6D.svs 69180 116678 3 +/data/TCGA/82583ba0-73b8-4ce2-a8f5-912566b8b92b/TCGA-5P-A9KF-01Z-00-DX1.E35ED527-BD60-4534-B23A-D4DDACA2EB6D.svs 65604 42966 4 +/data/TCGA/206a8f47-80e7-42bf-9087-ce61862a33a5/TCGA-XR-A8TE-01Z-00-DX1.BAA09A5C-74E3-4BF2-B08F-743886222E1B.svs 50300 28712 0 +/data/TCGA/206a8f47-80e7-42bf-9087-ce61862a33a5/TCGA-XR-A8TE-01Z-00-DX1.BAA09A5C-74E3-4BF2-B08F-743886222E1B.svs 18038 53175 1 +/data/TCGA/206a8f47-80e7-42bf-9087-ce61862a33a5/TCGA-XR-A8TE-01Z-00-DX1.BAA09A5C-74E3-4BF2-B08F-743886222E1B.svs 22191 14405 2 +/data/TCGA/206a8f47-80e7-42bf-9087-ce61862a33a5/TCGA-XR-A8TE-01Z-00-DX1.BAA09A5C-74E3-4BF2-B08F-743886222E1B.svs 85016 11872 3 +/data/TCGA/d1c9c164-e47e-444a-aef2-7535a1a30b12/TCGA-ZX-AA5X-01Z-00-DX1.8C4B54F5-409B-4A62-AA88-B079606D2D45.svs 41543 19580 0 +/data/TCGA/d1c9c164-e47e-444a-aef2-7535a1a30b12/TCGA-ZX-AA5X-01Z-00-DX1.8C4B54F5-409B-4A62-AA88-B079606D2D45.svs 40377 22388 1 +/data/TCGA/d1c9c164-e47e-444a-aef2-7535a1a30b12/TCGA-ZX-AA5X-01Z-00-DX1.8C4B54F5-409B-4A62-AA88-B079606D2D45.svs 21068 5354 2 +/data/TCGA/5dddda2b-4a82-479e-926d-12abdfd1338a/TCGA-GR-A4D5-01Z-00-DX1.D80C72B3-C80D-47E4-AF4B-44AB5F1AD8C5.svs 20868 25404 0 +/data/TCGA/5dddda2b-4a82-479e-926d-12abdfd1338a/TCGA-GR-A4D5-01Z-00-DX1.D80C72B3-C80D-47E4-AF4B-44AB5F1AD8C5.svs 23411 13089 1 +/data/TCGA/5dddda2b-4a82-479e-926d-12abdfd1338a/TCGA-GR-A4D5-01Z-00-DX1.D80C72B3-C80D-47E4-AF4B-44AB5F1AD8C5.svs 8854 9260 2 +/data/TCGA/58d08236-4147-48bb-99aa-7a6f6d8fd67b/TCGA-FE-A3PB-01Z-00-DX1.FBB5CA1C-6B8D-4F71-A4D2-382B055CF008.svs 49329 43403 0 +/data/TCGA/58d08236-4147-48bb-99aa-7a6f6d8fd67b/TCGA-FE-A3PB-01Z-00-DX1.FBB5CA1C-6B8D-4F71-A4D2-382B055CF008.svs 19440 20356 1 +/data/TCGA/58d08236-4147-48bb-99aa-7a6f6d8fd67b/TCGA-FE-A3PB-01Z-00-DX1.FBB5CA1C-6B8D-4F71-A4D2-382B055CF008.svs 61185 47494 2 +/data/TCGA/58d08236-4147-48bb-99aa-7a6f6d8fd67b/TCGA-FE-A3PB-01Z-00-DX1.FBB5CA1C-6B8D-4F71-A4D2-382B055CF008.svs 46146 35264 3 +/data/TCGA/2f2383b8-f09e-4268-9399-9013b13d3e73/TCGA-06-0238-01Z-00-DX1.3ee95605-124e-4849-a36b-eee7e19ce3de.svs 7920 6332 0 +/data/TCGA/2f2383b8-f09e-4268-9399-9013b13d3e73/TCGA-06-0238-01Z-00-DX1.3ee95605-124e-4849-a36b-eee7e19ce3de.svs 5687 7287 1 +/data/TCGA/2f2383b8-f09e-4268-9399-9013b13d3e73/TCGA-06-0238-01Z-00-DX1.3ee95605-124e-4849-a36b-eee7e19ce3de.svs 3633 3950 2 +/data/TCGA/ffe223d1-da53-49f2-8f5c-297b0cfce277/TCGA-M7-A724-01Z-00-DX1.9A09FA7A-21B8-4F04-BA5D-CA6D81334B0C.svs 17686 33283 0 +/data/TCGA/ffe223d1-da53-49f2-8f5c-297b0cfce277/TCGA-M7-A724-01Z-00-DX1.9A09FA7A-21B8-4F04-BA5D-CA6D81334B0C.svs 97843 15054 1 +/data/TCGA/ffe223d1-da53-49f2-8f5c-297b0cfce277/TCGA-M7-A724-01Z-00-DX1.9A09FA7A-21B8-4F04-BA5D-CA6D81334B0C.svs 93838 24065 2 +/data/TCGA/ffe223d1-da53-49f2-8f5c-297b0cfce277/TCGA-M7-A724-01Z-00-DX1.9A09FA7A-21B8-4F04-BA5D-CA6D81334B0C.svs 2659 14022 3 +/data/TCGA/406a565e-8e41-41e9-a870-f3e26f067842/TCGA-X6-A8C4-01Z-00-DX3.211D82B8-6161-4217-8D55-B039DE9503ED.svs 116763 63061 0 +/data/TCGA/406a565e-8e41-41e9-a870-f3e26f067842/TCGA-X6-A8C4-01Z-00-DX3.211D82B8-6161-4217-8D55-B039DE9503ED.svs 40593 51122 1 +/data/TCGA/406a565e-8e41-41e9-a870-f3e26f067842/TCGA-X6-A8C4-01Z-00-DX3.211D82B8-6161-4217-8D55-B039DE9503ED.svs 95953 40456 2 +/data/TCGA/406a565e-8e41-41e9-a870-f3e26f067842/TCGA-X6-A8C4-01Z-00-DX3.211D82B8-6161-4217-8D55-B039DE9503ED.svs 49008 31192 3 +/data/TCGA/86cd13dc-6538-4444-b47e-fcd378d05d52/TCGA-12-0827-01Z-00-DX3.CC3B9B34-4BD8-4C93-ACC8-29BC2D3D93E0.svs 49141 27987 0 +/data/TCGA/86cd13dc-6538-4444-b47e-fcd378d05d52/TCGA-12-0827-01Z-00-DX3.CC3B9B34-4BD8-4C93-ACC8-29BC2D3D93E0.svs 35601 26096 1 +/data/TCGA/86cd13dc-6538-4444-b47e-fcd378d05d52/TCGA-12-0827-01Z-00-DX3.CC3B9B34-4BD8-4C93-ACC8-29BC2D3D93E0.svs 37346 21210 2 +/data/TCGA/86cd13dc-6538-4444-b47e-fcd378d05d52/TCGA-12-0827-01Z-00-DX3.CC3B9B34-4BD8-4C93-ACC8-29BC2D3D93E0.svs 57030 2908 3 +/data/TCGA/56abf563-a1e8-48b7-8fac-3ee35c5de98a/TCGA-B6-A1KF-01Z-00-DX1.2E08E830-4216-4CD0-9646-1F489300E11D.svs 46072 56769 0 +/data/TCGA/56abf563-a1e8-48b7-8fac-3ee35c5de98a/TCGA-B6-A1KF-01Z-00-DX1.2E08E830-4216-4CD0-9646-1F489300E11D.svs 103731 7031 1 +/data/TCGA/56abf563-a1e8-48b7-8fac-3ee35c5de98a/TCGA-B6-A1KF-01Z-00-DX1.2E08E830-4216-4CD0-9646-1F489300E11D.svs 71839 14637 2 +/data/TCGA/56abf563-a1e8-48b7-8fac-3ee35c5de98a/TCGA-B6-A1KF-01Z-00-DX1.2E08E830-4216-4CD0-9646-1F489300E11D.svs 69881 65402 3 +/data/TCGA/88fcd2b1-5383-4a35-8a1e-ccbbf0f24f20/TCGA-D1-A0ZR-01Z-00-DX1.E126678B-0C0C-4632-98D7-E8297065E745.svs 46457 60637 0 +/data/TCGA/88fcd2b1-5383-4a35-8a1e-ccbbf0f24f20/TCGA-D1-A0ZR-01Z-00-DX1.E126678B-0C0C-4632-98D7-E8297065E745.svs 98844 7459 1 +/data/TCGA/88fcd2b1-5383-4a35-8a1e-ccbbf0f24f20/TCGA-D1-A0ZR-01Z-00-DX1.E126678B-0C0C-4632-98D7-E8297065E745.svs 53538 56405 2 +/data/TCGA/88fcd2b1-5383-4a35-8a1e-ccbbf0f24f20/TCGA-D1-A0ZR-01Z-00-DX1.E126678B-0C0C-4632-98D7-E8297065E745.svs 75294 3777 3 +/data/TCGA/4ffc6737-cc10-4394-b543-593e7f3ccedd/TCGA-E9-A1ND-01Z-00-DX1.5C2F5250-A3B2-4B97-9E11-56CF3C7CA2DB.svs 11492 16500 0 +/data/TCGA/4ffc6737-cc10-4394-b543-593e7f3ccedd/TCGA-E9-A1ND-01Z-00-DX1.5C2F5250-A3B2-4B97-9E11-56CF3C7CA2DB.svs 36005 40363 1 +/data/TCGA/4ffc6737-cc10-4394-b543-593e7f3ccedd/TCGA-E9-A1ND-01Z-00-DX1.5C2F5250-A3B2-4B97-9E11-56CF3C7CA2DB.svs 51231 39834 2 +/data/TCGA/4ffc6737-cc10-4394-b543-593e7f3ccedd/TCGA-E9-A1ND-01Z-00-DX1.5C2F5250-A3B2-4B97-9E11-56CF3C7CA2DB.svs 42340 45708 3 +/data/TCGA/892a3866-38ff-43b1-b6b3-76496c3784c5/TCGA-EJ-5512-01Z-00-DX1.6034a735-b58c-4a6d-886a-b0a153bedeee.svs 16529 42224 0 +/data/TCGA/892a3866-38ff-43b1-b6b3-76496c3784c5/TCGA-EJ-5512-01Z-00-DX1.6034a735-b58c-4a6d-886a-b0a153bedeee.svs 43630 15179 1 +/data/TCGA/892a3866-38ff-43b1-b6b3-76496c3784c5/TCGA-EJ-5512-01Z-00-DX1.6034a735-b58c-4a6d-886a-b0a153bedeee.svs 44216 37882 2 +/data/TCGA/892a3866-38ff-43b1-b6b3-76496c3784c5/TCGA-EJ-5512-01Z-00-DX1.6034a735-b58c-4a6d-886a-b0a153bedeee.svs 41465 35706 3 +/data/TCGA/416fc507-39bb-4a82-ad75-00e45fb89942/TCGA-S9-A7IY-01Z-00-DX1.185F1FC6-576A-4AAF-9BE0-250489B3E7C4.svs 95206 8237 0 +/data/TCGA/416fc507-39bb-4a82-ad75-00e45fb89942/TCGA-S9-A7IY-01Z-00-DX1.185F1FC6-576A-4AAF-9BE0-250489B3E7C4.svs 45307 35766 1 +/data/TCGA/416fc507-39bb-4a82-ad75-00e45fb89942/TCGA-S9-A7IY-01Z-00-DX1.185F1FC6-576A-4AAF-9BE0-250489B3E7C4.svs 80617 35779 2 +/data/TCGA/416fc507-39bb-4a82-ad75-00e45fb89942/TCGA-S9-A7IY-01Z-00-DX1.185F1FC6-576A-4AAF-9BE0-250489B3E7C4.svs 83070 22717 3 +/data/TCGA/1a6ffdf0-7ca5-427e-9982-87c05248aca5/TCGA-CN-4741-01Z-00-DX1.6adfce37-b5b0-44ff-834e-85059eec24c0.svs 121718 25287 0 +/data/TCGA/1a6ffdf0-7ca5-427e-9982-87c05248aca5/TCGA-CN-4741-01Z-00-DX1.6adfce37-b5b0-44ff-834e-85059eec24c0.svs 123729 41301 1 +/data/TCGA/1a6ffdf0-7ca5-427e-9982-87c05248aca5/TCGA-CN-4741-01Z-00-DX1.6adfce37-b5b0-44ff-834e-85059eec24c0.svs 117807 59981 2 +/data/TCGA/1a6ffdf0-7ca5-427e-9982-87c05248aca5/TCGA-CN-4741-01Z-00-DX1.6adfce37-b5b0-44ff-834e-85059eec24c0.svs 29644 53146 3 +/data/TCGA/f577ac42-d711-4c26-8fb9-c86e88f6cae5/TCGA-QR-A6GO-01Z-00-DX1.D41FDCC9-65C3-41B0-A22C-2F0C397EF9DC.svs 30920 20174 0 +/data/TCGA/f577ac42-d711-4c26-8fb9-c86e88f6cae5/TCGA-QR-A6GO-01Z-00-DX1.D41FDCC9-65C3-41B0-A22C-2F0C397EF9DC.svs 44488 14702 1 +/data/TCGA/f577ac42-d711-4c26-8fb9-c86e88f6cae5/TCGA-QR-A6GO-01Z-00-DX1.D41FDCC9-65C3-41B0-A22C-2F0C397EF9DC.svs 28187 29199 2 +/data/TCGA/f577ac42-d711-4c26-8fb9-c86e88f6cae5/TCGA-QR-A6GO-01Z-00-DX1.D41FDCC9-65C3-41B0-A22C-2F0C397EF9DC.svs 48961 50712 3 +/data/TCGA/cf69ef1a-edca-4aca-adc4-a9c69031f0b2/TCGA-EL-A3N3-01Z-00-DX1.7EBD18A4-3A24-4AFD-8CD4-F2BAF60BE32A.svs 13463 9147 0 +/data/TCGA/cf69ef1a-edca-4aca-adc4-a9c69031f0b2/TCGA-EL-A3N3-01Z-00-DX1.7EBD18A4-3A24-4AFD-8CD4-F2BAF60BE32A.svs 24002 16276 1 +/data/TCGA/cf69ef1a-edca-4aca-adc4-a9c69031f0b2/TCGA-EL-A3N3-01Z-00-DX1.7EBD18A4-3A24-4AFD-8CD4-F2BAF60BE32A.svs 9149 10440 2 +/data/TCGA/cf69ef1a-edca-4aca-adc4-a9c69031f0b2/TCGA-EL-A3N3-01Z-00-DX1.7EBD18A4-3A24-4AFD-8CD4-F2BAF60BE32A.svs 24740 32585 3 +/data/TCGA/ff8cc037-3166-41b4-a66c-3da9871ada8f/TCGA-CV-A45U-01Z-00-DX1.ABAEB988-816B-4644-B3A8-C2A83679E28E.svs 5384 49121 0 +/data/TCGA/ff8cc037-3166-41b4-a66c-3da9871ada8f/TCGA-CV-A45U-01Z-00-DX1.ABAEB988-816B-4644-B3A8-C2A83679E28E.svs 35534 46955 1 +/data/TCGA/ff8cc037-3166-41b4-a66c-3da9871ada8f/TCGA-CV-A45U-01Z-00-DX1.ABAEB988-816B-4644-B3A8-C2A83679E28E.svs 39394 35637 2 +/data/TCGA/ff8cc037-3166-41b4-a66c-3da9871ada8f/TCGA-CV-A45U-01Z-00-DX1.ABAEB988-816B-4644-B3A8-C2A83679E28E.svs 56164 9963 3 +/data/TCGA/b712cd21-2112-437d-9177-fc5f3c2310e6/TCGA-DJ-A3VJ-01Z-00-DX1.84EE18A7-A597-4D0E-80E6-FB4A9361D512.svs 113124 72031 0 +/data/TCGA/b712cd21-2112-437d-9177-fc5f3c2310e6/TCGA-DJ-A3VJ-01Z-00-DX1.84EE18A7-A597-4D0E-80E6-FB4A9361D512.svs 64785 36208 1 +/data/TCGA/b712cd21-2112-437d-9177-fc5f3c2310e6/TCGA-DJ-A3VJ-01Z-00-DX1.84EE18A7-A597-4D0E-80E6-FB4A9361D512.svs 68302 32898 2 +/data/TCGA/b712cd21-2112-437d-9177-fc5f3c2310e6/TCGA-DJ-A3VJ-01Z-00-DX1.84EE18A7-A597-4D0E-80E6-FB4A9361D512.svs 100362 73540 3 +/data/TCGA/0ff4a32a-6014-4693-b22c-4d0953654a8c/TCGA-MY-A5BE-01Z-00-DX1.C345ACDE-83AF-4EB1-9B4C-EBA16F89CB9F.svs 89117 33194 0 +/data/TCGA/0ff4a32a-6014-4693-b22c-4d0953654a8c/TCGA-MY-A5BE-01Z-00-DX1.C345ACDE-83AF-4EB1-9B4C-EBA16F89CB9F.svs 58052 37849 1 +/data/TCGA/0ff4a32a-6014-4693-b22c-4d0953654a8c/TCGA-MY-A5BE-01Z-00-DX1.C345ACDE-83AF-4EB1-9B4C-EBA16F89CB9F.svs 34059 30463 2 +/data/TCGA/0ff4a32a-6014-4693-b22c-4d0953654a8c/TCGA-MY-A5BE-01Z-00-DX1.C345ACDE-83AF-4EB1-9B4C-EBA16F89CB9F.svs 76703 11756 3 +/data/TCGA/a9f1be46-b64c-455f-a29f-9261f89a7dc5/TCGA-19-5960-01Z-00-DX1.3376dcf2-9873-445e-83a9-95c5b208efc7.svs 111969 10675 0 +/data/TCGA/a9f1be46-b64c-455f-a29f-9261f89a7dc5/TCGA-19-5960-01Z-00-DX1.3376dcf2-9873-445e-83a9-95c5b208efc7.svs 117479 45354 1 +/data/TCGA/a9f1be46-b64c-455f-a29f-9261f89a7dc5/TCGA-19-5960-01Z-00-DX1.3376dcf2-9873-445e-83a9-95c5b208efc7.svs 4463 17922 2 +/data/TCGA/a9f1be46-b64c-455f-a29f-9261f89a7dc5/TCGA-19-5960-01Z-00-DX1.3376dcf2-9873-445e-83a9-95c5b208efc7.svs 4617 7151 3 +/data/TCGA/b5d1e455-5c25-4ad1-87b5-b56776d17baf/TCGA-AA-A00W-01Z-00-DX1.24770462-BD63-4881-9AE3-9198E9093AD9.svs 17715 27852 0 +/data/TCGA/b5d1e455-5c25-4ad1-87b5-b56776d17baf/TCGA-AA-A00W-01Z-00-DX1.24770462-BD63-4881-9AE3-9198E9093AD9.svs 26978 27630 1 +/data/TCGA/b5d1e455-5c25-4ad1-87b5-b56776d17baf/TCGA-AA-A00W-01Z-00-DX1.24770462-BD63-4881-9AE3-9198E9093AD9.svs 38794 25145 2 +/data/TCGA/b1f7b151-be70-4bcd-a875-3aab33055166/TCGA-D8-A146-01Z-00-DX1.D93FB315-E5D7-49BA-8380-38B16B70361B.svs 35976 35082 0 +/data/TCGA/b1f7b151-be70-4bcd-a875-3aab33055166/TCGA-D8-A146-01Z-00-DX1.D93FB315-E5D7-49BA-8380-38B16B70361B.svs 11787 34915 1 +/data/TCGA/b1f7b151-be70-4bcd-a875-3aab33055166/TCGA-D8-A146-01Z-00-DX1.D93FB315-E5D7-49BA-8380-38B16B70361B.svs 14975 39812 2 +/data/TCGA/b1f7b151-be70-4bcd-a875-3aab33055166/TCGA-D8-A146-01Z-00-DX1.D93FB315-E5D7-49BA-8380-38B16B70361B.svs 27406 26931 3 +/data/TCGA/6cae6202-1746-437a-a455-d74447f0b5b0/TCGA-G7-7502-01Z-00-DX1.2ba28bc2-1b3a-415f-ba2b-26b2e76de731.svs 33236 29883 0 +/data/TCGA/6cae6202-1746-437a-a455-d74447f0b5b0/TCGA-G7-7502-01Z-00-DX1.2ba28bc2-1b3a-415f-ba2b-26b2e76de731.svs 46930 50507 1 +/data/TCGA/6cae6202-1746-437a-a455-d74447f0b5b0/TCGA-G7-7502-01Z-00-DX1.2ba28bc2-1b3a-415f-ba2b-26b2e76de731.svs 4384 24805 2 +/data/TCGA/6cae6202-1746-437a-a455-d74447f0b5b0/TCGA-G7-7502-01Z-00-DX1.2ba28bc2-1b3a-415f-ba2b-26b2e76de731.svs 27633 50713 3 +/data/TCGA/a5ec8178-fbac-4b49-9628-6e1e6bb7ea6e/TCGA-G2-AA3F-01Z-00-DX4.8DD53108-E08F-4F3C-80EE-E31D934B9BDF.svs 125689 67510 0 +/data/TCGA/a5ec8178-fbac-4b49-9628-6e1e6bb7ea6e/TCGA-G2-AA3F-01Z-00-DX4.8DD53108-E08F-4F3C-80EE-E31D934B9BDF.svs 53273 43003 1 +/data/TCGA/a5ec8178-fbac-4b49-9628-6e1e6bb7ea6e/TCGA-G2-AA3F-01Z-00-DX4.8DD53108-E08F-4F3C-80EE-E31D934B9BDF.svs 120136 49390 2 +/data/TCGA/a5ec8178-fbac-4b49-9628-6e1e6bb7ea6e/TCGA-G2-AA3F-01Z-00-DX4.8DD53108-E08F-4F3C-80EE-E31D934B9BDF.svs 57859 12260 3 +/data/TCGA/d8da6202-ec4b-4390-aa8a-0e1ebb8e7e37/TCGA-GD-A2C5-01Z-00-DX1.3A81505E-5BF9-466C-938B-28909CD88193.svs 128523 20954 0 +/data/TCGA/d8da6202-ec4b-4390-aa8a-0e1ebb8e7e37/TCGA-GD-A2C5-01Z-00-DX1.3A81505E-5BF9-466C-938B-28909CD88193.svs 72721 12040 1 +/data/TCGA/d8da6202-ec4b-4390-aa8a-0e1ebb8e7e37/TCGA-GD-A2C5-01Z-00-DX1.3A81505E-5BF9-466C-938B-28909CD88193.svs 115702 15497 2 +/data/TCGA/d8da6202-ec4b-4390-aa8a-0e1ebb8e7e37/TCGA-GD-A2C5-01Z-00-DX1.3A81505E-5BF9-466C-938B-28909CD88193.svs 101426 15061 3 +/data/TCGA/cb3614ea-be8a-489e-83e3-732a6b1264eb/TCGA-14-1401-01Z-00-DX2.c9d44615-8e8b-4434-ad30-46724c025d37.svs 1263 14518 0 +/data/TCGA/cb3614ea-be8a-489e-83e3-732a6b1264eb/TCGA-14-1401-01Z-00-DX2.c9d44615-8e8b-4434-ad30-46724c025d37.svs 13725 10324 1 +/data/TCGA/cb3614ea-be8a-489e-83e3-732a6b1264eb/TCGA-14-1401-01Z-00-DX2.c9d44615-8e8b-4434-ad30-46724c025d37.svs 2674 17848 2 +/data/TCGA/8f7cdbca-32a7-4bd3-be11-6cf7b7b03d13/TCGA-50-6591-01Z-00-DX1.12e1050b-75e9-4059-b945-291995b3e93c.svs 16459 23548 0 +/data/TCGA/8f7cdbca-32a7-4bd3-be11-6cf7b7b03d13/TCGA-50-6591-01Z-00-DX1.12e1050b-75e9-4059-b945-291995b3e93c.svs 106905 67773 1 +/data/TCGA/8f7cdbca-32a7-4bd3-be11-6cf7b7b03d13/TCGA-50-6591-01Z-00-DX1.12e1050b-75e9-4059-b945-291995b3e93c.svs 31120 15685 2 +/data/TCGA/8f7cdbca-32a7-4bd3-be11-6cf7b7b03d13/TCGA-50-6591-01Z-00-DX1.12e1050b-75e9-4059-b945-291995b3e93c.svs 124470 31261 3 +/data/TCGA/b1b445b1-3941-4bec-a27a-712ec08ac8eb/TCGA-TQ-A7RR-01Z-00-DX1.45839A23-093F-4BDE-8FF3-642DE69BD656.svs 72172 6236 0 +/data/TCGA/b1b445b1-3941-4bec-a27a-712ec08ac8eb/TCGA-TQ-A7RR-01Z-00-DX1.45839A23-093F-4BDE-8FF3-642DE69BD656.svs 39607 15666 1 +/data/TCGA/b1b445b1-3941-4bec-a27a-712ec08ac8eb/TCGA-TQ-A7RR-01Z-00-DX1.45839A23-093F-4BDE-8FF3-642DE69BD656.svs 60550 27142 2 +/data/TCGA/b1b445b1-3941-4bec-a27a-712ec08ac8eb/TCGA-TQ-A7RR-01Z-00-DX1.45839A23-093F-4BDE-8FF3-642DE69BD656.svs 19637 65008 3 +/data/TCGA/c6754722-a9ca-49c6-bd71-3188fd5068d6/TCGA-J4-A67N-01Z-00-DX1.3253614F-8B3D-4337-96C5-BF842DCAA35C.svs 121226 49451 0 +/data/TCGA/c6754722-a9ca-49c6-bd71-3188fd5068d6/TCGA-J4-A67N-01Z-00-DX1.3253614F-8B3D-4337-96C5-BF842DCAA35C.svs 148215 32503 1 +/data/TCGA/c6754722-a9ca-49c6-bd71-3188fd5068d6/TCGA-J4-A67N-01Z-00-DX1.3253614F-8B3D-4337-96C5-BF842DCAA35C.svs 51629 7215 2 +/data/TCGA/c6754722-a9ca-49c6-bd71-3188fd5068d6/TCGA-J4-A67N-01Z-00-DX1.3253614F-8B3D-4337-96C5-BF842DCAA35C.svs 45590 33124 3 +/data/TCGA/f520937e-b280-43dc-8c43-4f3a77aff298/TCGA-12-0819-01Z-00-DX1.8F874ED5-34B2-4E42-BBA5-329FB2DED709.svs 11477 18995 0 +/data/TCGA/f520937e-b280-43dc-8c43-4f3a77aff298/TCGA-12-0819-01Z-00-DX1.8F874ED5-34B2-4E42-BBA5-329FB2DED709.svs 9951 9990 1 +/data/TCGA/f520937e-b280-43dc-8c43-4f3a77aff298/TCGA-12-0819-01Z-00-DX1.8F874ED5-34B2-4E42-BBA5-329FB2DED709.svs 4395 18959 2 +/data/TCGA/bf106879-4a61-4751-8758-728f8bd17e9c/TCGA-FD-A62N-01Z-00-DX1.204E48B7-51D1-49D7-88F3-4BD33A07146A.svs 47138 31128 0 +/data/TCGA/bf106879-4a61-4751-8758-728f8bd17e9c/TCGA-FD-A62N-01Z-00-DX1.204E48B7-51D1-49D7-88F3-4BD33A07146A.svs 60099 34091 1 +/data/TCGA/bf106879-4a61-4751-8758-728f8bd17e9c/TCGA-FD-A62N-01Z-00-DX1.204E48B7-51D1-49D7-88F3-4BD33A07146A.svs 48980 42145 2 +/data/TCGA/bf106879-4a61-4751-8758-728f8bd17e9c/TCGA-FD-A62N-01Z-00-DX1.204E48B7-51D1-49D7-88F3-4BD33A07146A.svs 16281 5633 3 +/data/TCGA/6809adcc-90fc-46e2-ae1c-1bd703ed657f/TCGA-FZ-5920-01Z-00-DX1.2aa8667a-3eb1-4b9c-b8de-b0cfce479e90.svs 113 65558 0 +/data/TCGA/6809adcc-90fc-46e2-ae1c-1bd703ed657f/TCGA-FZ-5920-01Z-00-DX1.2aa8667a-3eb1-4b9c-b8de-b0cfce479e90.svs 7388 22455 1 +/data/TCGA/6809adcc-90fc-46e2-ae1c-1bd703ed657f/TCGA-FZ-5920-01Z-00-DX1.2aa8667a-3eb1-4b9c-b8de-b0cfce479e90.svs 7045 62788 2 +/data/TCGA/6809adcc-90fc-46e2-ae1c-1bd703ed657f/TCGA-FZ-5920-01Z-00-DX1.2aa8667a-3eb1-4b9c-b8de-b0cfce479e90.svs 32439 43283 3 +/data/TCGA/71131c0f-9590-4058-af78-5fa28fe19687/TCGA-N6-A4VC-01Z-00-DX1.18468117-C130-4E03-84DA-774F4BEB7DFC.svs 62342 46346 0 +/data/TCGA/71131c0f-9590-4058-af78-5fa28fe19687/TCGA-N6-A4VC-01Z-00-DX1.18468117-C130-4E03-84DA-774F4BEB7DFC.svs 7430 22278 1 +/data/TCGA/71131c0f-9590-4058-af78-5fa28fe19687/TCGA-N6-A4VC-01Z-00-DX1.18468117-C130-4E03-84DA-774F4BEB7DFC.svs 79530 64031 2 +/data/TCGA/71131c0f-9590-4058-af78-5fa28fe19687/TCGA-N6-A4VC-01Z-00-DX1.18468117-C130-4E03-84DA-774F4BEB7DFC.svs 57221 13223 3 +/data/TCGA/12779db9-bb91-43ed-bd35-db7cd6212088/TCGA-06-0743-01Z-00-DX1.efc295e1-bb7b-4706-99e9-01901c3869d2.svs 10950 7272 0 +/data/TCGA/12779db9-bb91-43ed-bd35-db7cd6212088/TCGA-06-0743-01Z-00-DX1.efc295e1-bb7b-4706-99e9-01901c3869d2.svs 13235 12306 1 +/data/TCGA/12779db9-bb91-43ed-bd35-db7cd6212088/TCGA-06-0743-01Z-00-DX1.efc295e1-bb7b-4706-99e9-01901c3869d2.svs 4724 19368 2 +/data/TCGA/31ea692d-38d3-4799-8a85-52981629ff64/TCGA-VQ-A8PU-01Z-00-DX1.8E355321-0F03-4EEF-80B1-9677982C9D2F.svs 49259 13861 0 +/data/TCGA/31ea692d-38d3-4799-8a85-52981629ff64/TCGA-VQ-A8PU-01Z-00-DX1.8E355321-0F03-4EEF-80B1-9677982C9D2F.svs 46178 11315 1 +/data/TCGA/31ea692d-38d3-4799-8a85-52981629ff64/TCGA-VQ-A8PU-01Z-00-DX1.8E355321-0F03-4EEF-80B1-9677982C9D2F.svs 34857 47652 2 +/data/TCGA/31ea692d-38d3-4799-8a85-52981629ff64/TCGA-VQ-A8PU-01Z-00-DX1.8E355321-0F03-4EEF-80B1-9677982C9D2F.svs 54305 6839 3 +/data/TCGA/a6b55667-cdd8-449f-b551-c10810c9109b/TCGA-T3-A92M-01Z-00-DX3.9117ABA6-D184-4EA1-B7BA-6006427DC59D.svs 39412 97252 0 +/data/TCGA/a6b55667-cdd8-449f-b551-c10810c9109b/TCGA-T3-A92M-01Z-00-DX3.9117ABA6-D184-4EA1-B7BA-6006427DC59D.svs 90670 103606 1 +/data/TCGA/a6b55667-cdd8-449f-b551-c10810c9109b/TCGA-T3-A92M-01Z-00-DX3.9117ABA6-D184-4EA1-B7BA-6006427DC59D.svs 70866 114736 2 +/data/TCGA/a6b55667-cdd8-449f-b551-c10810c9109b/TCGA-T3-A92M-01Z-00-DX3.9117ABA6-D184-4EA1-B7BA-6006427DC59D.svs 60161 85424 3 +/data/TCGA/a6b55667-cdd8-449f-b551-c10810c9109b/TCGA-T3-A92M-01Z-00-DX3.9117ABA6-D184-4EA1-B7BA-6006427DC59D.svs 12206 84965 4 +/data/TCGA/da0370c1-5f4f-44d8-b5e8-151521635933/TCGA-77-7338-01Z-00-DX1.52f2f410-a5cb-47e8-a4f9-242616a21e8e.svs 62656 41258 0 +/data/TCGA/da0370c1-5f4f-44d8-b5e8-151521635933/TCGA-77-7338-01Z-00-DX1.52f2f410-a5cb-47e8-a4f9-242616a21e8e.svs 46342 30784 1 +/data/TCGA/da0370c1-5f4f-44d8-b5e8-151521635933/TCGA-77-7338-01Z-00-DX1.52f2f410-a5cb-47e8-a4f9-242616a21e8e.svs 29731 31401 2 +/data/TCGA/da0370c1-5f4f-44d8-b5e8-151521635933/TCGA-77-7338-01Z-00-DX1.52f2f410-a5cb-47e8-a4f9-242616a21e8e.svs 55919 4610 3 +/data/TCGA/48845e74-7039-4781-9aa7-fcfeabd746dc/TCGA-HT-7482-01Z-00-DX6.3A26CFA8-910B-42C1-B611-E4A6B4F2AEEC.svs 8593 18879 0 +/data/TCGA/48845e74-7039-4781-9aa7-fcfeabd746dc/TCGA-HT-7482-01Z-00-DX6.3A26CFA8-910B-42C1-B611-E4A6B4F2AEEC.svs 92502 5922 1 +/data/TCGA/48845e74-7039-4781-9aa7-fcfeabd746dc/TCGA-HT-7482-01Z-00-DX6.3A26CFA8-910B-42C1-B611-E4A6B4F2AEEC.svs 87028 5490 2 +/data/TCGA/48845e74-7039-4781-9aa7-fcfeabd746dc/TCGA-HT-7482-01Z-00-DX6.3A26CFA8-910B-42C1-B611-E4A6B4F2AEEC.svs 12930 8021 3 +/data/TCGA/4974efbf-1da4-4c45-86e1-93fe4c25a196/TCGA-VR-AA7B-01Z-00-DX1.2C59E44A-5691-4193-8970-774591B83CC9.svs 41958 10796 0 +/data/TCGA/4974efbf-1da4-4c45-86e1-93fe4c25a196/TCGA-VR-AA7B-01Z-00-DX1.2C59E44A-5691-4193-8970-774591B83CC9.svs 68691 20183 1 +/data/TCGA/4974efbf-1da4-4c45-86e1-93fe4c25a196/TCGA-VR-AA7B-01Z-00-DX1.2C59E44A-5691-4193-8970-774591B83CC9.svs 41274 9908 2 +/data/TCGA/4974efbf-1da4-4c45-86e1-93fe4c25a196/TCGA-VR-AA7B-01Z-00-DX1.2C59E44A-5691-4193-8970-774591B83CC9.svs 24115 46004 3 +/data/TCGA/f23b18a1-ad76-42ef-b00b-6d05a892059e/TCGA-CC-5259-01Z-00-DX1.D18B2F62-0CC0-4665-90E3-7DB6817F2FF8.svs 30271 25108 0 +/data/TCGA/f23b18a1-ad76-42ef-b00b-6d05a892059e/TCGA-CC-5259-01Z-00-DX1.D18B2F62-0CC0-4665-90E3-7DB6817F2FF8.svs 29328 24222 1 +/data/TCGA/f23b18a1-ad76-42ef-b00b-6d05a892059e/TCGA-CC-5259-01Z-00-DX1.D18B2F62-0CC0-4665-90E3-7DB6817F2FF8.svs 6251 30083 2 +/data/TCGA/f23b18a1-ad76-42ef-b00b-6d05a892059e/TCGA-CC-5259-01Z-00-DX1.D18B2F62-0CC0-4665-90E3-7DB6817F2FF8.svs 28308 30941 3 +/data/TCGA/1580dc8b-5970-4239-9171-55a4fe7ef14f/TCGA-ND-A4W6-01Z-00-DX4.5F16BF71-71E6-46D2-BE61-300268E4B710.svs 34151 29304 0 +/data/TCGA/1580dc8b-5970-4239-9171-55a4fe7ef14f/TCGA-ND-A4W6-01Z-00-DX4.5F16BF71-71E6-46D2-BE61-300268E4B710.svs 37513 23227 1 +/data/TCGA/1580dc8b-5970-4239-9171-55a4fe7ef14f/TCGA-ND-A4W6-01Z-00-DX4.5F16BF71-71E6-46D2-BE61-300268E4B710.svs 16152 52058 2 +/data/TCGA/1580dc8b-5970-4239-9171-55a4fe7ef14f/TCGA-ND-A4W6-01Z-00-DX4.5F16BF71-71E6-46D2-BE61-300268E4B710.svs 18866 8725 3 +/data/TCGA/5976b6bd-aabc-42aa-a8d1-9e67113b1cb1/TCGA-EL-A3ZR-01Z-00-DX1.290FBBAA-BD0E-4010-AA05-68341C606678.svs 48044 9450 0 +/data/TCGA/5976b6bd-aabc-42aa-a8d1-9e67113b1cb1/TCGA-EL-A3ZR-01Z-00-DX1.290FBBAA-BD0E-4010-AA05-68341C606678.svs 66003 40914 1 +/data/TCGA/5976b6bd-aabc-42aa-a8d1-9e67113b1cb1/TCGA-EL-A3ZR-01Z-00-DX1.290FBBAA-BD0E-4010-AA05-68341C606678.svs 34302 28035 2 +/data/TCGA/5976b6bd-aabc-42aa-a8d1-9e67113b1cb1/TCGA-EL-A3ZR-01Z-00-DX1.290FBBAA-BD0E-4010-AA05-68341C606678.svs 59120 19936 3 +/data/TCGA/9ef5680b-7a2b-4d6e-8122-4e9044598a36/TCGA-23-1120-01Z-00-DX1.59367B12-17F1-41AA-A6FB-8D940365176A.svs 59708 34791 0 +/data/TCGA/9ef5680b-7a2b-4d6e-8122-4e9044598a36/TCGA-23-1120-01Z-00-DX1.59367B12-17F1-41AA-A6FB-8D940365176A.svs 33388 50273 1 +/data/TCGA/9ef5680b-7a2b-4d6e-8122-4e9044598a36/TCGA-23-1120-01Z-00-DX1.59367B12-17F1-41AA-A6FB-8D940365176A.svs 29460 19238 2 +/data/TCGA/9ef5680b-7a2b-4d6e-8122-4e9044598a36/TCGA-23-1120-01Z-00-DX1.59367B12-17F1-41AA-A6FB-8D940365176A.svs 34666 15584 3 +/data/TCGA/e2264cbf-c0d1-4b27-a0f5-7d4a897c2719/TCGA-AX-A1CC-01Z-00-DX1.FE3C98F1-8309-49B2-B8FD-C04911D608E9.svs 46207 2629 0 +/data/TCGA/e2264cbf-c0d1-4b27-a0f5-7d4a897c2719/TCGA-AX-A1CC-01Z-00-DX1.FE3C98F1-8309-49B2-B8FD-C04911D608E9.svs 18658 36038 1 +/data/TCGA/e2264cbf-c0d1-4b27-a0f5-7d4a897c2719/TCGA-AX-A1CC-01Z-00-DX1.FE3C98F1-8309-49B2-B8FD-C04911D608E9.svs 59171 49148 2 +/data/TCGA/e2264cbf-c0d1-4b27-a0f5-7d4a897c2719/TCGA-AX-A1CC-01Z-00-DX1.FE3C98F1-8309-49B2-B8FD-C04911D608E9.svs 59204 58751 3 +/data/TCGA/1088914d-515a-40a2-a667-599f7a40ff4a/TCGA-VQ-A8PQ-01Z-00-DX1.D63AEF37-BAB9-4BFC-9F7E-33509A227B71.svs 84465 50058 0 +/data/TCGA/1088914d-515a-40a2-a667-599f7a40ff4a/TCGA-VQ-A8PQ-01Z-00-DX1.D63AEF37-BAB9-4BFC-9F7E-33509A227B71.svs 77814 58107 1 +/data/TCGA/1088914d-515a-40a2-a667-599f7a40ff4a/TCGA-VQ-A8PQ-01Z-00-DX1.D63AEF37-BAB9-4BFC-9F7E-33509A227B71.svs 53538 66541 2 +/data/TCGA/1088914d-515a-40a2-a667-599f7a40ff4a/TCGA-VQ-A8PQ-01Z-00-DX1.D63AEF37-BAB9-4BFC-9F7E-33509A227B71.svs 45416 36643 3 +/data/TCGA/f1755d9f-844a-4a20-9748-a1f2bea401df/TCGA-F5-6465-01Z-00-DX1.e0c7afc7-1904-4dc4-8e8a-83b4290f445f.svs 50950 39076 0 +/data/TCGA/f1755d9f-844a-4a20-9748-a1f2bea401df/TCGA-F5-6465-01Z-00-DX1.e0c7afc7-1904-4dc4-8e8a-83b4290f445f.svs 55564 48578 1 +/data/TCGA/f1755d9f-844a-4a20-9748-a1f2bea401df/TCGA-F5-6465-01Z-00-DX1.e0c7afc7-1904-4dc4-8e8a-83b4290f445f.svs 36108 48552 2 +/data/TCGA/f1755d9f-844a-4a20-9748-a1f2bea401df/TCGA-F5-6465-01Z-00-DX1.e0c7afc7-1904-4dc4-8e8a-83b4290f445f.svs 10075 39575 3 +/data/TCGA/a2f49efb-1af3-4963-9ca6-a6a2b0e892b5/TCGA-J8-A3YD-01Z-00-DX1.CEB0DB0D-C621-44A8-81A1-EA72B161FA07.svs 51836 48766 0 +/data/TCGA/a2f49efb-1af3-4963-9ca6-a6a2b0e892b5/TCGA-J8-A3YD-01Z-00-DX1.CEB0DB0D-C621-44A8-81A1-EA72B161FA07.svs 52047 33146 1 +/data/TCGA/a2f49efb-1af3-4963-9ca6-a6a2b0e892b5/TCGA-J8-A3YD-01Z-00-DX1.CEB0DB0D-C621-44A8-81A1-EA72B161FA07.svs 18312 9599 2 +/data/TCGA/a2f49efb-1af3-4963-9ca6-a6a2b0e892b5/TCGA-J8-A3YD-01Z-00-DX1.CEB0DB0D-C621-44A8-81A1-EA72B161FA07.svs 64106 37160 3 +/data/TCGA/278450e0-f55c-4c26-a2cc-08d8dddee2c6/TCGA-ET-A2N4-01Z-00-DX1.726A5148-0065-4494-9352-3CBFB9E58536.svs 61453 78993 0 +/data/TCGA/278450e0-f55c-4c26-a2cc-08d8dddee2c6/TCGA-ET-A2N4-01Z-00-DX1.726A5148-0065-4494-9352-3CBFB9E58536.svs 105816 52099 1 +/data/TCGA/278450e0-f55c-4c26-a2cc-08d8dddee2c6/TCGA-ET-A2N4-01Z-00-DX1.726A5148-0065-4494-9352-3CBFB9E58536.svs 106387 38697 2 +/data/TCGA/278450e0-f55c-4c26-a2cc-08d8dddee2c6/TCGA-ET-A2N4-01Z-00-DX1.726A5148-0065-4494-9352-3CBFB9E58536.svs 83788 38391 3 +/data/TCGA/af585d94-6f4d-44f7-ad96-6ada1e9fcad6/TCGA-CM-6679-01Z-00-DX1.b3a899df-256a-4546-9428-a6dd2695b2cf.svs 96398 38147 0 +/data/TCGA/af585d94-6f4d-44f7-ad96-6ada1e9fcad6/TCGA-CM-6679-01Z-00-DX1.b3a899df-256a-4546-9428-a6dd2695b2cf.svs 44660 32903 1 +/data/TCGA/af585d94-6f4d-44f7-ad96-6ada1e9fcad6/TCGA-CM-6679-01Z-00-DX1.b3a899df-256a-4546-9428-a6dd2695b2cf.svs 67935 53077 2 +/data/TCGA/af585d94-6f4d-44f7-ad96-6ada1e9fcad6/TCGA-CM-6679-01Z-00-DX1.b3a899df-256a-4546-9428-a6dd2695b2cf.svs 98689 57992 3 +/data/TCGA/5bd2d920-fb46-45b2-9995-bd383330c8f6/TCGA-C8-A27A-01Z-00-DX1.0E26C46D-CD65-40F3-8976-EB4415582934.svs 40243 39167 0 +/data/TCGA/5bd2d920-fb46-45b2-9995-bd383330c8f6/TCGA-C8-A27A-01Z-00-DX1.0E26C46D-CD65-40F3-8976-EB4415582934.svs 26082 33001 1 +/data/TCGA/5bd2d920-fb46-45b2-9995-bd383330c8f6/TCGA-C8-A27A-01Z-00-DX1.0E26C46D-CD65-40F3-8976-EB4415582934.svs 18060 24119 2 +/data/TCGA/5bd2d920-fb46-45b2-9995-bd383330c8f6/TCGA-C8-A27A-01Z-00-DX1.0E26C46D-CD65-40F3-8976-EB4415582934.svs 21119 46127 3 +/data/TCGA/80ff715b-b928-47cf-b046-4cd8aa1449dc/TCGA-DG-A2KM-01Z-00-DX1.58F88374-0268-4314-B75D-BF04DA186995.svs 52331 3383 0 +/data/TCGA/80ff715b-b928-47cf-b046-4cd8aa1449dc/TCGA-DG-A2KM-01Z-00-DX1.58F88374-0268-4314-B75D-BF04DA186995.svs 20830 12628 1 +/data/TCGA/80ff715b-b928-47cf-b046-4cd8aa1449dc/TCGA-DG-A2KM-01Z-00-DX1.58F88374-0268-4314-B75D-BF04DA186995.svs 63251 15944 2 +/data/TCGA/80ff715b-b928-47cf-b046-4cd8aa1449dc/TCGA-DG-A2KM-01Z-00-DX1.58F88374-0268-4314-B75D-BF04DA186995.svs 59949 7403 3 +/data/TCGA/74d4edd7-e253-434b-b99f-a42c6383b008/TCGA-EM-A3O3-01Z-00-DX1.F1D69AEB-CBBD-49EE-A2F4-411A11E3B3AC.svs 13518 13231 0 +/data/TCGA/74d4edd7-e253-434b-b99f-a42c6383b008/TCGA-EM-A3O3-01Z-00-DX1.F1D69AEB-CBBD-49EE-A2F4-411A11E3B3AC.svs 9454 23235 1 +/data/TCGA/74d4edd7-e253-434b-b99f-a42c6383b008/TCGA-EM-A3O3-01Z-00-DX1.F1D69AEB-CBBD-49EE-A2F4-411A11E3B3AC.svs 9471 18077 2 +/data/TCGA/73b0a630-47be-43e8-9777-25a643aa67a2/TCGA-V4-A9EC-01Z-00-DX1.5730E636-95F2-4665-BC43-0746B2C05595.svs 24118 49679 0 +/data/TCGA/73b0a630-47be-43e8-9777-25a643aa67a2/TCGA-V4-A9EC-01Z-00-DX1.5730E636-95F2-4665-BC43-0746B2C05595.svs 26363 82165 1 +/data/TCGA/73b0a630-47be-43e8-9777-25a643aa67a2/TCGA-V4-A9EC-01Z-00-DX1.5730E636-95F2-4665-BC43-0746B2C05595.svs 5056 34927 2 +/data/TCGA/73b0a630-47be-43e8-9777-25a643aa67a2/TCGA-V4-A9EC-01Z-00-DX1.5730E636-95F2-4665-BC43-0746B2C05595.svs 50387 10101 3 +/data/TCGA/b0e88e0a-ff33-4e06-b347-8281ecf03901/TCGA-A7-A425-01Z-00-DX1.812A94B1-0403-4298-A6C5-F71AFD3A9995.svs 32646 44853 0 +/data/TCGA/b0e88e0a-ff33-4e06-b347-8281ecf03901/TCGA-A7-A425-01Z-00-DX1.812A94B1-0403-4298-A6C5-F71AFD3A9995.svs 72531 26362 1 +/data/TCGA/b0e88e0a-ff33-4e06-b347-8281ecf03901/TCGA-A7-A425-01Z-00-DX1.812A94B1-0403-4298-A6C5-F71AFD3A9995.svs 22379 30826 2 +/data/TCGA/b0e88e0a-ff33-4e06-b347-8281ecf03901/TCGA-A7-A425-01Z-00-DX1.812A94B1-0403-4298-A6C5-F71AFD3A9995.svs 64119 9727 3 +/data/TCGA/daff3278-bdad-4db0-96c8-290918dd99ac/TCGA-AA-3495-01Z-00-DX1.67DEE36B-724E-4B4F-B3A9-B4E8CCCEFA80.svs 4889 2749 0 +/data/TCGA/daff3278-bdad-4db0-96c8-290918dd99ac/TCGA-AA-3495-01Z-00-DX1.67DEE36B-724E-4B4F-B3A9-B4E8CCCEFA80.svs 4245 658 1 +/data/TCGA/5986d782-2c15-40a3-a9b3-276f36d3195d/TCGA-33-4538-01Z-00-DX1.efde88cb-4766-4fb6-bed9-52b14059c7c1.svs 112212 1665 0 +/data/TCGA/5986d782-2c15-40a3-a9b3-276f36d3195d/TCGA-33-4538-01Z-00-DX1.efde88cb-4766-4fb6-bed9-52b14059c7c1.svs 5455 34854 1 +/data/TCGA/5986d782-2c15-40a3-a9b3-276f36d3195d/TCGA-33-4538-01Z-00-DX1.efde88cb-4766-4fb6-bed9-52b14059c7c1.svs 55484 11056 2 +/data/TCGA/5986d782-2c15-40a3-a9b3-276f36d3195d/TCGA-33-4538-01Z-00-DX1.efde88cb-4766-4fb6-bed9-52b14059c7c1.svs 109763 5462 3 +/data/TCGA/d5084138-2de0-4cce-afa3-5e1771130e20/TCGA-06-0214-01Z-00-DX2.b30c4c85-604f-42ea-b2f8-e583566fcefe.svs 20062 8966 0 +/data/TCGA/d5084138-2de0-4cce-afa3-5e1771130e20/TCGA-06-0214-01Z-00-DX2.b30c4c85-604f-42ea-b2f8-e583566fcefe.svs 26572 11657 1 +/data/TCGA/d5084138-2de0-4cce-afa3-5e1771130e20/TCGA-06-0214-01Z-00-DX2.b30c4c85-604f-42ea-b2f8-e583566fcefe.svs 14294 20325 2 +/data/TCGA/dbc1e046-61ad-4433-bca7-3427cec6d465/TCGA-C8-A26Z-01Z-00-DX1.1A15D951-F3BD-4024-91DD-E7633C09A837.svs 71117 50589 0 +/data/TCGA/dbc1e046-61ad-4433-bca7-3427cec6d465/TCGA-C8-A26Z-01Z-00-DX1.1A15D951-F3BD-4024-91DD-E7633C09A837.svs 60725 36519 1 +/data/TCGA/dbc1e046-61ad-4433-bca7-3427cec6d465/TCGA-C8-A26Z-01Z-00-DX1.1A15D951-F3BD-4024-91DD-E7633C09A837.svs 39895 7661 2 +/data/TCGA/dbc1e046-61ad-4433-bca7-3427cec6d465/TCGA-C8-A26Z-01Z-00-DX1.1A15D951-F3BD-4024-91DD-E7633C09A837.svs 7142 37238 3 +/data/TCGA/0e7f6b2d-f496-40b1-a9d8-281a4ec7a6fe/TCGA-QR-A6H1-01Z-00-DX1.5CFC1A51-79FB-44E7-A11D-640DFB772803.svs 99032 25714 0 +/data/TCGA/0e7f6b2d-f496-40b1-a9d8-281a4ec7a6fe/TCGA-QR-A6H1-01Z-00-DX1.5CFC1A51-79FB-44E7-A11D-640DFB772803.svs 64283 16088 1 +/data/TCGA/0e7f6b2d-f496-40b1-a9d8-281a4ec7a6fe/TCGA-QR-A6H1-01Z-00-DX1.5CFC1A51-79FB-44E7-A11D-640DFB772803.svs 79640 30779 2 +/data/TCGA/0e7f6b2d-f496-40b1-a9d8-281a4ec7a6fe/TCGA-QR-A6H1-01Z-00-DX1.5CFC1A51-79FB-44E7-A11D-640DFB772803.svs 56647 45752 3 +/data/TCGA/4c558ac2-57f0-4acc-93c9-da4d1a24d0a6/TCGA-06-5411-01Z-00-DX1.08bf7f79-7346-4b1b-b8a7-e24abf11e848.svs 82395 35486 0 +/data/TCGA/4c558ac2-57f0-4acc-93c9-da4d1a24d0a6/TCGA-06-5411-01Z-00-DX1.08bf7f79-7346-4b1b-b8a7-e24abf11e848.svs 51496 15340 1 +/data/TCGA/4c558ac2-57f0-4acc-93c9-da4d1a24d0a6/TCGA-06-5411-01Z-00-DX1.08bf7f79-7346-4b1b-b8a7-e24abf11e848.svs 10938 30621 2 +/data/TCGA/4c558ac2-57f0-4acc-93c9-da4d1a24d0a6/TCGA-06-5411-01Z-00-DX1.08bf7f79-7346-4b1b-b8a7-e24abf11e848.svs 37452 25320 3 +/data/TCGA/9e240724-33b5-4fac-b7c2-c01e9cb18b7c/TCGA-3B-A9I0-01Z-00-DX1.AE4FDD21-8DB7-4E8B-A6A9-7B4E86E011B0.svs 30573 40151 0 +/data/TCGA/9e240724-33b5-4fac-b7c2-c01e9cb18b7c/TCGA-3B-A9I0-01Z-00-DX1.AE4FDD21-8DB7-4E8B-A6A9-7B4E86E011B0.svs 22125 40909 1 +/data/TCGA/9e240724-33b5-4fac-b7c2-c01e9cb18b7c/TCGA-3B-A9I0-01Z-00-DX1.AE4FDD21-8DB7-4E8B-A6A9-7B4E86E011B0.svs 6107 44095 2 +/data/TCGA/9e240724-33b5-4fac-b7c2-c01e9cb18b7c/TCGA-3B-A9I0-01Z-00-DX1.AE4FDD21-8DB7-4E8B-A6A9-7B4E86E011B0.svs 12854 34169 3 +/data/TCGA/1005a39c-e0db-4db6-9ba9-00dfb17af515/TCGA-12-0662-01Z-00-DX4.29f739c2-f70f-4ad5-ae7f-9f94c14adca2.svs 25881 17540 0 +/data/TCGA/1005a39c-e0db-4db6-9ba9-00dfb17af515/TCGA-12-0662-01Z-00-DX4.29f739c2-f70f-4ad5-ae7f-9f94c14adca2.svs 11388 28278 1 +/data/TCGA/1005a39c-e0db-4db6-9ba9-00dfb17af515/TCGA-12-0662-01Z-00-DX4.29f739c2-f70f-4ad5-ae7f-9f94c14adca2.svs 30123 15561 2 +/data/TCGA/29b005db-4568-4685-8a33-7b0c331f6ae3/TCGA-AA-3518-01Z-00-DX1.5aad7b19-2900-4f1c-9312-f8d8c4725449.svs 13312 24264 0 +/data/TCGA/29b005db-4568-4685-8a33-7b0c331f6ae3/TCGA-AA-3518-01Z-00-DX1.5aad7b19-2900-4f1c-9312-f8d8c4725449.svs 7318 37140 1 +/data/TCGA/29b005db-4568-4685-8a33-7b0c331f6ae3/TCGA-AA-3518-01Z-00-DX1.5aad7b19-2900-4f1c-9312-f8d8c4725449.svs 4856 25046 2 +/data/TCGA/29b005db-4568-4685-8a33-7b0c331f6ae3/TCGA-AA-3518-01Z-00-DX1.5aad7b19-2900-4f1c-9312-f8d8c4725449.svs 15776 52443 3 +/data/TCGA/d7cc9e34-a659-49ee-a7bf-7f74d56f2f87/TCGA-KO-8408-01Z-00-DX1.4D45F809-E93A-4221-832A-97C3A4B4E30C.svs 23308 15107 0 +/data/TCGA/d7cc9e34-a659-49ee-a7bf-7f74d56f2f87/TCGA-KO-8408-01Z-00-DX1.4D45F809-E93A-4221-832A-97C3A4B4E30C.svs 37557 28010 1 +/data/TCGA/d7cc9e34-a659-49ee-a7bf-7f74d56f2f87/TCGA-KO-8408-01Z-00-DX1.4D45F809-E93A-4221-832A-97C3A4B4E30C.svs 88023 40151 2 +/data/TCGA/d7cc9e34-a659-49ee-a7bf-7f74d56f2f87/TCGA-KO-8408-01Z-00-DX1.4D45F809-E93A-4221-832A-97C3A4B4E30C.svs 55881 45719 3 +/data/TCGA/8d80a759-b079-415d-8ffc-a12a119068ad/TCGA-DD-AADY-01Z-00-DX1.178DA812-24C2-4018-BDB4-6BB63069DF60.svs 60611 26211 0 +/data/TCGA/8d80a759-b079-415d-8ffc-a12a119068ad/TCGA-DD-AADY-01Z-00-DX1.178DA812-24C2-4018-BDB4-6BB63069DF60.svs 5385 30633 1 +/data/TCGA/8d80a759-b079-415d-8ffc-a12a119068ad/TCGA-DD-AADY-01Z-00-DX1.178DA812-24C2-4018-BDB4-6BB63069DF60.svs 46906 38317 2 +/data/TCGA/8d80a759-b079-415d-8ffc-a12a119068ad/TCGA-DD-AADY-01Z-00-DX1.178DA812-24C2-4018-BDB4-6BB63069DF60.svs 12304 9494 3 +/data/TCGA/5e73a8ab-562f-4b92-ac02-18038b9e9043/TCGA-06-0216-01Z-00-DX5.b9a89800-36b0-47ec-b510-75a74f2e433c.svs 581 5856 0 +/data/TCGA/5e73a8ab-562f-4b92-ac02-18038b9e9043/TCGA-06-0216-01Z-00-DX5.b9a89800-36b0-47ec-b510-75a74f2e433c.svs 1801 5838 1 +/data/TCGA/5e73a8ab-562f-4b92-ac02-18038b9e9043/TCGA-06-0216-01Z-00-DX5.b9a89800-36b0-47ec-b510-75a74f2e433c.svs 8123 34039 2 +/data/TCGA/69b9292a-fcca-479a-9dff-a8bbc4413551/TCGA-OR-A5LK-01Z-00-DX5.2228D0EA-D285-4A3C-87DB-5C3DA593F3EB.svs 17507 33758 0 +/data/TCGA/69b9292a-fcca-479a-9dff-a8bbc4413551/TCGA-OR-A5LK-01Z-00-DX5.2228D0EA-D285-4A3C-87DB-5C3DA593F3EB.svs 73104 13369 1 +/data/TCGA/69b9292a-fcca-479a-9dff-a8bbc4413551/TCGA-OR-A5LK-01Z-00-DX5.2228D0EA-D285-4A3C-87DB-5C3DA593F3EB.svs 65405 41698 2 +/data/TCGA/69b9292a-fcca-479a-9dff-a8bbc4413551/TCGA-OR-A5LK-01Z-00-DX5.2228D0EA-D285-4A3C-87DB-5C3DA593F3EB.svs 24635 76912 3 +/data/TCGA/24eacba2-b08a-4ee9-9f49-3fe18df247e4/TCGA-CV-7235-01Z-00-DX1.4779177A-2956-41BC-8324-00729FEE8B9A.svs 63516 43726 0 +/data/TCGA/24eacba2-b08a-4ee9-9f49-3fe18df247e4/TCGA-CV-7235-01Z-00-DX1.4779177A-2956-41BC-8324-00729FEE8B9A.svs 63357 41107 1 +/data/TCGA/24eacba2-b08a-4ee9-9f49-3fe18df247e4/TCGA-CV-7235-01Z-00-DX1.4779177A-2956-41BC-8324-00729FEE8B9A.svs 42178 33257 2 +/data/TCGA/24eacba2-b08a-4ee9-9f49-3fe18df247e4/TCGA-CV-7235-01Z-00-DX1.4779177A-2956-41BC-8324-00729FEE8B9A.svs 42976 34752 3 +/data/TCGA/5f8d6257-e1b0-45e9-b9ea-72d10714126a/TCGA-77-7139-01Z-00-DX1.b8b79b0c-4ea0-4f6c-8e6e-29ad76eca78f.svs 72271 12920 0 +/data/TCGA/5f8d6257-e1b0-45e9-b9ea-72d10714126a/TCGA-77-7139-01Z-00-DX1.b8b79b0c-4ea0-4f6c-8e6e-29ad76eca78f.svs 90516 23400 1 +/data/TCGA/5f8d6257-e1b0-45e9-b9ea-72d10714126a/TCGA-77-7139-01Z-00-DX1.b8b79b0c-4ea0-4f6c-8e6e-29ad76eca78f.svs 53401 55694 2 +/data/TCGA/5f8d6257-e1b0-45e9-b9ea-72d10714126a/TCGA-77-7139-01Z-00-DX1.b8b79b0c-4ea0-4f6c-8e6e-29ad76eca78f.svs 92886 68150 3 +/data/TCGA/7cf0e77f-ead2-422b-8948-9d2e2d1c1cfe/TCGA-3M-AB47-01Z-00-DX1.D7D70922-A91F-4798-8D6E-DFD84D145A59.svs 28918 28597 0 +/data/TCGA/7cf0e77f-ead2-422b-8948-9d2e2d1c1cfe/TCGA-3M-AB47-01Z-00-DX1.D7D70922-A91F-4798-8D6E-DFD84D145A59.svs 26078 54763 1 +/data/TCGA/7cf0e77f-ead2-422b-8948-9d2e2d1c1cfe/TCGA-3M-AB47-01Z-00-DX1.D7D70922-A91F-4798-8D6E-DFD84D145A59.svs 28149 67669 2 +/data/TCGA/7cf0e77f-ead2-422b-8948-9d2e2d1c1cfe/TCGA-3M-AB47-01Z-00-DX1.D7D70922-A91F-4798-8D6E-DFD84D145A59.svs 43735 43918 3 +/data/TCGA/efe3f8fb-c709-4fc2-9140-3fd3115a478f/TCGA-FG-8191-01Z-00-DX1.cf5a8abc-ba6d-438f-b070-95fc79ba0fce.svs 94232 24343 0 +/data/TCGA/efe3f8fb-c709-4fc2-9140-3fd3115a478f/TCGA-FG-8191-01Z-00-DX1.cf5a8abc-ba6d-438f-b070-95fc79ba0fce.svs 22596 9055 1 +/data/TCGA/efe3f8fb-c709-4fc2-9140-3fd3115a478f/TCGA-FG-8191-01Z-00-DX1.cf5a8abc-ba6d-438f-b070-95fc79ba0fce.svs 13054 17634 2 +/data/TCGA/efe3f8fb-c709-4fc2-9140-3fd3115a478f/TCGA-FG-8191-01Z-00-DX1.cf5a8abc-ba6d-438f-b070-95fc79ba0fce.svs 89466 25629 3 +/data/TCGA/516fe079-c40f-42d2-adf7-98cc141c7de4/TCGA-E1-A7YV-01Z-00-DX2.3F5FD3A4-1234-40A5-921C-08C92F2E1C57.svs 33044 33954 0 +/data/TCGA/516fe079-c40f-42d2-adf7-98cc141c7de4/TCGA-E1-A7YV-01Z-00-DX2.3F5FD3A4-1234-40A5-921C-08C92F2E1C57.svs 49559 23153 1 +/data/TCGA/516fe079-c40f-42d2-adf7-98cc141c7de4/TCGA-E1-A7YV-01Z-00-DX2.3F5FD3A4-1234-40A5-921C-08C92F2E1C57.svs 50299 49777 2 +/data/TCGA/516fe079-c40f-42d2-adf7-98cc141c7de4/TCGA-E1-A7YV-01Z-00-DX2.3F5FD3A4-1234-40A5-921C-08C92F2E1C57.svs 29649 12367 3 +/data/TCGA/7f5333c9-6ec4-4f38-9622-345a74b93afb/TCGA-HC-7209-01Z-00-DX1.ccf1d3c8-0351-4b7e-8539-0817ce3b8364.svs 10002 16437 0 +/data/TCGA/7f5333c9-6ec4-4f38-9622-345a74b93afb/TCGA-HC-7209-01Z-00-DX1.ccf1d3c8-0351-4b7e-8539-0817ce3b8364.svs 13697 10648 1 +/data/TCGA/7f5333c9-6ec4-4f38-9622-345a74b93afb/TCGA-HC-7209-01Z-00-DX1.ccf1d3c8-0351-4b7e-8539-0817ce3b8364.svs 15257 21810 2 +/data/TCGA/c676a39c-97d7-492c-a448-9013f5eeffc6/TCGA-DD-A3A2-01Z-00-DX1.19C972E3-0FE2-4E70-98FD-8B35FA3E1B19.svs 51935 42082 0 +/data/TCGA/c676a39c-97d7-492c-a448-9013f5eeffc6/TCGA-DD-A3A2-01Z-00-DX1.19C972E3-0FE2-4E70-98FD-8B35FA3E1B19.svs 22694 30576 1 +/data/TCGA/c676a39c-97d7-492c-a448-9013f5eeffc6/TCGA-DD-A3A2-01Z-00-DX1.19C972E3-0FE2-4E70-98FD-8B35FA3E1B19.svs 34781 22340 2 +/data/TCGA/c676a39c-97d7-492c-a448-9013f5eeffc6/TCGA-DD-A3A2-01Z-00-DX1.19C972E3-0FE2-4E70-98FD-8B35FA3E1B19.svs 101568 9533 3 +/data/TCGA/5a966eb4-241c-4f5c-9cb7-7b5e5698f26a/TCGA-G5-6572-01Z-00-DX1.7a9d5e04-f3dc-4fc7-b188-b90219e0cc50.svs 50483 53318 0 +/data/TCGA/5a966eb4-241c-4f5c-9cb7-7b5e5698f26a/TCGA-G5-6572-01Z-00-DX1.7a9d5e04-f3dc-4fc7-b188-b90219e0cc50.svs 27631 23990 1 +/data/TCGA/5a966eb4-241c-4f5c-9cb7-7b5e5698f26a/TCGA-G5-6572-01Z-00-DX1.7a9d5e04-f3dc-4fc7-b188-b90219e0cc50.svs 70645 48203 2 +/data/TCGA/5a966eb4-241c-4f5c-9cb7-7b5e5698f26a/TCGA-G5-6572-01Z-00-DX1.7a9d5e04-f3dc-4fc7-b188-b90219e0cc50.svs 48562 32910 3 +/data/TCGA/91ebcd54-3880-4de8-b120-7dd26afbccc1/TCGA-LN-A7HZ-01Z-00-DX1.3B2E3D05-6241-4938-B900-23F510714046.svs 39906 50952 0 +/data/TCGA/91ebcd54-3880-4de8-b120-7dd26afbccc1/TCGA-LN-A7HZ-01Z-00-DX1.3B2E3D05-6241-4938-B900-23F510714046.svs 27096 66240 1 +/data/TCGA/91ebcd54-3880-4de8-b120-7dd26afbccc1/TCGA-LN-A7HZ-01Z-00-DX1.3B2E3D05-6241-4938-B900-23F510714046.svs 50838 4810 2 +/data/TCGA/91ebcd54-3880-4de8-b120-7dd26afbccc1/TCGA-LN-A7HZ-01Z-00-DX1.3B2E3D05-6241-4938-B900-23F510714046.svs 46872 13756 3 +/data/TCGA/fd207839-6cff-4165-8dc7-af4e1013b27f/TCGA-WK-A8Y0-01Z-00-DX1.F69CB510-B0F1-43BF-A394-47DCBF8CB41F.svs 79383 21212 0 +/data/TCGA/fd207839-6cff-4165-8dc7-af4e1013b27f/TCGA-WK-A8Y0-01Z-00-DX1.F69CB510-B0F1-43BF-A394-47DCBF8CB41F.svs 89946 53961 1 +/data/TCGA/fd207839-6cff-4165-8dc7-af4e1013b27f/TCGA-WK-A8Y0-01Z-00-DX1.F69CB510-B0F1-43BF-A394-47DCBF8CB41F.svs 45947 57700 2 +/data/TCGA/fd207839-6cff-4165-8dc7-af4e1013b27f/TCGA-WK-A8Y0-01Z-00-DX1.F69CB510-B0F1-43BF-A394-47DCBF8CB41F.svs 71777 31040 3 +/data/TCGA/21d8c9b3-6b8d-45dc-a22f-94c637d1b20c/TCGA-YD-A9TB-01Z-00-DX2.BFDBD5B4-486D-41B1-A123-DC1966D4BF52.svs 36314 25711 0 +/data/TCGA/21d8c9b3-6b8d-45dc-a22f-94c637d1b20c/TCGA-YD-A9TB-01Z-00-DX2.BFDBD5B4-486D-41B1-A123-DC1966D4BF52.svs 45708 61587 1 +/data/TCGA/21d8c9b3-6b8d-45dc-a22f-94c637d1b20c/TCGA-YD-A9TB-01Z-00-DX2.BFDBD5B4-486D-41B1-A123-DC1966D4BF52.svs 54269 20468 2 +/data/TCGA/21d8c9b3-6b8d-45dc-a22f-94c637d1b20c/TCGA-YD-A9TB-01Z-00-DX2.BFDBD5B4-486D-41B1-A123-DC1966D4BF52.svs 57785 71420 3 +/data/TCGA/6b47a483-9dfc-442b-8193-8638d09048f0/TCGA-CJ-4912-01Z-00-DX1.28805E39-F07A-40FF-8810-162BED671E17.svs 31738 74906 0 +/data/TCGA/6b47a483-9dfc-442b-8193-8638d09048f0/TCGA-CJ-4912-01Z-00-DX1.28805E39-F07A-40FF-8810-162BED671E17.svs 64043 12539 1 +/data/TCGA/6b47a483-9dfc-442b-8193-8638d09048f0/TCGA-CJ-4912-01Z-00-DX1.28805E39-F07A-40FF-8810-162BED671E17.svs 71147 30692 2 +/data/TCGA/6b47a483-9dfc-442b-8193-8638d09048f0/TCGA-CJ-4912-01Z-00-DX1.28805E39-F07A-40FF-8810-162BED671E17.svs 8007 58824 3 +/data/TCGA/bd94c88a-195a-4ffb-a4a9-e1d0fbbd920d/TCGA-06-0209-01Z-00-DX8.4a540299-b778-43e4-b80b-f70d5f222378.svs 12325 22908 0 +/data/TCGA/bd94c88a-195a-4ffb-a4a9-e1d0fbbd920d/TCGA-06-0209-01Z-00-DX8.4a540299-b778-43e4-b80b-f70d5f222378.svs 42946 21647 1 +/data/TCGA/bd94c88a-195a-4ffb-a4a9-e1d0fbbd920d/TCGA-06-0209-01Z-00-DX8.4a540299-b778-43e4-b80b-f70d5f222378.svs 29191 22979 2 +/data/TCGA/8f190691-95fe-4394-8a01-56d0ea587ee8/TCGA-RE-A7BO-01Z-00-DX1.E6F76917-D416-420D-A3A7-A89576B22D01.svs 37231 47129 0 +/data/TCGA/8f190691-95fe-4394-8a01-56d0ea587ee8/TCGA-RE-A7BO-01Z-00-DX1.E6F76917-D416-420D-A3A7-A89576B22D01.svs 115505 59390 1 +/data/TCGA/8f190691-95fe-4394-8a01-56d0ea587ee8/TCGA-RE-A7BO-01Z-00-DX1.E6F76917-D416-420D-A3A7-A89576B22D01.svs 92808 62512 2 +/data/TCGA/8f190691-95fe-4394-8a01-56d0ea587ee8/TCGA-RE-A7BO-01Z-00-DX1.E6F76917-D416-420D-A3A7-A89576B22D01.svs 91224 58162 3 +/data/TCGA/f3f83ef3-aecd-4252-bc7e-44da89db41e9/TCGA-DD-A39X-01Z-00-DX2.AFC0C74E-529E-4B33-961C-C96AE16C9CFB.svs 45502 44441 0 +/data/TCGA/f3f83ef3-aecd-4252-bc7e-44da89db41e9/TCGA-DD-A39X-01Z-00-DX2.AFC0C74E-529E-4B33-961C-C96AE16C9CFB.svs 45836 41825 1 +/data/TCGA/f3f83ef3-aecd-4252-bc7e-44da89db41e9/TCGA-DD-A39X-01Z-00-DX2.AFC0C74E-529E-4B33-961C-C96AE16C9CFB.svs 63027 61310 2 +/data/TCGA/f3f83ef3-aecd-4252-bc7e-44da89db41e9/TCGA-DD-A39X-01Z-00-DX2.AFC0C74E-529E-4B33-961C-C96AE16C9CFB.svs 73662 29331 3 +/data/TCGA/1fdbf922-989b-4195-a06e-82332481ae7b/TCGA-VS-A8EL-01Z-00-DX1.EF7B6F23-A566-4E2F-9935-28643B7E5357.svs 18105 62581 0 +/data/TCGA/1fdbf922-989b-4195-a06e-82332481ae7b/TCGA-VS-A8EL-01Z-00-DX1.EF7B6F23-A566-4E2F-9935-28643B7E5357.svs 13214 9383 1 +/data/TCGA/1fdbf922-989b-4195-a06e-82332481ae7b/TCGA-VS-A8EL-01Z-00-DX1.EF7B6F23-A566-4E2F-9935-28643B7E5357.svs 19406 14543 2 +/data/TCGA/1fdbf922-989b-4195-a06e-82332481ae7b/TCGA-VS-A8EL-01Z-00-DX1.EF7B6F23-A566-4E2F-9935-28643B7E5357.svs 6847 61854 3 +/data/TCGA/eaf9abed-214b-4933-a4e4-1286b36d5f73/TCGA-D8-A1Y2-01Z-00-DX1.77451A0F-00FD-44A9-A0D0-CB7A39CE74CC.svs 49697 38337 0 +/data/TCGA/eaf9abed-214b-4933-a4e4-1286b36d5f73/TCGA-D8-A1Y2-01Z-00-DX1.77451A0F-00FD-44A9-A0D0-CB7A39CE74CC.svs 68907 47207 1 +/data/TCGA/eaf9abed-214b-4933-a4e4-1286b36d5f73/TCGA-D8-A1Y2-01Z-00-DX1.77451A0F-00FD-44A9-A0D0-CB7A39CE74CC.svs 63531 36721 2 +/data/TCGA/eaf9abed-214b-4933-a4e4-1286b36d5f73/TCGA-D8-A1Y2-01Z-00-DX1.77451A0F-00FD-44A9-A0D0-CB7A39CE74CC.svs 55595 44793 3 +/data/TCGA/11fa819b-831d-46e3-8730-65e100530df1/TCGA-ET-A25M-01Z-00-DX1.E9DBEE28-5DAA-4F9E-AF56-01712348B430.svs 35878 4835 0 +/data/TCGA/11fa819b-831d-46e3-8730-65e100530df1/TCGA-ET-A25M-01Z-00-DX1.E9DBEE28-5DAA-4F9E-AF56-01712348B430.svs 55339 69821 1 +/data/TCGA/11fa819b-831d-46e3-8730-65e100530df1/TCGA-ET-A25M-01Z-00-DX1.E9DBEE28-5DAA-4F9E-AF56-01712348B430.svs 25525 12435 2 +/data/TCGA/11fa819b-831d-46e3-8730-65e100530df1/TCGA-ET-A25M-01Z-00-DX1.E9DBEE28-5DAA-4F9E-AF56-01712348B430.svs 77603 51880 3 +/data/TCGA/9cfaf965-7063-4aee-bcf3-0528f8c23ac5/TCGA-12-0616-01Z-00-DX4.bcc9933d-865c-4c8d-a96d-607940b8ebaf.svs 11095 9023 0 +/data/TCGA/9cfaf965-7063-4aee-bcf3-0528f8c23ac5/TCGA-12-0616-01Z-00-DX4.bcc9933d-865c-4c8d-a96d-607940b8ebaf.svs 9359 3992 1 +/data/TCGA/9cfaf965-7063-4aee-bcf3-0528f8c23ac5/TCGA-12-0616-01Z-00-DX4.bcc9933d-865c-4c8d-a96d-607940b8ebaf.svs 16969 37294 2 +/data/TCGA/e8c17143-d1d1-4e04-81f1-ba495327be44/TCGA-02-0006-01Z-00-DX1.a37df719-8b93-4245-ae49-67eb1114253a.svs 7862 11171 0 +/data/TCGA/e8c17143-d1d1-4e04-81f1-ba495327be44/TCGA-02-0006-01Z-00-DX1.a37df719-8b93-4245-ae49-67eb1114253a.svs 21946 26098 1 +/data/TCGA/e8c17143-d1d1-4e04-81f1-ba495327be44/TCGA-02-0006-01Z-00-DX1.a37df719-8b93-4245-ae49-67eb1114253a.svs 8641 10493 2 +/data/TCGA/8bbbfc1f-d946-476d-ad78-728b2ebd927c/TCGA-B9-4117-01Z-00-DX1.9c2239e4-0bff-4482-914d-fd59afde75ab.svs 101606 30686 0 +/data/TCGA/8bbbfc1f-d946-476d-ad78-728b2ebd927c/TCGA-B9-4117-01Z-00-DX1.9c2239e4-0bff-4482-914d-fd59afde75ab.svs 40233 19389 1 +/data/TCGA/8bbbfc1f-d946-476d-ad78-728b2ebd927c/TCGA-B9-4117-01Z-00-DX1.9c2239e4-0bff-4482-914d-fd59afde75ab.svs 21345 26259 2 +/data/TCGA/8bbbfc1f-d946-476d-ad78-728b2ebd927c/TCGA-B9-4117-01Z-00-DX1.9c2239e4-0bff-4482-914d-fd59afde75ab.svs 76071 35327 3 +/data/TCGA/ce907e48-de19-4bcd-959c-379978f2795c/TCGA-FE-A23A-01Z-00-DX1.87FE71D9-087F-45B2-8B1B-935566E8489A.svs 114790 51182 0 +/data/TCGA/ce907e48-de19-4bcd-959c-379978f2795c/TCGA-FE-A23A-01Z-00-DX1.87FE71D9-087F-45B2-8B1B-935566E8489A.svs 25925 12426 1 +/data/TCGA/ce907e48-de19-4bcd-959c-379978f2795c/TCGA-FE-A23A-01Z-00-DX1.87FE71D9-087F-45B2-8B1B-935566E8489A.svs 77563 44769 2 +/data/TCGA/ce907e48-de19-4bcd-959c-379978f2795c/TCGA-FE-A23A-01Z-00-DX1.87FE71D9-087F-45B2-8B1B-935566E8489A.svs 46225 26325 3 +/data/TCGA/e9ae8dc8-1922-4145-9e11-903adb2da859/TCGA-CV-7423-01Z-00-DX1.B40488AA-9D45-4B58-993B-F4BF4F1ACEBF.svs 72987 20007 0 +/data/TCGA/e9ae8dc8-1922-4145-9e11-903adb2da859/TCGA-CV-7423-01Z-00-DX1.B40488AA-9D45-4B58-993B-F4BF4F1ACEBF.svs 84458 39064 1 +/data/TCGA/e9ae8dc8-1922-4145-9e11-903adb2da859/TCGA-CV-7423-01Z-00-DX1.B40488AA-9D45-4B58-993B-F4BF4F1ACEBF.svs 48390 28957 2 +/data/TCGA/e9ae8dc8-1922-4145-9e11-903adb2da859/TCGA-CV-7423-01Z-00-DX1.B40488AA-9D45-4B58-993B-F4BF4F1ACEBF.svs 16701 5681 3 +/data/TCGA/0eb70b9c-57fc-4423-ad35-db2d2c7b2ad3/TCGA-ND-A4WF-01Z-00-DX1.A82E5E1F-9D99-4A2F-9BF8-D2AC3ECB9A00.svs 78416 70714 0 +/data/TCGA/0eb70b9c-57fc-4423-ad35-db2d2c7b2ad3/TCGA-ND-A4WF-01Z-00-DX1.A82E5E1F-9D99-4A2F-9BF8-D2AC3ECB9A00.svs 53391 30003 1 +/data/TCGA/0eb70b9c-57fc-4423-ad35-db2d2c7b2ad3/TCGA-ND-A4WF-01Z-00-DX1.A82E5E1F-9D99-4A2F-9BF8-D2AC3ECB9A00.svs 70161 37796 2 +/data/TCGA/0eb70b9c-57fc-4423-ad35-db2d2c7b2ad3/TCGA-ND-A4WF-01Z-00-DX1.A82E5E1F-9D99-4A2F-9BF8-D2AC3ECB9A00.svs 84004 32754 3 +/data/TCGA/c59d9296-f17c-4cd7-a698-4667ff15a52e/TCGA-97-A4M0-01Z-00-DX1.BDDFB04C-2475-485A-9A85-C4B9EB15155E.svs 42214 11191 0 +/data/TCGA/c59d9296-f17c-4cd7-a698-4667ff15a52e/TCGA-97-A4M0-01Z-00-DX1.BDDFB04C-2475-485A-9A85-C4B9EB15155E.svs 66403 44780 1 +/data/TCGA/c59d9296-f17c-4cd7-a698-4667ff15a52e/TCGA-97-A4M0-01Z-00-DX1.BDDFB04C-2475-485A-9A85-C4B9EB15155E.svs 32832 55427 2 +/data/TCGA/c59d9296-f17c-4cd7-a698-4667ff15a52e/TCGA-97-A4M0-01Z-00-DX1.BDDFB04C-2475-485A-9A85-C4B9EB15155E.svs 22353 7061 3 +/data/TCGA/b59573c1-4f67-4e38-a1dc-3eb428b7d159/TCGA-AL-A5DJ-01Z-00-DX1.AF15A60D-67BF-47AB-8AE3-CCBE6DDAF86D.svs 54328 12240 0 +/data/TCGA/b59573c1-4f67-4e38-a1dc-3eb428b7d159/TCGA-AL-A5DJ-01Z-00-DX1.AF15A60D-67BF-47AB-8AE3-CCBE6DDAF86D.svs 57727 26781 1 +/data/TCGA/b59573c1-4f67-4e38-a1dc-3eb428b7d159/TCGA-AL-A5DJ-01Z-00-DX1.AF15A60D-67BF-47AB-8AE3-CCBE6DDAF86D.svs 32784 20163 2 +/data/TCGA/b59573c1-4f67-4e38-a1dc-3eb428b7d159/TCGA-AL-A5DJ-01Z-00-DX1.AF15A60D-67BF-47AB-8AE3-CCBE6DDAF86D.svs 35413 20562 3 +/data/TCGA/dc35b149-469c-4529-baf9-945e697c2091/TCGA-CH-5766-01Z-00-DX1.ea679de9-2957-4958-a11a-6005b456bf87.svs 87987 27876 0 +/data/TCGA/dc35b149-469c-4529-baf9-945e697c2091/TCGA-CH-5766-01Z-00-DX1.ea679de9-2957-4958-a11a-6005b456bf87.svs 17241 13060 1 +/data/TCGA/dc35b149-469c-4529-baf9-945e697c2091/TCGA-CH-5766-01Z-00-DX1.ea679de9-2957-4958-a11a-6005b456bf87.svs 3301 20109 2 +/data/TCGA/dc35b149-469c-4529-baf9-945e697c2091/TCGA-CH-5766-01Z-00-DX1.ea679de9-2957-4958-a11a-6005b456bf87.svs 84723 15788 3 +/data/TCGA/4030c911-7ed0-482b-8fb4-08c7e0d99be3/TCGA-OR-A5JE-01Z-00-DX5.B8972497-F2DB-4E9F-98CE-F5815C66C89B.svs 17922 15639 0 +/data/TCGA/4030c911-7ed0-482b-8fb4-08c7e0d99be3/TCGA-OR-A5JE-01Z-00-DX5.B8972497-F2DB-4E9F-98CE-F5815C66C89B.svs 31465 28129 1 +/data/TCGA/4030c911-7ed0-482b-8fb4-08c7e0d99be3/TCGA-OR-A5JE-01Z-00-DX5.B8972497-F2DB-4E9F-98CE-F5815C66C89B.svs 40796 66293 2 +/data/TCGA/4030c911-7ed0-482b-8fb4-08c7e0d99be3/TCGA-OR-A5JE-01Z-00-DX5.B8972497-F2DB-4E9F-98CE-F5815C66C89B.svs 34302 16081 3 +/data/TCGA/df9e48ed-041a-460e-8603-628b053028a0/TCGA-OR-A5LP-01Z-00-DX3.FA162B97-24CC-4504-9D23-27A5C1D31DCF.svs 58746 49021 0 +/data/TCGA/df9e48ed-041a-460e-8603-628b053028a0/TCGA-OR-A5LP-01Z-00-DX3.FA162B97-24CC-4504-9D23-27A5C1D31DCF.svs 98857 50069 1 +/data/TCGA/df9e48ed-041a-460e-8603-628b053028a0/TCGA-OR-A5LP-01Z-00-DX3.FA162B97-24CC-4504-9D23-27A5C1D31DCF.svs 83659 24545 2 +/data/TCGA/df9e48ed-041a-460e-8603-628b053028a0/TCGA-OR-A5LP-01Z-00-DX3.FA162B97-24CC-4504-9D23-27A5C1D31DCF.svs 65967 63252 3 +/data/TCGA/a613418b-5552-4018-afe1-b58df86e75da/TCGA-AX-A0J0-01Z-00-DX2.56C668BE-03B8-4B87-A226-AABD97D53C38.svs 83214 73119 0 +/data/TCGA/a613418b-5552-4018-afe1-b58df86e75da/TCGA-AX-A0J0-01Z-00-DX2.56C668BE-03B8-4B87-A226-AABD97D53C38.svs 63313 41762 1 +/data/TCGA/a613418b-5552-4018-afe1-b58df86e75da/TCGA-AX-A0J0-01Z-00-DX2.56C668BE-03B8-4B87-A226-AABD97D53C38.svs 13195 54002 2 +/data/TCGA/a613418b-5552-4018-afe1-b58df86e75da/TCGA-AX-A0J0-01Z-00-DX2.56C668BE-03B8-4B87-A226-AABD97D53C38.svs 6261 42341 3 +/data/TCGA/d10abbb5-fc57-448a-8466-c0ed3cc06af9/TCGA-B0-5121-01Z-00-DX1.3e7c6f3c-998a-465f-a464-c301e71f2a89.svs 42079 20818 0 +/data/TCGA/d10abbb5-fc57-448a-8466-c0ed3cc06af9/TCGA-B0-5121-01Z-00-DX1.3e7c6f3c-998a-465f-a464-c301e71f2a89.svs 75901 57660 1 +/data/TCGA/d10abbb5-fc57-448a-8466-c0ed3cc06af9/TCGA-B0-5121-01Z-00-DX1.3e7c6f3c-998a-465f-a464-c301e71f2a89.svs 37295 19782 2 +/data/TCGA/d10abbb5-fc57-448a-8466-c0ed3cc06af9/TCGA-B0-5121-01Z-00-DX1.3e7c6f3c-998a-465f-a464-c301e71f2a89.svs 40200 21231 3 +/data/TCGA/0e3ea476-20f5-4d4f-8e66-e0abdc184d64/TCGA-HT-7856-01Z-00-DX9.FC0DFB62-9704-4BAA-A48C-F53BEB00AE40.svs 68173 49183 0 +/data/TCGA/0e3ea476-20f5-4d4f-8e66-e0abdc184d64/TCGA-HT-7856-01Z-00-DX9.FC0DFB62-9704-4BAA-A48C-F53BEB00AE40.svs 22867 35579 1 +/data/TCGA/0e3ea476-20f5-4d4f-8e66-e0abdc184d64/TCGA-HT-7856-01Z-00-DX9.FC0DFB62-9704-4BAA-A48C-F53BEB00AE40.svs 22605 32078 2 +/data/TCGA/0e3ea476-20f5-4d4f-8e66-e0abdc184d64/TCGA-HT-7856-01Z-00-DX9.FC0DFB62-9704-4BAA-A48C-F53BEB00AE40.svs 17451 16475 3 +/data/TCGA/b052e17b-9c5f-4815-890a-be5bc15b9f90/TCGA-HT-7684-01Z-00-DX1.7499FC8D-DB42-4516-B14F-F0ED3BBEE87D.svs 15621 32271 0 +/data/TCGA/b052e17b-9c5f-4815-890a-be5bc15b9f90/TCGA-HT-7684-01Z-00-DX1.7499FC8D-DB42-4516-B14F-F0ED3BBEE87D.svs 45033 50467 1 +/data/TCGA/b052e17b-9c5f-4815-890a-be5bc15b9f90/TCGA-HT-7684-01Z-00-DX1.7499FC8D-DB42-4516-B14F-F0ED3BBEE87D.svs 46582 35347 2 +/data/TCGA/b052e17b-9c5f-4815-890a-be5bc15b9f90/TCGA-HT-7684-01Z-00-DX1.7499FC8D-DB42-4516-B14F-F0ED3BBEE87D.svs 69076 34816 3 +/data/TCGA/e458119a-bd5c-4f49-89e1-2a642b175e70/TCGA-DB-A4XA-01Z-00-DX1.108DC8B4-E6B6-4526-9E9B-B42DCF90FF01.svs 20463 2422 0 +/data/TCGA/e458119a-bd5c-4f49-89e1-2a642b175e70/TCGA-DB-A4XA-01Z-00-DX1.108DC8B4-E6B6-4526-9E9B-B42DCF90FF01.svs 81090 29231 1 +/data/TCGA/e458119a-bd5c-4f49-89e1-2a642b175e70/TCGA-DB-A4XA-01Z-00-DX1.108DC8B4-E6B6-4526-9E9B-B42DCF90FF01.svs 59492 29558 2 +/data/TCGA/e458119a-bd5c-4f49-89e1-2a642b175e70/TCGA-DB-A4XA-01Z-00-DX1.108DC8B4-E6B6-4526-9E9B-B42DCF90FF01.svs 52602 22814 3 +/data/TCGA/b840d3d8-1d66-4b8f-99fb-5afeca6e5948/TCGA-DB-5281-01Z-00-DX2.672BE5A5-77AE-4DE2-99AF-5B13532917DF.svs 29401 31595 0 +/data/TCGA/b840d3d8-1d66-4b8f-99fb-5afeca6e5948/TCGA-DB-5281-01Z-00-DX2.672BE5A5-77AE-4DE2-99AF-5B13532917DF.svs 51129 19462 1 +/data/TCGA/b840d3d8-1d66-4b8f-99fb-5afeca6e5948/TCGA-DB-5281-01Z-00-DX2.672BE5A5-77AE-4DE2-99AF-5B13532917DF.svs 74058 15902 2 +/data/TCGA/b840d3d8-1d66-4b8f-99fb-5afeca6e5948/TCGA-DB-5281-01Z-00-DX2.672BE5A5-77AE-4DE2-99AF-5B13532917DF.svs 7655 33283 3 +/data/TCGA/f7fe82a3-7085-42e2-b52e-130f5df28348/TCGA-D7-8579-01Z-00-DX1.BFA005CC-E2B4-4A36-9C84-5F51F0526856.svs 53309 26189 0 +/data/TCGA/f7fe82a3-7085-42e2-b52e-130f5df28348/TCGA-D7-8579-01Z-00-DX1.BFA005CC-E2B4-4A36-9C84-5F51F0526856.svs 41443 55530 1 +/data/TCGA/f7fe82a3-7085-42e2-b52e-130f5df28348/TCGA-D7-8579-01Z-00-DX1.BFA005CC-E2B4-4A36-9C84-5F51F0526856.svs 55958 45138 2 +/data/TCGA/f7fe82a3-7085-42e2-b52e-130f5df28348/TCGA-D7-8579-01Z-00-DX1.BFA005CC-E2B4-4A36-9C84-5F51F0526856.svs 58670 40859 3 +/data/TCGA/11541d1e-3fb5-4fe0-9fe5-6ac0093826b8/TCGA-D6-6826-01Z-00-DX1.9346b65d-ffc0-46ed-b68b-e18b2a43c5ea.svs 41764 19838 0 +/data/TCGA/11541d1e-3fb5-4fe0-9fe5-6ac0093826b8/TCGA-D6-6826-01Z-00-DX1.9346b65d-ffc0-46ed-b68b-e18b2a43c5ea.svs 12213 2816 1 +/data/TCGA/11541d1e-3fb5-4fe0-9fe5-6ac0093826b8/TCGA-D6-6826-01Z-00-DX1.9346b65d-ffc0-46ed-b68b-e18b2a43c5ea.svs 82444 8912 2 +/data/TCGA/11541d1e-3fb5-4fe0-9fe5-6ac0093826b8/TCGA-D6-6826-01Z-00-DX1.9346b65d-ffc0-46ed-b68b-e18b2a43c5ea.svs 80989 6229 3 +/data/TCGA/49bc87f8-1fe8-4641-b364-9d2efd8ddca4/TCGA-AP-A0LT-01Z-00-DX1.74C269EA-3118-4E65-AAFE-C1D186EAC207.svs 26433 12385 0 +/data/TCGA/49bc87f8-1fe8-4641-b364-9d2efd8ddca4/TCGA-AP-A0LT-01Z-00-DX1.74C269EA-3118-4E65-AAFE-C1D186EAC207.svs 5625 23197 1 +/data/TCGA/49bc87f8-1fe8-4641-b364-9d2efd8ddca4/TCGA-AP-A0LT-01Z-00-DX1.74C269EA-3118-4E65-AAFE-C1D186EAC207.svs 5741 24323 2 +/data/TCGA/2b375647-6c52-4383-bdf9-c54cebd735ee/TCGA-BR-8078-01Z-00-DX1.8e4a1099-d1c4-46b2-ae3b-5276b93d7003.svs 6473 40270 0 +/data/TCGA/2b375647-6c52-4383-bdf9-c54cebd735ee/TCGA-BR-8078-01Z-00-DX1.8e4a1099-d1c4-46b2-ae3b-5276b93d7003.svs 57710 8697 1 +/data/TCGA/2b375647-6c52-4383-bdf9-c54cebd735ee/TCGA-BR-8078-01Z-00-DX1.8e4a1099-d1c4-46b2-ae3b-5276b93d7003.svs 27508 4144 2 +/data/TCGA/2b375647-6c52-4383-bdf9-c54cebd735ee/TCGA-BR-8078-01Z-00-DX1.8e4a1099-d1c4-46b2-ae3b-5276b93d7003.svs 5925 22689 3 +/data/TCGA/1bc8af23-aa8c-4e73-9975-cd1a461ba6f7/TCGA-CQ-6224-01Z-00-DX1.c0d0fca6-b287-41fa-bd8a-95c99a6d9008.svs 78822 45865 0 +/data/TCGA/1bc8af23-aa8c-4e73-9975-cd1a461ba6f7/TCGA-CQ-6224-01Z-00-DX1.c0d0fca6-b287-41fa-bd8a-95c99a6d9008.svs 83195 58492 1 +/data/TCGA/1bc8af23-aa8c-4e73-9975-cd1a461ba6f7/TCGA-CQ-6224-01Z-00-DX1.c0d0fca6-b287-41fa-bd8a-95c99a6d9008.svs 73117 2843 2 +/data/TCGA/1bc8af23-aa8c-4e73-9975-cd1a461ba6f7/TCGA-CQ-6224-01Z-00-DX1.c0d0fca6-b287-41fa-bd8a-95c99a6d9008.svs 47891 42729 3 +/data/TCGA/166cefcd-8e0f-48f3-a44a-614b5e1e8515/TCGA-HT-7468-01Z-00-DX7.64F8DF3B-5821-4BCB-80E5-1252F9EB8DFD.svs 12945 5774 0 +/data/TCGA/166cefcd-8e0f-48f3-a44a-614b5e1e8515/TCGA-HT-7468-01Z-00-DX7.64F8DF3B-5821-4BCB-80E5-1252F9EB8DFD.svs 12869 23541 1 +/data/TCGA/166cefcd-8e0f-48f3-a44a-614b5e1e8515/TCGA-HT-7468-01Z-00-DX7.64F8DF3B-5821-4BCB-80E5-1252F9EB8DFD.svs 26772 18776 2 +/data/TCGA/266f280f-6189-4f8f-b8ba-0b123a325415/TCGA-TS-A7OZ-01Z-00-DX1.F295DAAC-AD14-4B71-AFCE-4756D179811E.svs 32900 67851 0 +/data/TCGA/266f280f-6189-4f8f-b8ba-0b123a325415/TCGA-TS-A7OZ-01Z-00-DX1.F295DAAC-AD14-4B71-AFCE-4756D179811E.svs 32924 68225 1 +/data/TCGA/266f280f-6189-4f8f-b8ba-0b123a325415/TCGA-TS-A7OZ-01Z-00-DX1.F295DAAC-AD14-4B71-AFCE-4756D179811E.svs 86448 47308 2 +/data/TCGA/266f280f-6189-4f8f-b8ba-0b123a325415/TCGA-TS-A7OZ-01Z-00-DX1.F295DAAC-AD14-4B71-AFCE-4756D179811E.svs 98460 36853 3 +/data/TCGA/6646b483-4099-4c90-82ae-a9950d1df476/TCGA-FJ-A3Z7-01Z-00-DX2.C4531060-32B7-4472-8B6D-3E4477810B9F.svs 9637 76368 0 +/data/TCGA/6646b483-4099-4c90-82ae-a9950d1df476/TCGA-FJ-A3Z7-01Z-00-DX2.C4531060-32B7-4472-8B6D-3E4477810B9F.svs 36130 50786 1 +/data/TCGA/6646b483-4099-4c90-82ae-a9950d1df476/TCGA-FJ-A3Z7-01Z-00-DX2.C4531060-32B7-4472-8B6D-3E4477810B9F.svs 42520 60230 2 +/data/TCGA/6646b483-4099-4c90-82ae-a9950d1df476/TCGA-FJ-A3Z7-01Z-00-DX2.C4531060-32B7-4472-8B6D-3E4477810B9F.svs 28385 28733 3 +/data/TCGA/9ec44dab-9479-46c0-9b5e-e3e620f7e51d/TCGA-2A-A8W3-01Z-00-DX1.CC00522F-8A47-4C63-B9CC-F215F9EAAFBA.svs 59780 33966 0 +/data/TCGA/9ec44dab-9479-46c0-9b5e-e3e620f7e51d/TCGA-2A-A8W3-01Z-00-DX1.CC00522F-8A47-4C63-B9CC-F215F9EAAFBA.svs 87387 54127 1 +/data/TCGA/9ec44dab-9479-46c0-9b5e-e3e620f7e51d/TCGA-2A-A8W3-01Z-00-DX1.CC00522F-8A47-4C63-B9CC-F215F9EAAFBA.svs 28708 19451 2 +/data/TCGA/9ec44dab-9479-46c0-9b5e-e3e620f7e51d/TCGA-2A-A8W3-01Z-00-DX1.CC00522F-8A47-4C63-B9CC-F215F9EAAFBA.svs 24739 45175 3 +/data/TCGA/1d3abfb0-92a2-40e0-9898-9a1c66cdb51a/TCGA-B0-5698-01Z-00-DX1.e7739945-c890-46f9-ba2b-f2cd2ae39567.svs 172098 21082 0 +/data/TCGA/1d3abfb0-92a2-40e0-9898-9a1c66cdb51a/TCGA-B0-5698-01Z-00-DX1.e7739945-c890-46f9-ba2b-f2cd2ae39567.svs 54450 27507 1 +/data/TCGA/1d3abfb0-92a2-40e0-9898-9a1c66cdb51a/TCGA-B0-5698-01Z-00-DX1.e7739945-c890-46f9-ba2b-f2cd2ae39567.svs 19667 29644 2 +/data/TCGA/1d3abfb0-92a2-40e0-9898-9a1c66cdb51a/TCGA-B0-5698-01Z-00-DX1.e7739945-c890-46f9-ba2b-f2cd2ae39567.svs 57212 10539 3 +/data/TCGA/d653e0f5-954b-47e8-9fd1-a210a093e468/TCGA-02-0047-01Z-00-DX1.4755D138-5842-4159-848C-4248D6D53DE0.svs 25510 70671 0 +/data/TCGA/d653e0f5-954b-47e8-9fd1-a210a093e468/TCGA-02-0047-01Z-00-DX1.4755D138-5842-4159-848C-4248D6D53DE0.svs 33941 67348 1 +/data/TCGA/d653e0f5-954b-47e8-9fd1-a210a093e468/TCGA-02-0047-01Z-00-DX1.4755D138-5842-4159-848C-4248D6D53DE0.svs 44098 52027 2 +/data/TCGA/d653e0f5-954b-47e8-9fd1-a210a093e468/TCGA-02-0047-01Z-00-DX1.4755D138-5842-4159-848C-4248D6D53DE0.svs 33563 26650 3 +/data/TCGA/fc7d3a58-119d-4cb5-9b48-1932c9f271e9/TCGA-97-A4M1-01Z-00-DX1.1C4B8247-BA3F-4841-BC9D-554F03F7894C.svs 81321 32779 0 +/data/TCGA/fc7d3a58-119d-4cb5-9b48-1932c9f271e9/TCGA-97-A4M1-01Z-00-DX1.1C4B8247-BA3F-4841-BC9D-554F03F7894C.svs 36813 27042 1 +/data/TCGA/fc7d3a58-119d-4cb5-9b48-1932c9f271e9/TCGA-97-A4M1-01Z-00-DX1.1C4B8247-BA3F-4841-BC9D-554F03F7894C.svs 61878 11821 2 +/data/TCGA/fc7d3a58-119d-4cb5-9b48-1932c9f271e9/TCGA-97-A4M1-01Z-00-DX1.1C4B8247-BA3F-4841-BC9D-554F03F7894C.svs 79151 46068 3 +/data/TCGA/5de618ba-ec07-4661-a5d3-32143a074530/TCGA-EJ-5510-01Z-00-DX1.ab391b79-7b8f-4ad8-b5bd-c868effa75f8.svs 34971 11362 0 +/data/TCGA/5de618ba-ec07-4661-a5d3-32143a074530/TCGA-EJ-5510-01Z-00-DX1.ab391b79-7b8f-4ad8-b5bd-c868effa75f8.svs 41691 13709 1 +/data/TCGA/5de618ba-ec07-4661-a5d3-32143a074530/TCGA-EJ-5510-01Z-00-DX1.ab391b79-7b8f-4ad8-b5bd-c868effa75f8.svs 13731 23795 2 +/data/TCGA/5de618ba-ec07-4661-a5d3-32143a074530/TCGA-EJ-5510-01Z-00-DX1.ab391b79-7b8f-4ad8-b5bd-c868effa75f8.svs 16312 45552 3 +/data/TCGA/3d6b06b6-1253-4c6b-b7ea-bb838c1ea37b/TCGA-XF-A8HI-01Z-00-DX1.1BA3EF33-D4D5-4213-833D-A7F8C0EFFF02.svs 88412 48841 0 +/data/TCGA/3d6b06b6-1253-4c6b-b7ea-bb838c1ea37b/TCGA-XF-A8HI-01Z-00-DX1.1BA3EF33-D4D5-4213-833D-A7F8C0EFFF02.svs 65637 57807 1 +/data/TCGA/3d6b06b6-1253-4c6b-b7ea-bb838c1ea37b/TCGA-XF-A8HI-01Z-00-DX1.1BA3EF33-D4D5-4213-833D-A7F8C0EFFF02.svs 70273 29958 2 +/data/TCGA/3d6b06b6-1253-4c6b-b7ea-bb838c1ea37b/TCGA-XF-A8HI-01Z-00-DX1.1BA3EF33-D4D5-4213-833D-A7F8C0EFFF02.svs 34626 26608 3 +/data/TCGA/60f8249b-abf8-4ae3-a472-ed2a428e3834/TCGA-05-4433-01Z-00-DX1.5843D3CC-CB24-4A0A-BB65-78A5DAA11D84.svs 59963 22796 0 +/data/TCGA/60f8249b-abf8-4ae3-a472-ed2a428e3834/TCGA-05-4433-01Z-00-DX1.5843D3CC-CB24-4A0A-BB65-78A5DAA11D84.svs 16608 50216 1 +/data/TCGA/60f8249b-abf8-4ae3-a472-ed2a428e3834/TCGA-05-4433-01Z-00-DX1.5843D3CC-CB24-4A0A-BB65-78A5DAA11D84.svs 47209 32668 2 +/data/TCGA/60f8249b-abf8-4ae3-a472-ed2a428e3834/TCGA-05-4433-01Z-00-DX1.5843D3CC-CB24-4A0A-BB65-78A5DAA11D84.svs 65094 44030 3 +/data/TCGA/9b2a863c-03de-4a09-9d64-85319f26d0f6/TCGA-S7-A7WW-01Z-00-DX2.05AC99B0-DDFF-4F28-B0E7-D8276F88C2A8.svs 42135 44072 0 +/data/TCGA/9b2a863c-03de-4a09-9d64-85319f26d0f6/TCGA-S7-A7WW-01Z-00-DX2.05AC99B0-DDFF-4F28-B0E7-D8276F88C2A8.svs 74476 37185 1 +/data/TCGA/9b2a863c-03de-4a09-9d64-85319f26d0f6/TCGA-S7-A7WW-01Z-00-DX2.05AC99B0-DDFF-4F28-B0E7-D8276F88C2A8.svs 46177 63937 2 +/data/TCGA/9b2a863c-03de-4a09-9d64-85319f26d0f6/TCGA-S7-A7WW-01Z-00-DX2.05AC99B0-DDFF-4F28-B0E7-D8276F88C2A8.svs 19587 27343 3 +/data/TCGA/03bf9e37-0870-4994-b6ac-dcb0e11a290c/TCGA-OR-A5JB-01Z-00-DX3.A71196CF-F710-49EC-8F1A-2F90F60CDA0C.svs 37079 33044 0 +/data/TCGA/03bf9e37-0870-4994-b6ac-dcb0e11a290c/TCGA-OR-A5JB-01Z-00-DX3.A71196CF-F710-49EC-8F1A-2F90F60CDA0C.svs 38514 45235 1 +/data/TCGA/03bf9e37-0870-4994-b6ac-dcb0e11a290c/TCGA-OR-A5JB-01Z-00-DX3.A71196CF-F710-49EC-8F1A-2F90F60CDA0C.svs 51629 41864 2 +/data/TCGA/03bf9e37-0870-4994-b6ac-dcb0e11a290c/TCGA-OR-A5JB-01Z-00-DX3.A71196CF-F710-49EC-8F1A-2F90F60CDA0C.svs 51689 21800 3 +/data/TCGA/fbcf506f-03f3-4c27-930d-dffd828f8680/TCGA-BH-A0DV-01Z-00-DX1.2F0B5FB3-40F0-4D27-BFAC-390FB9A42B39.svs 67220 14234 0 +/data/TCGA/fbcf506f-03f3-4c27-930d-dffd828f8680/TCGA-BH-A0DV-01Z-00-DX1.2F0B5FB3-40F0-4D27-BFAC-390FB9A42B39.svs 71813 13484 1 +/data/TCGA/fbcf506f-03f3-4c27-930d-dffd828f8680/TCGA-BH-A0DV-01Z-00-DX1.2F0B5FB3-40F0-4D27-BFAC-390FB9A42B39.svs 113704 13001 2 +/data/TCGA/fbcf506f-03f3-4c27-930d-dffd828f8680/TCGA-BH-A0DV-01Z-00-DX1.2F0B5FB3-40F0-4D27-BFAC-390FB9A42B39.svs 50284 20471 3 +/data/TCGA/b765abf7-2f53-4a0a-a14b-f9e5b0aaa122/TCGA-06-0178-01Z-00-DX4.16c7b728-c6ba-496f-8dc8-4f5bb4a38e56.svs 13616 18716 0 +/data/TCGA/b765abf7-2f53-4a0a-a14b-f9e5b0aaa122/TCGA-06-0178-01Z-00-DX4.16c7b728-c6ba-496f-8dc8-4f5bb4a38e56.svs 38519 21219 1 +/data/TCGA/b765abf7-2f53-4a0a-a14b-f9e5b0aaa122/TCGA-06-0178-01Z-00-DX4.16c7b728-c6ba-496f-8dc8-4f5bb4a38e56.svs 23080 8280 2 +/data/TCGA/0ecb2d7b-0a69-46ce-80d6-1be65cec3cc7/TCGA-AA-3524-01Z-00-DX1.b1aae264-87be-4514-8f9d-25660b39caa7.svs 28426 11154 0 +/data/TCGA/0ecb2d7b-0a69-46ce-80d6-1be65cec3cc7/TCGA-AA-3524-01Z-00-DX1.b1aae264-87be-4514-8f9d-25660b39caa7.svs 31350 36759 1 +/data/TCGA/0ecb2d7b-0a69-46ce-80d6-1be65cec3cc7/TCGA-AA-3524-01Z-00-DX1.b1aae264-87be-4514-8f9d-25660b39caa7.svs 27079 38203 2 +/data/TCGA/0ecb2d7b-0a69-46ce-80d6-1be65cec3cc7/TCGA-AA-3524-01Z-00-DX1.b1aae264-87be-4514-8f9d-25660b39caa7.svs 25386 29923 3 +/data/TCGA/b27f6617-dba7-40bc-b123-0ebf4a93a05c/TCGA-3U-A98F-01Z-00-DX1.4D2C4E75-7D1A-40C3-AD67-BB5789EC9FB2.svs 14883 35261 0 +/data/TCGA/b27f6617-dba7-40bc-b123-0ebf4a93a05c/TCGA-3U-A98F-01Z-00-DX1.4D2C4E75-7D1A-40C3-AD67-BB5789EC9FB2.svs 38619 32067 1 +/data/TCGA/b27f6617-dba7-40bc-b123-0ebf4a93a05c/TCGA-3U-A98F-01Z-00-DX1.4D2C4E75-7D1A-40C3-AD67-BB5789EC9FB2.svs 16759 44058 2 +/data/TCGA/b27f6617-dba7-40bc-b123-0ebf4a93a05c/TCGA-3U-A98F-01Z-00-DX1.4D2C4E75-7D1A-40C3-AD67-BB5789EC9FB2.svs 32711 27013 3 +/data/TCGA/53c1e162-aaf7-414b-9df4-0fae258c6baf/TCGA-BA-A6DA-01Z-00-DX1.8BFA179A-8E8A-45DC-A036-77A7D6ABB7EA.svs 37783 34465 0 +/data/TCGA/53c1e162-aaf7-414b-9df4-0fae258c6baf/TCGA-BA-A6DA-01Z-00-DX1.8BFA179A-8E8A-45DC-A036-77A7D6ABB7EA.svs 90275 53116 1 +/data/TCGA/53c1e162-aaf7-414b-9df4-0fae258c6baf/TCGA-BA-A6DA-01Z-00-DX1.8BFA179A-8E8A-45DC-A036-77A7D6ABB7EA.svs 74123 49148 2 +/data/TCGA/53c1e162-aaf7-414b-9df4-0fae258c6baf/TCGA-BA-A6DA-01Z-00-DX1.8BFA179A-8E8A-45DC-A036-77A7D6ABB7EA.svs 39841 37731 3 +/data/TCGA/16a0ee3c-7f26-4a82-93ef-2a57e4a23af3/TCGA-4G-AAZO-01Z-00-DX1.B3E01FF4-2D88-49D5-8D09-582B68B2EA12.svs 29761 36035 0 +/data/TCGA/16a0ee3c-7f26-4a82-93ef-2a57e4a23af3/TCGA-4G-AAZO-01Z-00-DX1.B3E01FF4-2D88-49D5-8D09-582B68B2EA12.svs 90386 29551 1 +/data/TCGA/16a0ee3c-7f26-4a82-93ef-2a57e4a23af3/TCGA-4G-AAZO-01Z-00-DX1.B3E01FF4-2D88-49D5-8D09-582B68B2EA12.svs 122694 6912 2 +/data/TCGA/16a0ee3c-7f26-4a82-93ef-2a57e4a23af3/TCGA-4G-AAZO-01Z-00-DX1.B3E01FF4-2D88-49D5-8D09-582B68B2EA12.svs 16436 30336 3 +/data/TCGA/a4b66023-521f-43c1-9dd5-0d630fca82e5/TCGA-55-6968-01Z-00-DX1.810e0fee-99ab-465b-8ae9-fb416e4dca3c.svs 30704 35739 0 +/data/TCGA/a4b66023-521f-43c1-9dd5-0d630fca82e5/TCGA-55-6968-01Z-00-DX1.810e0fee-99ab-465b-8ae9-fb416e4dca3c.svs 43285 19464 1 +/data/TCGA/a4b66023-521f-43c1-9dd5-0d630fca82e5/TCGA-55-6968-01Z-00-DX1.810e0fee-99ab-465b-8ae9-fb416e4dca3c.svs 45757 13756 2 +/data/TCGA/a4b66023-521f-43c1-9dd5-0d630fca82e5/TCGA-55-6968-01Z-00-DX1.810e0fee-99ab-465b-8ae9-fb416e4dca3c.svs 42452 2520 3 +/data/TCGA/b468381b-93d0-436c-95fe-dce581e733e8/TCGA-B0-4816-01Z-00-DX1.6cc0b334-b885-4cdc-a2a8-cd3efaa2e241.svs 70840 58921 0 +/data/TCGA/b468381b-93d0-436c-95fe-dce581e733e8/TCGA-B0-4816-01Z-00-DX1.6cc0b334-b885-4cdc-a2a8-cd3efaa2e241.svs 41423 6346 1 +/data/TCGA/b468381b-93d0-436c-95fe-dce581e733e8/TCGA-B0-4816-01Z-00-DX1.6cc0b334-b885-4cdc-a2a8-cd3efaa2e241.svs 91463 21842 2 +/data/TCGA/b468381b-93d0-436c-95fe-dce581e733e8/TCGA-B0-4816-01Z-00-DX1.6cc0b334-b885-4cdc-a2a8-cd3efaa2e241.svs 84864 41041 3 +/data/TCGA/e22c5231-6410-44ef-853f-ef8c466124ba/TCGA-MH-A55Z-01Z-00-DX1.14253FE3-706D-4C25-9470-423396F80EC1.svs 53654 48690 0 +/data/TCGA/e22c5231-6410-44ef-853f-ef8c466124ba/TCGA-MH-A55Z-01Z-00-DX1.14253FE3-706D-4C25-9470-423396F80EC1.svs 45811 68384 1 +/data/TCGA/e22c5231-6410-44ef-853f-ef8c466124ba/TCGA-MH-A55Z-01Z-00-DX1.14253FE3-706D-4C25-9470-423396F80EC1.svs 58657 43083 2 +/data/TCGA/e22c5231-6410-44ef-853f-ef8c466124ba/TCGA-MH-A55Z-01Z-00-DX1.14253FE3-706D-4C25-9470-423396F80EC1.svs 84131 53815 3 +/data/TCGA/f8f65573-8dba-4acf-928c-809f8f9c9f20/TCGA-39-5016-01Z-00-DX1.b568cdcd-f8bf-4917-ae40-dbd505c36d1e.svs 33784 35762 0 +/data/TCGA/f8f65573-8dba-4acf-928c-809f8f9c9f20/TCGA-39-5016-01Z-00-DX1.b568cdcd-f8bf-4917-ae40-dbd505c36d1e.svs 10298 32308 1 +/data/TCGA/f8f65573-8dba-4acf-928c-809f8f9c9f20/TCGA-39-5016-01Z-00-DX1.b568cdcd-f8bf-4917-ae40-dbd505c36d1e.svs 13777 21554 2 +/data/TCGA/635e6359-6cdf-4f87-bf29-bd1925c7800e/TCGA-IQ-A61J-01Z-00-DX1.EE2EEE5B-949A-441E-9FA0-60627020E29D.svs 65822 18910 0 +/data/TCGA/635e6359-6cdf-4f87-bf29-bd1925c7800e/TCGA-IQ-A61J-01Z-00-DX1.EE2EEE5B-949A-441E-9FA0-60627020E29D.svs 56104 71018 1 +/data/TCGA/635e6359-6cdf-4f87-bf29-bd1925c7800e/TCGA-IQ-A61J-01Z-00-DX1.EE2EEE5B-949A-441E-9FA0-60627020E29D.svs 47174 21147 2 +/data/TCGA/635e6359-6cdf-4f87-bf29-bd1925c7800e/TCGA-IQ-A61J-01Z-00-DX1.EE2EEE5B-949A-441E-9FA0-60627020E29D.svs 41023 41779 3 +/data/TCGA/1b6c743e-8a29-4657-8917-467f90c8c272/TCGA-KV-A6GE-01Z-00-DX6.BAF3885F-8013-47CB-B9B1-C7F4FD0FB5E7.svs 65343 80744 0 +/data/TCGA/1b6c743e-8a29-4657-8917-467f90c8c272/TCGA-KV-A6GE-01Z-00-DX6.BAF3885F-8013-47CB-B9B1-C7F4FD0FB5E7.svs 60929 61739 1 +/data/TCGA/1b6c743e-8a29-4657-8917-467f90c8c272/TCGA-KV-A6GE-01Z-00-DX6.BAF3885F-8013-47CB-B9B1-C7F4FD0FB5E7.svs 65453 52145 2 +/data/TCGA/1b6c743e-8a29-4657-8917-467f90c8c272/TCGA-KV-A6GE-01Z-00-DX6.BAF3885F-8013-47CB-B9B1-C7F4FD0FB5E7.svs 75395 71521 3 +/data/TCGA/674f569f-7873-4e80-a00a-0fbd2dc14967/TCGA-EL-A3ZG-01Z-00-DX1.BBB20AF3-D1AB-4C1A-BC99-25729B3F1566.svs 53409 46845 0 +/data/TCGA/674f569f-7873-4e80-a00a-0fbd2dc14967/TCGA-EL-A3ZG-01Z-00-DX1.BBB20AF3-D1AB-4C1A-BC99-25729B3F1566.svs 76196 48292 1 +/data/TCGA/674f569f-7873-4e80-a00a-0fbd2dc14967/TCGA-EL-A3ZG-01Z-00-DX1.BBB20AF3-D1AB-4C1A-BC99-25729B3F1566.svs 33930 45327 2 +/data/TCGA/674f569f-7873-4e80-a00a-0fbd2dc14967/TCGA-EL-A3ZG-01Z-00-DX1.BBB20AF3-D1AB-4C1A-BC99-25729B3F1566.svs 63792 41523 3 +/data/TCGA/2224e5fa-9048-4943-aa1e-2294bdd97790/TCGA-BR-A44U-01Z-00-DX1.8C665560-8CAC-4ABF-B2B2-17A76B3A9F14.svs 98622 49475 0 +/data/TCGA/2224e5fa-9048-4943-aa1e-2294bdd97790/TCGA-BR-A44U-01Z-00-DX1.8C665560-8CAC-4ABF-B2B2-17A76B3A9F14.svs 86377 17910 1 +/data/TCGA/2224e5fa-9048-4943-aa1e-2294bdd97790/TCGA-BR-A44U-01Z-00-DX1.8C665560-8CAC-4ABF-B2B2-17A76B3A9F14.svs 82719 36574 2 +/data/TCGA/2224e5fa-9048-4943-aa1e-2294bdd97790/TCGA-BR-A44U-01Z-00-DX1.8C665560-8CAC-4ABF-B2B2-17A76B3A9F14.svs 28462 39307 3 +/data/TCGA/7483233a-b4b6-43cf-8f21-0a70d5802d5f/TCGA-56-7822-01Z-00-DX1.c387e241-ff4c-44ef-af45-12a85066f0ce.svs 34290 29096 0 +/data/TCGA/7483233a-b4b6-43cf-8f21-0a70d5802d5f/TCGA-56-7822-01Z-00-DX1.c387e241-ff4c-44ef-af45-12a85066f0ce.svs 18453 33309 1 +/data/TCGA/7483233a-b4b6-43cf-8f21-0a70d5802d5f/TCGA-56-7822-01Z-00-DX1.c387e241-ff4c-44ef-af45-12a85066f0ce.svs 18673 12559 2 +/data/TCGA/33b8e562-09a1-459e-b8fa-30060bc76a5e/TCGA-HT-8113-01Z-00-DX1.641F5405-47CF-41C6-8EA4-4ABD6C677A46.svs 66180 62539 0 +/data/TCGA/33b8e562-09a1-459e-b8fa-30060bc76a5e/TCGA-HT-8113-01Z-00-DX1.641F5405-47CF-41C6-8EA4-4ABD6C677A46.svs 62867 67976 1 +/data/TCGA/33b8e562-09a1-459e-b8fa-30060bc76a5e/TCGA-HT-8113-01Z-00-DX1.641F5405-47CF-41C6-8EA4-4ABD6C677A46.svs 62614 60397 2 +/data/TCGA/33b8e562-09a1-459e-b8fa-30060bc76a5e/TCGA-HT-8113-01Z-00-DX1.641F5405-47CF-41C6-8EA4-4ABD6C677A46.svs 56453 35371 3 +/data/TCGA/dee64a96-9071-4cbc-aa71-1afc9d03ff9f/TCGA-IB-A5SQ-01Z-00-DX1.790002F9-0B3B-44F6-A888-82E87FC78B73.svs 118566 42799 0 +/data/TCGA/dee64a96-9071-4cbc-aa71-1afc9d03ff9f/TCGA-IB-A5SQ-01Z-00-DX1.790002F9-0B3B-44F6-A888-82E87FC78B73.svs 108717 38858 1 +/data/TCGA/dee64a96-9071-4cbc-aa71-1afc9d03ff9f/TCGA-IB-A5SQ-01Z-00-DX1.790002F9-0B3B-44F6-A888-82E87FC78B73.svs 132119 2181 2 +/data/TCGA/dee64a96-9071-4cbc-aa71-1afc9d03ff9f/TCGA-IB-A5SQ-01Z-00-DX1.790002F9-0B3B-44F6-A888-82E87FC78B73.svs 8377 28158 3 +/data/TCGA/92333ba0-aba2-481e-b0d4-2a25a308add8/TCGA-JX-A5QV-01Z-00-DX1.90769414-2C5C-4BAA-A432-9FC0A15EEF5A.svs 156529 13793 0 +/data/TCGA/92333ba0-aba2-481e-b0d4-2a25a308add8/TCGA-JX-A5QV-01Z-00-DX1.90769414-2C5C-4BAA-A432-9FC0A15EEF5A.svs 161732 75927 1 +/data/TCGA/92333ba0-aba2-481e-b0d4-2a25a308add8/TCGA-JX-A5QV-01Z-00-DX1.90769414-2C5C-4BAA-A432-9FC0A15EEF5A.svs 62341 31008 2 +/data/TCGA/92333ba0-aba2-481e-b0d4-2a25a308add8/TCGA-JX-A5QV-01Z-00-DX1.90769414-2C5C-4BAA-A432-9FC0A15EEF5A.svs 52296 30201 3 +/data/TCGA/70a21c4f-f0e2-4bbc-a575-7ae4ed6f193a/TCGA-ER-A19L-01Z-00-DX1.1CA310C8-2C7A-4719-9D54-6F2098F43949.svs 86626 20510 0 +/data/TCGA/70a21c4f-f0e2-4bbc-a575-7ae4ed6f193a/TCGA-ER-A19L-01Z-00-DX1.1CA310C8-2C7A-4719-9D54-6F2098F43949.svs 42770 61309 1 +/data/TCGA/70a21c4f-f0e2-4bbc-a575-7ae4ed6f193a/TCGA-ER-A19L-01Z-00-DX1.1CA310C8-2C7A-4719-9D54-6F2098F43949.svs 21884 16968 2 +/data/TCGA/70a21c4f-f0e2-4bbc-a575-7ae4ed6f193a/TCGA-ER-A19L-01Z-00-DX1.1CA310C8-2C7A-4719-9D54-6F2098F43949.svs 53232 59556 3 +/data/TCGA/8846fe87-dbd3-4664-b8a2-c233829c7a6b/TCGA-EB-A1NK-01Z-00-DX1.655D7734-ADAD-4F3E-A82B-0C24EB6C9E79.svs 12425 37619 0 +/data/TCGA/8846fe87-dbd3-4664-b8a2-c233829c7a6b/TCGA-EB-A1NK-01Z-00-DX1.655D7734-ADAD-4F3E-A82B-0C24EB6C9E79.svs 35039 26639 1 +/data/TCGA/8846fe87-dbd3-4664-b8a2-c233829c7a6b/TCGA-EB-A1NK-01Z-00-DX1.655D7734-ADAD-4F3E-A82B-0C24EB6C9E79.svs 17016 17963 2 +/data/TCGA/8846fe87-dbd3-4664-b8a2-c233829c7a6b/TCGA-EB-A1NK-01Z-00-DX1.655D7734-ADAD-4F3E-A82B-0C24EB6C9E79.svs 14861 29228 3 +/data/TCGA/81c73328-d1da-4e9e-9771-e2c4bee1a763/TCGA-UD-AAC4-01Z-00-DX1.3485484D-1085-4FD5-B60E-FB3927BA0853.svs 84141 47279 0 +/data/TCGA/81c73328-d1da-4e9e-9771-e2c4bee1a763/TCGA-UD-AAC4-01Z-00-DX1.3485484D-1085-4FD5-B60E-FB3927BA0853.svs 59961 26284 1 +/data/TCGA/81c73328-d1da-4e9e-9771-e2c4bee1a763/TCGA-UD-AAC4-01Z-00-DX1.3485484D-1085-4FD5-B60E-FB3927BA0853.svs 34333 38121 2 +/data/TCGA/81c73328-d1da-4e9e-9771-e2c4bee1a763/TCGA-UD-AAC4-01Z-00-DX1.3485484D-1085-4FD5-B60E-FB3927BA0853.svs 46379 54257 3 +/data/TCGA/cd7bddd5-0f09-4891-a11a-b18cae6b9b53/TCGA-AA-3819-01Z-00-DX1.cd674efa-b953-4721-9468-ec6ad8b6f567.svs 15640 76552 0 +/data/TCGA/cd7bddd5-0f09-4891-a11a-b18cae6b9b53/TCGA-AA-3819-01Z-00-DX1.cd674efa-b953-4721-9468-ec6ad8b6f567.svs 11380 66808 1 +/data/TCGA/cd7bddd5-0f09-4891-a11a-b18cae6b9b53/TCGA-AA-3819-01Z-00-DX1.cd674efa-b953-4721-9468-ec6ad8b6f567.svs 8960 83173 2 +/data/TCGA/cd7bddd5-0f09-4891-a11a-b18cae6b9b53/TCGA-AA-3819-01Z-00-DX1.cd674efa-b953-4721-9468-ec6ad8b6f567.svs 16722 70858 3 +/data/TCGA/d31c8be2-ee73-4d8e-8772-a71fd8398745/TCGA-DD-AACJ-01Z-00-DX1.05506FD0-A106-4A19-929D-162BA04D172A.svs 97331 43288 0 +/data/TCGA/d31c8be2-ee73-4d8e-8772-a71fd8398745/TCGA-DD-AACJ-01Z-00-DX1.05506FD0-A106-4A19-929D-162BA04D172A.svs 44083 19988 1 +/data/TCGA/d31c8be2-ee73-4d8e-8772-a71fd8398745/TCGA-DD-AACJ-01Z-00-DX1.05506FD0-A106-4A19-929D-162BA04D172A.svs 105939 29527 2 +/data/TCGA/d31c8be2-ee73-4d8e-8772-a71fd8398745/TCGA-DD-AACJ-01Z-00-DX1.05506FD0-A106-4A19-929D-162BA04D172A.svs 23795 31913 3 +/data/TCGA/eeab1331-c986-4ff1-83a5-bc7d00a3d252/TCGA-Z6-A8JE-01Z-00-DX1.A8C43EAD-0CDD-4803-8348-6E7B158C85C5.svs 34204 65243 0 +/data/TCGA/eeab1331-c986-4ff1-83a5-bc7d00a3d252/TCGA-Z6-A8JE-01Z-00-DX1.A8C43EAD-0CDD-4803-8348-6E7B158C85C5.svs 39709 49760 1 +/data/TCGA/eeab1331-c986-4ff1-83a5-bc7d00a3d252/TCGA-Z6-A8JE-01Z-00-DX1.A8C43EAD-0CDD-4803-8348-6E7B158C85C5.svs 39953 30424 2 +/data/TCGA/eeab1331-c986-4ff1-83a5-bc7d00a3d252/TCGA-Z6-A8JE-01Z-00-DX1.A8C43EAD-0CDD-4803-8348-6E7B158C85C5.svs 38201 20740 3 +/data/TCGA/10e9734e-e699-490f-b3a0-a04c1aa5a75c/TCGA-ZS-A9CG-01Z-00-DX1.FEF9A55C-9331-469C-9D13-FCB232136024.svs 57312 23519 0 +/data/TCGA/10e9734e-e699-490f-b3a0-a04c1aa5a75c/TCGA-ZS-A9CG-01Z-00-DX1.FEF9A55C-9331-469C-9D13-FCB232136024.svs 85811 24327 1 +/data/TCGA/10e9734e-e699-490f-b3a0-a04c1aa5a75c/TCGA-ZS-A9CG-01Z-00-DX1.FEF9A55C-9331-469C-9D13-FCB232136024.svs 85830 58377 2 +/data/TCGA/10e9734e-e699-490f-b3a0-a04c1aa5a75c/TCGA-ZS-A9CG-01Z-00-DX1.FEF9A55C-9331-469C-9D13-FCB232136024.svs 113522 46839 3 +/data/TCGA/1884b4a2-9bfc-40af-ae5e-6d664795e106/TCGA-ET-A39N-01Z-00-DX1.26D1D111-73BF-476F-8DCA-82BD5A56061C.svs 44794 40152 0 +/data/TCGA/1884b4a2-9bfc-40af-ae5e-6d664795e106/TCGA-ET-A39N-01Z-00-DX1.26D1D111-73BF-476F-8DCA-82BD5A56061C.svs 26323 65631 1 +/data/TCGA/1884b4a2-9bfc-40af-ae5e-6d664795e106/TCGA-ET-A39N-01Z-00-DX1.26D1D111-73BF-476F-8DCA-82BD5A56061C.svs 86916 12271 2 +/data/TCGA/1884b4a2-9bfc-40af-ae5e-6d664795e106/TCGA-ET-A39N-01Z-00-DX1.26D1D111-73BF-476F-8DCA-82BD5A56061C.svs 16518 34706 3 +/data/TCGA/c5be1884-f7b8-44a5-a123-1fe699555886/TCGA-XF-A9SL-01Z-00-DX1.AA56A70C-28E1-4140-9B15-72AB0D5051A6.svs 41263 48299 0 +/data/TCGA/c5be1884-f7b8-44a5-a123-1fe699555886/TCGA-XF-A9SL-01Z-00-DX1.AA56A70C-28E1-4140-9B15-72AB0D5051A6.svs 66466 62354 1 +/data/TCGA/c5be1884-f7b8-44a5-a123-1fe699555886/TCGA-XF-A9SL-01Z-00-DX1.AA56A70C-28E1-4140-9B15-72AB0D5051A6.svs 72278 56934 2 +/data/TCGA/c5be1884-f7b8-44a5-a123-1fe699555886/TCGA-XF-A9SL-01Z-00-DX1.AA56A70C-28E1-4140-9B15-72AB0D5051A6.svs 62508 56136 3 +/data/TCGA/07716617-0373-443e-82d6-75ec1af0a257/TCGA-PK-A5HC-01Z-00-DX2.B17A10A3-D5DA-40D7-A850-8E537C20C471.svs 72813 25868 0 +/data/TCGA/07716617-0373-443e-82d6-75ec1af0a257/TCGA-PK-A5HC-01Z-00-DX2.B17A10A3-D5DA-40D7-A850-8E537C20C471.svs 42139 26401 1 +/data/TCGA/07716617-0373-443e-82d6-75ec1af0a257/TCGA-PK-A5HC-01Z-00-DX2.B17A10A3-D5DA-40D7-A850-8E537C20C471.svs 31306 10683 2 +/data/TCGA/07716617-0373-443e-82d6-75ec1af0a257/TCGA-PK-A5HC-01Z-00-DX2.B17A10A3-D5DA-40D7-A850-8E537C20C471.svs 53086 11372 3 +/data/TCGA/b74332d0-15bc-4657-8d83-958e7d7920d2/TCGA-XN-A8T5-01Z-00-DX1.317CFC78-4666-4F11-BCC4-B60F5E5EB78B.svs 31335 78516 0 +/data/TCGA/b74332d0-15bc-4657-8d83-958e7d7920d2/TCGA-XN-A8T5-01Z-00-DX1.317CFC78-4666-4F11-BCC4-B60F5E5EB78B.svs 88440 67487 1 +/data/TCGA/b74332d0-15bc-4657-8d83-958e7d7920d2/TCGA-XN-A8T5-01Z-00-DX1.317CFC78-4666-4F11-BCC4-B60F5E5EB78B.svs 38306 35706 2 +/data/TCGA/b74332d0-15bc-4657-8d83-958e7d7920d2/TCGA-XN-A8T5-01Z-00-DX1.317CFC78-4666-4F11-BCC4-B60F5E5EB78B.svs 58012 20533 3 +/data/TCGA/1acd3b56-a26b-4588-92bf-169240601461/TCGA-V4-A9F3-01Z-00-DX1.39FC86CA-2833-4361-93A0-C8534EBFD255.svs 57848 49483 0 +/data/TCGA/1acd3b56-a26b-4588-92bf-169240601461/TCGA-V4-A9F3-01Z-00-DX1.39FC86CA-2833-4361-93A0-C8534EBFD255.svs 5691 39185 1 +/data/TCGA/1acd3b56-a26b-4588-92bf-169240601461/TCGA-V4-A9F3-01Z-00-DX1.39FC86CA-2833-4361-93A0-C8534EBFD255.svs 60218 10699 2 +/data/TCGA/1acd3b56-a26b-4588-92bf-169240601461/TCGA-V4-A9F3-01Z-00-DX1.39FC86CA-2833-4361-93A0-C8534EBFD255.svs 61990 26406 3 +/data/TCGA/28f660a7-df83-45e2-adfd-3c0ac7b37d4a/TCGA-RD-A8N2-01Z-00-DX1.A56448E6-1C5E-4758-AC2E-4591A406116C.svs 98862 20827 0 +/data/TCGA/28f660a7-df83-45e2-adfd-3c0ac7b37d4a/TCGA-RD-A8N2-01Z-00-DX1.A56448E6-1C5E-4758-AC2E-4591A406116C.svs 42140 37128 1 +/data/TCGA/28f660a7-df83-45e2-adfd-3c0ac7b37d4a/TCGA-RD-A8N2-01Z-00-DX1.A56448E6-1C5E-4758-AC2E-4591A406116C.svs 101690 23751 2 +/data/TCGA/28f660a7-df83-45e2-adfd-3c0ac7b37d4a/TCGA-RD-A8N2-01Z-00-DX1.A56448E6-1C5E-4758-AC2E-4591A406116C.svs 63754 21757 3 +/data/TCGA/0e226b74-1cde-4bb5-9998-2e94a7fe16ba/TCGA-85-8352-01Z-00-DX1.47426016-95BC-49C0-9844-06A3A7EAE5D6.svs 49321 43796 0 +/data/TCGA/0e226b74-1cde-4bb5-9998-2e94a7fe16ba/TCGA-85-8352-01Z-00-DX1.47426016-95BC-49C0-9844-06A3A7EAE5D6.svs 31098 28160 1 +/data/TCGA/0e226b74-1cde-4bb5-9998-2e94a7fe16ba/TCGA-85-8352-01Z-00-DX1.47426016-95BC-49C0-9844-06A3A7EAE5D6.svs 63818 24457 2 +/data/TCGA/0e226b74-1cde-4bb5-9998-2e94a7fe16ba/TCGA-85-8352-01Z-00-DX1.47426016-95BC-49C0-9844-06A3A7EAE5D6.svs 63122 28802 3 +/data/TCGA/bb59d256-30c9-412a-b336-d08f7c90759c/TCGA-D7-A6EX-01Z-00-DX1.03BECFB9-A4B2-4B43-99F7-C49850796F31.svs 72415 50723 0 +/data/TCGA/bb59d256-30c9-412a-b336-d08f7c90759c/TCGA-D7-A6EX-01Z-00-DX1.03BECFB9-A4B2-4B43-99F7-C49850796F31.svs 58029 62798 1 +/data/TCGA/bb59d256-30c9-412a-b336-d08f7c90759c/TCGA-D7-A6EX-01Z-00-DX1.03BECFB9-A4B2-4B43-99F7-C49850796F31.svs 28515 60102 2 +/data/TCGA/bb59d256-30c9-412a-b336-d08f7c90759c/TCGA-D7-A6EX-01Z-00-DX1.03BECFB9-A4B2-4B43-99F7-C49850796F31.svs 40812 11534 3 +/data/TCGA/3c173a0e-4bfa-4d91-98a2-e9ae5b24faeb/TCGA-EB-A553-01Z-00-DX1.5DB62584-E538-4C83-8996-7F3AD478F4F1.svs 14026 25308 0 +/data/TCGA/3c173a0e-4bfa-4d91-98a2-e9ae5b24faeb/TCGA-EB-A553-01Z-00-DX1.5DB62584-E538-4C83-8996-7F3AD478F4F1.svs 38386 18265 1 +/data/TCGA/3c173a0e-4bfa-4d91-98a2-e9ae5b24faeb/TCGA-EB-A553-01Z-00-DX1.5DB62584-E538-4C83-8996-7F3AD478F4F1.svs 40890 3280 2 +/data/TCGA/3c173a0e-4bfa-4d91-98a2-e9ae5b24faeb/TCGA-EB-A553-01Z-00-DX1.5DB62584-E538-4C83-8996-7F3AD478F4F1.svs 47905 29071 3 +/data/TCGA/ee564807-c620-441d-b94b-09106ec9d7a0/TCGA-VM-A8C9-01Z-00-DX9.DEF6A890-B06E-42BC-A653-A6BF5E324B8D.svs 134199 44418 0 +/data/TCGA/ee564807-c620-441d-b94b-09106ec9d7a0/TCGA-VM-A8C9-01Z-00-DX9.DEF6A890-B06E-42BC-A653-A6BF5E324B8D.svs 50367 22883 1 +/data/TCGA/ee564807-c620-441d-b94b-09106ec9d7a0/TCGA-VM-A8C9-01Z-00-DX9.DEF6A890-B06E-42BC-A653-A6BF5E324B8D.svs 107513 44816 2 +/data/TCGA/ee564807-c620-441d-b94b-09106ec9d7a0/TCGA-VM-A8C9-01Z-00-DX9.DEF6A890-B06E-42BC-A653-A6BF5E324B8D.svs 58235 60553 3 +/data/TCGA/3f6b7888-c7c3-4e6a-8d54-364ad608e8d0/TCGA-B0-4712-01Z-00-DX1.b584d650-4bdd-452c-9926-18a1a8388d91.svs 54278 48520 0 +/data/TCGA/3f6b7888-c7c3-4e6a-8d54-364ad608e8d0/TCGA-B0-4712-01Z-00-DX1.b584d650-4bdd-452c-9926-18a1a8388d91.svs 70868 34951 1 +/data/TCGA/3f6b7888-c7c3-4e6a-8d54-364ad608e8d0/TCGA-B0-4712-01Z-00-DX1.b584d650-4bdd-452c-9926-18a1a8388d91.svs 64286 16342 2 +/data/TCGA/3f6b7888-c7c3-4e6a-8d54-364ad608e8d0/TCGA-B0-4712-01Z-00-DX1.b584d650-4bdd-452c-9926-18a1a8388d91.svs 59967 54799 3 +/data/TCGA/4e93254a-88c5-422d-ad7f-0c98fb344fe4/TCGA-SP-A6QH-01Z-00-DX1.E4E713B3-1CA8-470C-878B-256C38687D0B.svs 71061 45810 0 +/data/TCGA/4e93254a-88c5-422d-ad7f-0c98fb344fe4/TCGA-SP-A6QH-01Z-00-DX1.E4E713B3-1CA8-470C-878B-256C38687D0B.svs 65082 50497 1 +/data/TCGA/4e93254a-88c5-422d-ad7f-0c98fb344fe4/TCGA-SP-A6QH-01Z-00-DX1.E4E713B3-1CA8-470C-878B-256C38687D0B.svs 35879 41648 2 +/data/TCGA/4e93254a-88c5-422d-ad7f-0c98fb344fe4/TCGA-SP-A6QH-01Z-00-DX1.E4E713B3-1CA8-470C-878B-256C38687D0B.svs 39664 45557 3 +/data/TCGA/2c6fbdb0-2fbb-4881-aa2e-ad3627665576/TCGA-SU-A7E7-01Z-00-DX1.1C4CB02E-100C-4A40-8C98-55F21C6CEE30.svs 26357 39920 0 +/data/TCGA/2c6fbdb0-2fbb-4881-aa2e-ad3627665576/TCGA-SU-A7E7-01Z-00-DX1.1C4CB02E-100C-4A40-8C98-55F21C6CEE30.svs 27998 17363 1 +/data/TCGA/2c6fbdb0-2fbb-4881-aa2e-ad3627665576/TCGA-SU-A7E7-01Z-00-DX1.1C4CB02E-100C-4A40-8C98-55F21C6CEE30.svs 32829 27309 2 +/data/TCGA/2c6fbdb0-2fbb-4881-aa2e-ad3627665576/TCGA-SU-A7E7-01Z-00-DX1.1C4CB02E-100C-4A40-8C98-55F21C6CEE30.svs 10373 44502 3 +/data/TCGA/f514d2bc-3d41-4a44-b5e2-4d6743f5dec1/TCGA-X6-A8C5-01Z-00-DX1.73A190A3-EC24-4CCE-AD22-7444DDE23CFD.svs 107767 38484 0 +/data/TCGA/f514d2bc-3d41-4a44-b5e2-4d6743f5dec1/TCGA-X6-A8C5-01Z-00-DX1.73A190A3-EC24-4CCE-AD22-7444DDE23CFD.svs 121829 71084 1 +/data/TCGA/f514d2bc-3d41-4a44-b5e2-4d6743f5dec1/TCGA-X6-A8C5-01Z-00-DX1.73A190A3-EC24-4CCE-AD22-7444DDE23CFD.svs 96852 31017 2 +/data/TCGA/f514d2bc-3d41-4a44-b5e2-4d6743f5dec1/TCGA-X6-A8C5-01Z-00-DX1.73A190A3-EC24-4CCE-AD22-7444DDE23CFD.svs 37059 40030 3 +/data/TCGA/a3e9a779-c21a-464b-8423-576dedc41aa1/TCGA-C8-A1HM-01Z-00-DX1.F93C3F56-3AA6-4D38-B51E-4694CBEA3830.svs 22281 40300 0 +/data/TCGA/a3e9a779-c21a-464b-8423-576dedc41aa1/TCGA-C8-A1HM-01Z-00-DX1.F93C3F56-3AA6-4D38-B51E-4694CBEA3830.svs 17816 48773 1 +/data/TCGA/a3e9a779-c21a-464b-8423-576dedc41aa1/TCGA-C8-A1HM-01Z-00-DX1.F93C3F56-3AA6-4D38-B51E-4694CBEA3830.svs 10651 33712 2 +/data/TCGA/a3e9a779-c21a-464b-8423-576dedc41aa1/TCGA-C8-A1HM-01Z-00-DX1.F93C3F56-3AA6-4D38-B51E-4694CBEA3830.svs 9292 27149 3 +/data/TCGA/18635267-7704-4327-b08a-a6aaf8778774/TCGA-14-1454-01Z-00-DX1.b61db33c-e8d4-4740-b565-5e62bc13e606.svs 35734 23587 0 +/data/TCGA/18635267-7704-4327-b08a-a6aaf8778774/TCGA-14-1454-01Z-00-DX1.b61db33c-e8d4-4740-b565-5e62bc13e606.svs 10499 28975 1 +/data/TCGA/18635267-7704-4327-b08a-a6aaf8778774/TCGA-14-1454-01Z-00-DX1.b61db33c-e8d4-4740-b565-5e62bc13e606.svs 7508 17923 2 +/data/TCGA/a12ed831-9ee6-48cb-9f33-af55441ccb06/TCGA-12-0821-01Z-00-DX3.36A91C47-5A98-430A-BDE2-A70A02E6C837.svs 9474 16616 0 +/data/TCGA/a12ed831-9ee6-48cb-9f33-af55441ccb06/TCGA-12-0821-01Z-00-DX3.36A91C47-5A98-430A-BDE2-A70A02E6C837.svs 29086 33768 1 +/data/TCGA/a12ed831-9ee6-48cb-9f33-af55441ccb06/TCGA-12-0821-01Z-00-DX3.36A91C47-5A98-430A-BDE2-A70A02E6C837.svs 20803 13223 2 +/data/TCGA/d932027a-0b20-4cca-af05-6caa3092c256/TCGA-CE-A13K-01Z-00-DX1.7D293931-179E-4C5E-ACE5-D87D7ECAC0A4.svs 52406 4924 0 +/data/TCGA/d932027a-0b20-4cca-af05-6caa3092c256/TCGA-CE-A13K-01Z-00-DX1.7D293931-179E-4C5E-ACE5-D87D7ECAC0A4.svs 25172 59322 1 +/data/TCGA/d932027a-0b20-4cca-af05-6caa3092c256/TCGA-CE-A13K-01Z-00-DX1.7D293931-179E-4C5E-ACE5-D87D7ECAC0A4.svs 27523 11419 2 +/data/TCGA/d932027a-0b20-4cca-af05-6caa3092c256/TCGA-CE-A13K-01Z-00-DX1.7D293931-179E-4C5E-ACE5-D87D7ECAC0A4.svs 10037 43465 3 +/data/TCGA/8443648b-2db7-446e-b169-c52cbdc9007d/TCGA-QK-A8Z9-01Z-00-DX1.41A4F270-25E0-4437-BE38-7D0D1A0FA901.svs 85773 62822 0 +/data/TCGA/8443648b-2db7-446e-b169-c52cbdc9007d/TCGA-QK-A8Z9-01Z-00-DX1.41A4F270-25E0-4437-BE38-7D0D1A0FA901.svs 70077 60853 1 +/data/TCGA/8443648b-2db7-446e-b169-c52cbdc9007d/TCGA-QK-A8Z9-01Z-00-DX1.41A4F270-25E0-4437-BE38-7D0D1A0FA901.svs 58021 71105 2 +/data/TCGA/8443648b-2db7-446e-b169-c52cbdc9007d/TCGA-QK-A8Z9-01Z-00-DX1.41A4F270-25E0-4437-BE38-7D0D1A0FA901.svs 90892 15899 3 +/data/TCGA/7b339fee-c4f4-4ce4-b26c-a2042a1e5a30/TCGA-TQ-A7RW-01Z-00-DX1.05F422AA-ED7B-4D53-9B32-2B7CEFB85021.svs 42644 14129 0 +/data/TCGA/7b339fee-c4f4-4ce4-b26c-a2042a1e5a30/TCGA-TQ-A7RW-01Z-00-DX1.05F422AA-ED7B-4D53-9B32-2B7CEFB85021.svs 57268 49843 1 +/data/TCGA/7b339fee-c4f4-4ce4-b26c-a2042a1e5a30/TCGA-TQ-A7RW-01Z-00-DX1.05F422AA-ED7B-4D53-9B32-2B7CEFB85021.svs 56326 63082 2 +/data/TCGA/7b339fee-c4f4-4ce4-b26c-a2042a1e5a30/TCGA-TQ-A7RW-01Z-00-DX1.05F422AA-ED7B-4D53-9B32-2B7CEFB85021.svs 24065 44726 3 +/data/TCGA/a21467ab-2cbc-49b5-9cb0-cc82ce7c728b/TCGA-BR-4371-01Z-00-DX1.b45af289-5e56-40dd-80ba-7b8752d0344e.svs 277 431 0 +/data/TCGA/e53e0e0b-52de-4347-87c6-b1412bdfd655/TCGA-QK-A6V9-01Z-00-DX1.0D202E91-5205-4888-A40D-381F7534B34A.svs 72431 22105 0 +/data/TCGA/e53e0e0b-52de-4347-87c6-b1412bdfd655/TCGA-QK-A6V9-01Z-00-DX1.0D202E91-5205-4888-A40D-381F7534B34A.svs 40549 61096 1 +/data/TCGA/e53e0e0b-52de-4347-87c6-b1412bdfd655/TCGA-QK-A6V9-01Z-00-DX1.0D202E91-5205-4888-A40D-381F7534B34A.svs 19838 55239 2 +/data/TCGA/e53e0e0b-52de-4347-87c6-b1412bdfd655/TCGA-QK-A6V9-01Z-00-DX1.0D202E91-5205-4888-A40D-381F7534B34A.svs 31396 8171 3 +/data/TCGA/3b12bb4f-84bc-4947-b33d-c9ea2b3a3142/TCGA-4X-A9F9-01Z-00-DX6.9342DA04-2DE6-4C52-9E4D-B2430060EA85.svs 54639 29374 0 +/data/TCGA/3b12bb4f-84bc-4947-b33d-c9ea2b3a3142/TCGA-4X-A9F9-01Z-00-DX6.9342DA04-2DE6-4C52-9E4D-B2430060EA85.svs 62807 9189 1 +/data/TCGA/3b12bb4f-84bc-4947-b33d-c9ea2b3a3142/TCGA-4X-A9F9-01Z-00-DX6.9342DA04-2DE6-4C52-9E4D-B2430060EA85.svs 19138 6123 2 +/data/TCGA/3b12bb4f-84bc-4947-b33d-c9ea2b3a3142/TCGA-4X-A9F9-01Z-00-DX6.9342DA04-2DE6-4C52-9E4D-B2430060EA85.svs 11640 58583 3 +/data/TCGA/069a8f13-04e2-41c7-ab64-90a465c7c4bc/TCGA-AR-A0TQ-01Z-00-DX1.2BEA298C-6B3D-4133-ADBC-769E62CEFFA0.svs 8292 34900 0 +/data/TCGA/069a8f13-04e2-41c7-ab64-90a465c7c4bc/TCGA-AR-A0TQ-01Z-00-DX1.2BEA298C-6B3D-4133-ADBC-769E62CEFFA0.svs 33316 10902 1 +/data/TCGA/069a8f13-04e2-41c7-ab64-90a465c7c4bc/TCGA-AR-A0TQ-01Z-00-DX1.2BEA298C-6B3D-4133-ADBC-769E62CEFFA0.svs 19957 7329 2 +/data/TCGA/069a8f13-04e2-41c7-ab64-90a465c7c4bc/TCGA-AR-A0TQ-01Z-00-DX1.2BEA298C-6B3D-4133-ADBC-769E62CEFFA0.svs 13170 7010 3 +/data/TCGA/b39dec12-1ba9-4d67-a708-9b184abd9fc9/TCGA-RC-A7SH-01Z-00-DX1.96A1F4A5-ACE6-4EE6-9D41-9018F235A629.svs 90346 28061 0 +/data/TCGA/b39dec12-1ba9-4d67-a708-9b184abd9fc9/TCGA-RC-A7SH-01Z-00-DX1.96A1F4A5-ACE6-4EE6-9D41-9018F235A629.svs 28094 46792 1 +/data/TCGA/b39dec12-1ba9-4d67-a708-9b184abd9fc9/TCGA-RC-A7SH-01Z-00-DX1.96A1F4A5-ACE6-4EE6-9D41-9018F235A629.svs 36234 68713 2 +/data/TCGA/b39dec12-1ba9-4d67-a708-9b184abd9fc9/TCGA-RC-A7SH-01Z-00-DX1.96A1F4A5-ACE6-4EE6-9D41-9018F235A629.svs 10912 32361 3 +/data/TCGA/3d3794ec-04ba-4ce4-8c63-e09dee4f597f/TCGA-D3-A8GO-06Z-00-DX1.357CD90F-23D3-45BB-BA13-DCF5AED677C1.svs 29586 42425 0 +/data/TCGA/3d3794ec-04ba-4ce4-8c63-e09dee4f597f/TCGA-D3-A8GO-06Z-00-DX1.357CD90F-23D3-45BB-BA13-DCF5AED677C1.svs 27889 13699 1 +/data/TCGA/3d3794ec-04ba-4ce4-8c63-e09dee4f597f/TCGA-D3-A8GO-06Z-00-DX1.357CD90F-23D3-45BB-BA13-DCF5AED677C1.svs 71424 61190 2 +/data/TCGA/3d3794ec-04ba-4ce4-8c63-e09dee4f597f/TCGA-D3-A8GO-06Z-00-DX1.357CD90F-23D3-45BB-BA13-DCF5AED677C1.svs 3863 14076 3 +/data/TCGA/8472de58-9075-4534-b00b-3a87ba2158da/TCGA-AD-6963-01Z-00-DX1.7df2e133-5f24-4c0a-b7f5-5a65fe3420c9.svs 10157 7862 0 +/data/TCGA/8472de58-9075-4534-b00b-3a87ba2158da/TCGA-AD-6963-01Z-00-DX1.7df2e133-5f24-4c0a-b7f5-5a65fe3420c9.svs 20922 20576 1 +/data/TCGA/8472de58-9075-4534-b00b-3a87ba2158da/TCGA-AD-6963-01Z-00-DX1.7df2e133-5f24-4c0a-b7f5-5a65fe3420c9.svs 14205 10315 2 +/data/TCGA/34389bdd-bc1e-433c-ab19-826787f5a938/TCGA-KM-8440-01Z-00-DX1.528E053C-E8A4-464F-BE47-412836B1C31B.svs 40921 41323 0 +/data/TCGA/34389bdd-bc1e-433c-ab19-826787f5a938/TCGA-KM-8440-01Z-00-DX1.528E053C-E8A4-464F-BE47-412836B1C31B.svs 75068 60380 1 +/data/TCGA/34389bdd-bc1e-433c-ab19-826787f5a938/TCGA-KM-8440-01Z-00-DX1.528E053C-E8A4-464F-BE47-412836B1C31B.svs 68216 34348 2 +/data/TCGA/34389bdd-bc1e-433c-ab19-826787f5a938/TCGA-KM-8440-01Z-00-DX1.528E053C-E8A4-464F-BE47-412836B1C31B.svs 108608 23461 3 +/data/TCGA/15ad9b46-ebbb-4904-ab89-f082e4b0de99/TCGA-CV-6938-01Z-00-DX1.8D0880C1-2E01-4954-95C0-6F15FF0F0B0A.svs 56188 34165 0 +/data/TCGA/15ad9b46-ebbb-4904-ab89-f082e4b0de99/TCGA-CV-6938-01Z-00-DX1.8D0880C1-2E01-4954-95C0-6F15FF0F0B0A.svs 62612 12477 1 +/data/TCGA/15ad9b46-ebbb-4904-ab89-f082e4b0de99/TCGA-CV-6938-01Z-00-DX1.8D0880C1-2E01-4954-95C0-6F15FF0F0B0A.svs 68387 9224 2 +/data/TCGA/15ad9b46-ebbb-4904-ab89-f082e4b0de99/TCGA-CV-6938-01Z-00-DX1.8D0880C1-2E01-4954-95C0-6F15FF0F0B0A.svs 81982 14889 3 +/data/TCGA/a252e490-27df-4cb8-8983-3ec6489ef244/TCGA-FJ-A3Z7-01Z-00-DX3.6709359F-68F9-4B02-B793-359B83F26372.svs 83640 49868 0 +/data/TCGA/a252e490-27df-4cb8-8983-3ec6489ef244/TCGA-FJ-A3Z7-01Z-00-DX3.6709359F-68F9-4B02-B793-359B83F26372.svs 122340 47706 1 +/data/TCGA/a252e490-27df-4cb8-8983-3ec6489ef244/TCGA-FJ-A3Z7-01Z-00-DX3.6709359F-68F9-4B02-B793-359B83F26372.svs 119905 32610 2 +/data/TCGA/a252e490-27df-4cb8-8983-3ec6489ef244/TCGA-FJ-A3Z7-01Z-00-DX3.6709359F-68F9-4B02-B793-359B83F26372.svs 99947 39233 3 +/data/TCGA/72ef1dd6-1b36-4976-8f00-12b013be2657/TCGA-UF-A7JK-01Z-00-DX1.7CEA17F6-1EAC-4B48-A08F-B81ADEBE74D5.svs 72825 29092 0 +/data/TCGA/72ef1dd6-1b36-4976-8f00-12b013be2657/TCGA-UF-A7JK-01Z-00-DX1.7CEA17F6-1EAC-4B48-A08F-B81ADEBE74D5.svs 84758 57305 1 +/data/TCGA/72ef1dd6-1b36-4976-8f00-12b013be2657/TCGA-UF-A7JK-01Z-00-DX1.7CEA17F6-1EAC-4B48-A08F-B81ADEBE74D5.svs 63571 74492 2 +/data/TCGA/72ef1dd6-1b36-4976-8f00-12b013be2657/TCGA-UF-A7JK-01Z-00-DX1.7CEA17F6-1EAC-4B48-A08F-B81ADEBE74D5.svs 72494 30867 3 +/data/TCGA/a0224a1f-c5ef-4f68-9cc1-ba29a25656ef/TCGA-J4-A83K-01Z-00-DX1.7A8B686F-E4E3-48DF-8761-9B3923D38463.svs 47252 18756 0 +/data/TCGA/a0224a1f-c5ef-4f68-9cc1-ba29a25656ef/TCGA-J4-A83K-01Z-00-DX1.7A8B686F-E4E3-48DF-8761-9B3923D38463.svs 14826 52266 1 +/data/TCGA/a0224a1f-c5ef-4f68-9cc1-ba29a25656ef/TCGA-J4-A83K-01Z-00-DX1.7A8B686F-E4E3-48DF-8761-9B3923D38463.svs 51158 61617 2 +/data/TCGA/a0224a1f-c5ef-4f68-9cc1-ba29a25656ef/TCGA-J4-A83K-01Z-00-DX1.7A8B686F-E4E3-48DF-8761-9B3923D38463.svs 37473 6288 3 +/data/TCGA/36d160ab-0d5e-4059-a84a-7f96637e2f10/TCGA-AX-A1C5-01Z-00-DX1.5A13A645-BED0-4819-B168-22118E103828.svs 54903 50035 0 +/data/TCGA/36d160ab-0d5e-4059-a84a-7f96637e2f10/TCGA-AX-A1C5-01Z-00-DX1.5A13A645-BED0-4819-B168-22118E103828.svs 55072 35688 1 +/data/TCGA/36d160ab-0d5e-4059-a84a-7f96637e2f10/TCGA-AX-A1C5-01Z-00-DX1.5A13A645-BED0-4819-B168-22118E103828.svs 45510 33053 2 +/data/TCGA/36d160ab-0d5e-4059-a84a-7f96637e2f10/TCGA-AX-A1C5-01Z-00-DX1.5A13A645-BED0-4819-B168-22118E103828.svs 64481 22921 3 +/data/TCGA/2c943b62-a6d7-4c19-b743-cea09ef5c1c8/TCGA-22-4613-01Z-00-DX1.4BC3B7B8-99E7-4744-8F5A-089ECCDE144E.svs 22264 14262 0 +/data/TCGA/2c943b62-a6d7-4c19-b743-cea09ef5c1c8/TCGA-22-4613-01Z-00-DX1.4BC3B7B8-99E7-4744-8F5A-089ECCDE144E.svs 21150 50033 1 +/data/TCGA/2c943b62-a6d7-4c19-b743-cea09ef5c1c8/TCGA-22-4613-01Z-00-DX1.4BC3B7B8-99E7-4744-8F5A-089ECCDE144E.svs 42539 24671 2 +/data/TCGA/2c943b62-a6d7-4c19-b743-cea09ef5c1c8/TCGA-22-4613-01Z-00-DX1.4BC3B7B8-99E7-4744-8F5A-089ECCDE144E.svs 16164 23956 3 +/data/TCGA/a637b26b-961d-4932-90e9-3076704a3411/TCGA-HT-7470-01Z-00-DX1.C6D5284B-5049-4605-B94B-A1010257CD8E.svs 10592 12003 0 +/data/TCGA/a637b26b-961d-4932-90e9-3076704a3411/TCGA-HT-7470-01Z-00-DX1.C6D5284B-5049-4605-B94B-A1010257CD8E.svs 9027 14565 1 +/data/TCGA/a637b26b-961d-4932-90e9-3076704a3411/TCGA-HT-7470-01Z-00-DX1.C6D5284B-5049-4605-B94B-A1010257CD8E.svs 62100 5169 2 +/data/TCGA/bb8beece-3027-472a-97bc-699457482324/TCGA-BR-6803-01Z-00-DX1.0704a32a-4a03-4c67-96ad-4888ea899c70.svs 48938 34274 0 +/data/TCGA/bb8beece-3027-472a-97bc-699457482324/TCGA-BR-6803-01Z-00-DX1.0704a32a-4a03-4c67-96ad-4888ea899c70.svs 9181 28259 1 +/data/TCGA/bb8beece-3027-472a-97bc-699457482324/TCGA-BR-6803-01Z-00-DX1.0704a32a-4a03-4c67-96ad-4888ea899c70.svs 18531 8708 2 +/data/TCGA/bb8beece-3027-472a-97bc-699457482324/TCGA-BR-6803-01Z-00-DX1.0704a32a-4a03-4c67-96ad-4888ea899c70.svs 17872 19091 3 +/data/TCGA/65c68d5a-6fe1-4a30-bb8e-0bf6fb575fd8/TCGA-4Z-AA84-01Z-00-DX1.604B60F3-1E19-4335-9F8D-0D6920B1ACF8.svs 45563 70996 0 +/data/TCGA/65c68d5a-6fe1-4a30-bb8e-0bf6fb575fd8/TCGA-4Z-AA84-01Z-00-DX1.604B60F3-1E19-4335-9F8D-0D6920B1ACF8.svs 25336 61842 1 +/data/TCGA/65c68d5a-6fe1-4a30-bb8e-0bf6fb575fd8/TCGA-4Z-AA84-01Z-00-DX1.604B60F3-1E19-4335-9F8D-0D6920B1ACF8.svs 32438 19582 2 +/data/TCGA/65c68d5a-6fe1-4a30-bb8e-0bf6fb575fd8/TCGA-4Z-AA84-01Z-00-DX1.604B60F3-1E19-4335-9F8D-0D6920B1ACF8.svs 35612 22929 3 +/data/TCGA/223fb60a-932c-4cef-bb39-c286b9da2706/TCGA-CD-8524-01Z-00-DX1.DECAC3E1-31F4-4D7E-9ABD-8E0CF27DB4B9.svs 31110 20402 0 +/data/TCGA/223fb60a-932c-4cef-bb39-c286b9da2706/TCGA-CD-8524-01Z-00-DX1.DECAC3E1-31F4-4D7E-9ABD-8E0CF27DB4B9.svs 12009 26568 1 +/data/TCGA/223fb60a-932c-4cef-bb39-c286b9da2706/TCGA-CD-8524-01Z-00-DX1.DECAC3E1-31F4-4D7E-9ABD-8E0CF27DB4B9.svs 18766 21143 2 +/data/TCGA/223fb60a-932c-4cef-bb39-c286b9da2706/TCGA-CD-8524-01Z-00-DX1.DECAC3E1-31F4-4D7E-9ABD-8E0CF27DB4B9.svs 24806 37294 3 +/data/TCGA/7ec5e054-5e79-4830-8eef-162b1bb758d1/TCGA-EL-A3GY-01Z-00-DX1.77EB800B-4CE0-4AD3-816B-EA6D945C1156.svs 88543 21341 0 +/data/TCGA/7ec5e054-5e79-4830-8eef-162b1bb758d1/TCGA-EL-A3GY-01Z-00-DX1.77EB800B-4CE0-4AD3-816B-EA6D945C1156.svs 34580 49216 1 +/data/TCGA/7ec5e054-5e79-4830-8eef-162b1bb758d1/TCGA-EL-A3GY-01Z-00-DX1.77EB800B-4CE0-4AD3-816B-EA6D945C1156.svs 42889 45234 2 +/data/TCGA/7ec5e054-5e79-4830-8eef-162b1bb758d1/TCGA-EL-A3GY-01Z-00-DX1.77EB800B-4CE0-4AD3-816B-EA6D945C1156.svs 59492 44198 3 +/data/TCGA/5af6ee35-6515-402b-9584-89971c39137c/TCGA-ZH-A8Y1-01Z-00-DX1.2FE51BA7-9B4D-48B3-AB81-9C744DBA13A4.svs 137750 17740 0 +/data/TCGA/5af6ee35-6515-402b-9584-89971c39137c/TCGA-ZH-A8Y1-01Z-00-DX1.2FE51BA7-9B4D-48B3-AB81-9C744DBA13A4.svs 132715 21127 1 +/data/TCGA/5af6ee35-6515-402b-9584-89971c39137c/TCGA-ZH-A8Y1-01Z-00-DX1.2FE51BA7-9B4D-48B3-AB81-9C744DBA13A4.svs 146648 6310 2 +/data/TCGA/5af6ee35-6515-402b-9584-89971c39137c/TCGA-ZH-A8Y1-01Z-00-DX1.2FE51BA7-9B4D-48B3-AB81-9C744DBA13A4.svs 57473 52783 3 +/data/TCGA/1f0d2975-1007-4a95-974c-2c4b65a7fb68/TCGA-Y6-A9XI-01Z-00-DX5.C484E378-EF4C-4F91-ACC0-53FFC48F166F.svs 63864 63083 0 +/data/TCGA/1f0d2975-1007-4a95-974c-2c4b65a7fb68/TCGA-Y6-A9XI-01Z-00-DX5.C484E378-EF4C-4F91-ACC0-53FFC48F166F.svs 51841 26227 1 +/data/TCGA/1f0d2975-1007-4a95-974c-2c4b65a7fb68/TCGA-Y6-A9XI-01Z-00-DX5.C484E378-EF4C-4F91-ACC0-53FFC48F166F.svs 65458 42060 2 +/data/TCGA/1f0d2975-1007-4a95-974c-2c4b65a7fb68/TCGA-Y6-A9XI-01Z-00-DX5.C484E378-EF4C-4F91-ACC0-53FFC48F166F.svs 55564 46893 3 +/data/TCGA/d6d105f1-955f-4c6d-9099-f1a0af7b8a74/TCGA-49-4505-01Z-00-DX1.d49d603e-1f76-43a1-a803-9f2d6a6df715.svs 43440 49618 0 +/data/TCGA/d6d105f1-955f-4c6d-9099-f1a0af7b8a74/TCGA-49-4505-01Z-00-DX1.d49d603e-1f76-43a1-a803-9f2d6a6df715.svs 9135 32305 1 +/data/TCGA/d6d105f1-955f-4c6d-9099-f1a0af7b8a74/TCGA-49-4505-01Z-00-DX1.d49d603e-1f76-43a1-a803-9f2d6a6df715.svs 31629 40096 2 +/data/TCGA/d6d105f1-955f-4c6d-9099-f1a0af7b8a74/TCGA-49-4505-01Z-00-DX1.d49d603e-1f76-43a1-a803-9f2d6a6df715.svs 565 31334 3 +/data/TCGA/787730b7-c174-4241-a8f7-abb69d971df4/TCGA-AR-A1AJ-01Z-00-DX1.34B9FCF0-74D8-4328-9B5A-698AD57EDA85.svs 81662 26169 0 +/data/TCGA/787730b7-c174-4241-a8f7-abb69d971df4/TCGA-AR-A1AJ-01Z-00-DX1.34B9FCF0-74D8-4328-9B5A-698AD57EDA85.svs 41852 13249 1 +/data/TCGA/787730b7-c174-4241-a8f7-abb69d971df4/TCGA-AR-A1AJ-01Z-00-DX1.34B9FCF0-74D8-4328-9B5A-698AD57EDA85.svs 14189 23896 2 +/data/TCGA/787730b7-c174-4241-a8f7-abb69d971df4/TCGA-AR-A1AJ-01Z-00-DX1.34B9FCF0-74D8-4328-9B5A-698AD57EDA85.svs 18432 14113 3 +/data/TCGA/1bac9786-4d56-4f08-9792-ed131b398907/TCGA-D8-A1JH-01Z-00-DX1.4A4F2502-612C-421D-9F64-444BF2C85620.svs 102701 32570 0 +/data/TCGA/1bac9786-4d56-4f08-9792-ed131b398907/TCGA-D8-A1JH-01Z-00-DX1.4A4F2502-612C-421D-9F64-444BF2C85620.svs 56956 24418 1 +/data/TCGA/1bac9786-4d56-4f08-9792-ed131b398907/TCGA-D8-A1JH-01Z-00-DX1.4A4F2502-612C-421D-9F64-444BF2C85620.svs 79907 29955 2 +/data/TCGA/1bac9786-4d56-4f08-9792-ed131b398907/TCGA-D8-A1JH-01Z-00-DX1.4A4F2502-612C-421D-9F64-444BF2C85620.svs 77023 53826 3 +/data/TCGA/30420597-aa23-4fe9-adce-9c00ea7f440d/TCGA-VQ-A8DV-01Z-00-DX1.DB668CCB-E5C9-49D8-9F0B-2548AA1C3E69.svs 59798 20802 0 +/data/TCGA/30420597-aa23-4fe9-adce-9c00ea7f440d/TCGA-VQ-A8DV-01Z-00-DX1.DB668CCB-E5C9-49D8-9F0B-2548AA1C3E69.svs 26171 42422 1 +/data/TCGA/30420597-aa23-4fe9-adce-9c00ea7f440d/TCGA-VQ-A8DV-01Z-00-DX1.DB668CCB-E5C9-49D8-9F0B-2548AA1C3E69.svs 40632 3202 2 +/data/TCGA/30420597-aa23-4fe9-adce-9c00ea7f440d/TCGA-VQ-A8DV-01Z-00-DX1.DB668CCB-E5C9-49D8-9F0B-2548AA1C3E69.svs 7134 34995 3 +/data/TCGA/ea022bca-a2ee-4200-8769-abc8eed320e7/TCGA-19-1789-01Z-00-DX1.3cfc05c7-bd43-49ed-b182-e49d4da108ec.svs 11436 4885 0 +/data/TCGA/ea022bca-a2ee-4200-8769-abc8eed320e7/TCGA-19-1789-01Z-00-DX1.3cfc05c7-bd43-49ed-b182-e49d4da108ec.svs 12575 4865 1 +/data/TCGA/ea022bca-a2ee-4200-8769-abc8eed320e7/TCGA-19-1789-01Z-00-DX1.3cfc05c7-bd43-49ed-b182-e49d4da108ec.svs 9700 4495 2 +/data/TCGA/9aa83d09-fcb9-4b78-9e1b-c2dbdf13098a/TCGA-IB-A6UF-01Z-00-DX1.B5DE2588-B9C6-4F63-8784-A5599626D605.svs 45544 87494 0 +/data/TCGA/9aa83d09-fcb9-4b78-9e1b-c2dbdf13098a/TCGA-IB-A6UF-01Z-00-DX1.B5DE2588-B9C6-4F63-8784-A5599626D605.svs 76970 69175 1 +/data/TCGA/9aa83d09-fcb9-4b78-9e1b-c2dbdf13098a/TCGA-IB-A6UF-01Z-00-DX1.B5DE2588-B9C6-4F63-8784-A5599626D605.svs 61493 13397 2 +/data/TCGA/9aa83d09-fcb9-4b78-9e1b-c2dbdf13098a/TCGA-IB-A6UF-01Z-00-DX1.B5DE2588-B9C6-4F63-8784-A5599626D605.svs 56477 81778 3 +/data/TCGA/8bf5ba9a-1e13-4aa2-a4d2-a654cf82e77c/TCGA-FM-8000-01Z-00-DX1.c8307f0d-6f7f-4f4c-bd71-4c4a3da528d4.svs 32192 6465 0 +/data/TCGA/8bf5ba9a-1e13-4aa2-a4d2-a654cf82e77c/TCGA-FM-8000-01Z-00-DX1.c8307f0d-6f7f-4f4c-bd71-4c4a3da528d4.svs 44871 8713 1 +/data/TCGA/8bf5ba9a-1e13-4aa2-a4d2-a654cf82e77c/TCGA-FM-8000-01Z-00-DX1.c8307f0d-6f7f-4f4c-bd71-4c4a3da528d4.svs 47089 9805 2 +/data/TCGA/8bf5ba9a-1e13-4aa2-a4d2-a654cf82e77c/TCGA-FM-8000-01Z-00-DX1.c8307f0d-6f7f-4f4c-bd71-4c4a3da528d4.svs 12142 5351 3 +/data/TCGA/de331004-c9af-462a-85d2-73349b9cd4c9/TCGA-OR-A5LS-01Z-00-DX1.E88B46CA-1104-46F1-998C-A9819AB3E517.svs 63978 15329 0 +/data/TCGA/de331004-c9af-462a-85d2-73349b9cd4c9/TCGA-OR-A5LS-01Z-00-DX1.E88B46CA-1104-46F1-998C-A9819AB3E517.svs 45283 48007 1 +/data/TCGA/de331004-c9af-462a-85d2-73349b9cd4c9/TCGA-OR-A5LS-01Z-00-DX1.E88B46CA-1104-46F1-998C-A9819AB3E517.svs 78252 64135 2 +/data/TCGA/de331004-c9af-462a-85d2-73349b9cd4c9/TCGA-OR-A5LS-01Z-00-DX1.E88B46CA-1104-46F1-998C-A9819AB3E517.svs 67920 10277 3 +/data/TCGA/111f155e-2330-4f38-afe1-d42838c23ad7/TCGA-B6-A2IU-01Z-00-DX1.3C7DF701-4ED9-4989-AA63-A6B7B105F6EE.svs 72198 22554 0 +/data/TCGA/111f155e-2330-4f38-afe1-d42838c23ad7/TCGA-B6-A2IU-01Z-00-DX1.3C7DF701-4ED9-4989-AA63-A6B7B105F6EE.svs 62140 70793 1 +/data/TCGA/111f155e-2330-4f38-afe1-d42838c23ad7/TCGA-B6-A2IU-01Z-00-DX1.3C7DF701-4ED9-4989-AA63-A6B7B105F6EE.svs 80475 73438 2 +/data/TCGA/111f155e-2330-4f38-afe1-d42838c23ad7/TCGA-B6-A2IU-01Z-00-DX1.3C7DF701-4ED9-4989-AA63-A6B7B105F6EE.svs 94499 15385 3 +/data/TCGA/bb68e5ff-bcbd-42e3-b615-2b0e05c88ace/TCGA-BR-4294-01Z-00-DX1.247c5447-23e3-4620-a981-19d5f572235a.svs 1339 436 0 +/data/TCGA/09333455-e8b3-4dbf-a9e9-919a925dfdf7/TCGA-14-1454-01Z-00-DX2.91c3b5b3-8640-408a-956b-7df581d85121.svs 28900 12195 0 +/data/TCGA/09333455-e8b3-4dbf-a9e9-919a925dfdf7/TCGA-14-1454-01Z-00-DX2.91c3b5b3-8640-408a-956b-7df581d85121.svs 32463 4631 1 +/data/TCGA/09333455-e8b3-4dbf-a9e9-919a925dfdf7/TCGA-14-1454-01Z-00-DX2.91c3b5b3-8640-408a-956b-7df581d85121.svs 36883 17892 2 +/data/TCGA/1a62d692-bc08-49f9-ad59-6fddf3bbcb6d/TCGA-A7-A4SF-01Z-00-DX1.CDCFD4BC-4363-4CF2-95F5-4922E04C3B9D.svs 16358 25904 0 +/data/TCGA/1a62d692-bc08-49f9-ad59-6fddf3bbcb6d/TCGA-A7-A4SF-01Z-00-DX1.CDCFD4BC-4363-4CF2-95F5-4922E04C3B9D.svs 9238 17468 1 +/data/TCGA/1a62d692-bc08-49f9-ad59-6fddf3bbcb6d/TCGA-A7-A4SF-01Z-00-DX1.CDCFD4BC-4363-4CF2-95F5-4922E04C3B9D.svs 12563 30156 2 +/data/TCGA/42cd2216-9771-4d9d-a43f-364163276b9a/TCGA-V4-A9EZ-01Z-00-DX1.90136571-87FB-4B1B-9C4B-052773C65FAE.svs 21064 62876 0 +/data/TCGA/42cd2216-9771-4d9d-a43f-364163276b9a/TCGA-V4-A9EZ-01Z-00-DX1.90136571-87FB-4B1B-9C4B-052773C65FAE.svs 45476 17649 1 +/data/TCGA/42cd2216-9771-4d9d-a43f-364163276b9a/TCGA-V4-A9EZ-01Z-00-DX1.90136571-87FB-4B1B-9C4B-052773C65FAE.svs 26588 41826 2 +/data/TCGA/42cd2216-9771-4d9d-a43f-364163276b9a/TCGA-V4-A9EZ-01Z-00-DX1.90136571-87FB-4B1B-9C4B-052773C65FAE.svs 81065 18100 3 +/data/TCGA/0bd7ca22-a281-427c-a5ef-b59b5dd02da3/TCGA-BH-A0DE-01Z-00-DX1.64A0340A-8146-48E8-AAF7-4035988B9152.svs 7783 41514 0 +/data/TCGA/0bd7ca22-a281-427c-a5ef-b59b5dd02da3/TCGA-BH-A0DE-01Z-00-DX1.64A0340A-8146-48E8-AAF7-4035988B9152.svs 28190 32649 1 +/data/TCGA/0bd7ca22-a281-427c-a5ef-b59b5dd02da3/TCGA-BH-A0DE-01Z-00-DX1.64A0340A-8146-48E8-AAF7-4035988B9152.svs 49905 50796 2 +/data/TCGA/0bd7ca22-a281-427c-a5ef-b59b5dd02da3/TCGA-BH-A0DE-01Z-00-DX1.64A0340A-8146-48E8-AAF7-4035988B9152.svs 49236 8595 3 +/data/TCGA/2b735fe8-e3d5-4024-ab66-735bd55abc23/TCGA-27-1836-01Z-00-DX3.70ad0337-b205-4bd7-8a42-e8bb93bb589f.svs 8415 17525 0 +/data/TCGA/2b735fe8-e3d5-4024-ab66-735bd55abc23/TCGA-27-1836-01Z-00-DX3.70ad0337-b205-4bd7-8a42-e8bb93bb589f.svs 12453 36182 1 +/data/TCGA/2b735fe8-e3d5-4024-ab66-735bd55abc23/TCGA-27-1836-01Z-00-DX3.70ad0337-b205-4bd7-8a42-e8bb93bb589f.svs 27768 25941 2 +/data/TCGA/c74344f2-fb3a-47ee-8af7-95684f6a92d8/TCGA-06-0211-01Z-00-DX1.9c0772e4-c956-4f0a-bfc2-dc03640167a9.svs 10605 14952 0 +/data/TCGA/c74344f2-fb3a-47ee-8af7-95684f6a92d8/TCGA-06-0211-01Z-00-DX1.9c0772e4-c956-4f0a-bfc2-dc03640167a9.svs 14614 13183 1 +/data/TCGA/c74344f2-fb3a-47ee-8af7-95684f6a92d8/TCGA-06-0211-01Z-00-DX1.9c0772e4-c956-4f0a-bfc2-dc03640167a9.svs 10941 13171 2 +/data/TCGA/71e15437-c246-4f50-aecc-2ac3767414a6/TCGA-27-1836-01Z-00-DX2.85cffd50-6080-4254-ae41-c1c74391a6a8.svs 41808 9951 0 +/data/TCGA/71e15437-c246-4f50-aecc-2ac3767414a6/TCGA-27-1836-01Z-00-DX2.85cffd50-6080-4254-ae41-c1c74391a6a8.svs 37152 35949 1 +/data/TCGA/71e15437-c246-4f50-aecc-2ac3767414a6/TCGA-27-1836-01Z-00-DX2.85cffd50-6080-4254-ae41-c1c74391a6a8.svs 39916 5956 2 +/data/TCGA/b0e7ce5b-5de6-4b13-ae75-5a0360d044de/TCGA-EW-A1IZ-01Z-00-DX1.81D5544E-0A7D-4A92-A3B0-4F22CFB8BBB2.svs 17326 41988 0 +/data/TCGA/b0e7ce5b-5de6-4b13-ae75-5a0360d044de/TCGA-EW-A1IZ-01Z-00-DX1.81D5544E-0A7D-4A92-A3B0-4F22CFB8BBB2.svs 56997 12156 1 +/data/TCGA/b0e7ce5b-5de6-4b13-ae75-5a0360d044de/TCGA-EW-A1IZ-01Z-00-DX1.81D5544E-0A7D-4A92-A3B0-4F22CFB8BBB2.svs 69597 43530 2 +/data/TCGA/b0e7ce5b-5de6-4b13-ae75-5a0360d044de/TCGA-EW-A1IZ-01Z-00-DX1.81D5544E-0A7D-4A92-A3B0-4F22CFB8BBB2.svs 72639 17083 3 +/data/TCGA/b8356b56-8b39-493e-85d9-be3a93dc8e68/TCGA-X4-A8KQ-01Z-00-DX2.16F2F3D2-7673-40E0-9AE7-4C77403819EB.svs 115760 35465 0 +/data/TCGA/b8356b56-8b39-493e-85d9-be3a93dc8e68/TCGA-X4-A8KQ-01Z-00-DX2.16F2F3D2-7673-40E0-9AE7-4C77403819EB.svs 33870 42262 1 +/data/TCGA/b8356b56-8b39-493e-85d9-be3a93dc8e68/TCGA-X4-A8KQ-01Z-00-DX2.16F2F3D2-7673-40E0-9AE7-4C77403819EB.svs 49583 52800 2 +/data/TCGA/b8356b56-8b39-493e-85d9-be3a93dc8e68/TCGA-X4-A8KQ-01Z-00-DX2.16F2F3D2-7673-40E0-9AE7-4C77403819EB.svs 46467 21532 3 +/data/TCGA/53bcf09c-bff4-47e2-97e1-56a9c189e27a/TCGA-DJ-A2PR-01Z-00-DX1.CE0FA852-C086-421C-A19A-BAF52A25E8DD.svs 131980 37261 0 +/data/TCGA/53bcf09c-bff4-47e2-97e1-56a9c189e27a/TCGA-DJ-A2PR-01Z-00-DX1.CE0FA852-C086-421C-A19A-BAF52A25E8DD.svs 119906 78708 1 +/data/TCGA/53bcf09c-bff4-47e2-97e1-56a9c189e27a/TCGA-DJ-A2PR-01Z-00-DX1.CE0FA852-C086-421C-A19A-BAF52A25E8DD.svs 123560 82275 2 +/data/TCGA/53bcf09c-bff4-47e2-97e1-56a9c189e27a/TCGA-DJ-A2PR-01Z-00-DX1.CE0FA852-C086-421C-A19A-BAF52A25E8DD.svs 43093 37679 3 +/data/TCGA/81de33ce-7b9e-409d-85dc-4307fd5c8322/TCGA-FR-A7U9-01Z-00-DX1.7835C72B-C5CB-4EBB-BA41-EF1B6E40E131.svs 109074 41752 0 +/data/TCGA/81de33ce-7b9e-409d-85dc-4307fd5c8322/TCGA-FR-A7U9-01Z-00-DX1.7835C72B-C5CB-4EBB-BA41-EF1B6E40E131.svs 95976 38730 1 +/data/TCGA/81de33ce-7b9e-409d-85dc-4307fd5c8322/TCGA-FR-A7U9-01Z-00-DX1.7835C72B-C5CB-4EBB-BA41-EF1B6E40E131.svs 94400 13758 2 +/data/TCGA/81de33ce-7b9e-409d-85dc-4307fd5c8322/TCGA-FR-A7U9-01Z-00-DX1.7835C72B-C5CB-4EBB-BA41-EF1B6E40E131.svs 28986 29430 3 +/data/TCGA/78146586-f569-43e2-9fb7-bc49a2d80a57/TCGA-EE-A29W-01Z-00-DX1.5C3B9CDC-43EB-4E9E-85D2-7B83BE7AB6F0.svs 59474 47867 0 +/data/TCGA/78146586-f569-43e2-9fb7-bc49a2d80a57/TCGA-EE-A29W-01Z-00-DX1.5C3B9CDC-43EB-4E9E-85D2-7B83BE7AB6F0.svs 60185 5001 1 +/data/TCGA/78146586-f569-43e2-9fb7-bc49a2d80a57/TCGA-EE-A29W-01Z-00-DX1.5C3B9CDC-43EB-4E9E-85D2-7B83BE7AB6F0.svs 52294 44194 2 +/data/TCGA/78146586-f569-43e2-9fb7-bc49a2d80a57/TCGA-EE-A29W-01Z-00-DX1.5C3B9CDC-43EB-4E9E-85D2-7B83BE7AB6F0.svs 52109 7966 3 +/data/TCGA/817a653b-f4bc-4839-a93f-e1ce19bd3e8d/TCGA-56-8622-01Z-00-DX1.62B552C4-5CBE-4469-8DBB-E27497FF95F4.svs 9746 7561 0 +/data/TCGA/817a653b-f4bc-4839-a93f-e1ce19bd3e8d/TCGA-56-8622-01Z-00-DX1.62B552C4-5CBE-4469-8DBB-E27497FF95F4.svs 29776 44115 1 +/data/TCGA/817a653b-f4bc-4839-a93f-e1ce19bd3e8d/TCGA-56-8622-01Z-00-DX1.62B552C4-5CBE-4469-8DBB-E27497FF95F4.svs 18586 8809 2 +/data/TCGA/817a653b-f4bc-4839-a93f-e1ce19bd3e8d/TCGA-56-8622-01Z-00-DX1.62B552C4-5CBE-4469-8DBB-E27497FF95F4.svs 13877 7220 3 +/data/TCGA/37b876df-e1a7-439c-abc8-a766d1a9695f/TCGA-02-0446-01Z-00-DX1.95c368f8-b014-4c87-b93d-d792d876a0e9.svs 12230 13929 0 +/data/TCGA/37b876df-e1a7-439c-abc8-a766d1a9695f/TCGA-02-0446-01Z-00-DX1.95c368f8-b014-4c87-b93d-d792d876a0e9.svs 38890 22037 1 +/data/TCGA/37b876df-e1a7-439c-abc8-a766d1a9695f/TCGA-02-0446-01Z-00-DX1.95c368f8-b014-4c87-b93d-d792d876a0e9.svs 22987 28256 2 +/data/TCGA/dbaec6ca-e2b3-4ab4-ab1e-5879d656a09f/TCGA-69-7763-01Z-00-DX1.33203e8a-43e9-4e3e-98ba-1ac08b80a44f.svs 77131 38476 0 +/data/TCGA/dbaec6ca-e2b3-4ab4-ab1e-5879d656a09f/TCGA-69-7763-01Z-00-DX1.33203e8a-43e9-4e3e-98ba-1ac08b80a44f.svs 12002 21371 1 +/data/TCGA/dbaec6ca-e2b3-4ab4-ab1e-5879d656a09f/TCGA-69-7763-01Z-00-DX1.33203e8a-43e9-4e3e-98ba-1ac08b80a44f.svs 23077 21627 2 +/data/TCGA/dbaec6ca-e2b3-4ab4-ab1e-5879d656a09f/TCGA-69-7763-01Z-00-DX1.33203e8a-43e9-4e3e-98ba-1ac08b80a44f.svs 61132 22649 3 +/data/TCGA/83a002c5-bbac-4d56-b1c3-4f58beaa624a/TCGA-E3-A3DY-01Z-00-DX1.5FFB8A1E-3AC8-494D-8112-5F1FBDC3F597.svs 64345 24352 0 +/data/TCGA/83a002c5-bbac-4d56-b1c3-4f58beaa624a/TCGA-E3-A3DY-01Z-00-DX1.5FFB8A1E-3AC8-494D-8112-5F1FBDC3F597.svs 57303 68446 1 +/data/TCGA/83a002c5-bbac-4d56-b1c3-4f58beaa624a/TCGA-E3-A3DY-01Z-00-DX1.5FFB8A1E-3AC8-494D-8112-5F1FBDC3F597.svs 26269 34493 2 +/data/TCGA/83a002c5-bbac-4d56-b1c3-4f58beaa624a/TCGA-E3-A3DY-01Z-00-DX1.5FFB8A1E-3AC8-494D-8112-5F1FBDC3F597.svs 5016 6935 3 +/data/TCGA/d4676c59-a957-460b-8aa8-aec44409536d/TCGA-XF-A9SX-01Z-00-DX1.6DB4572E-915C-491F-BE68-99C019799E20.svs 70776 21307 0 +/data/TCGA/d4676c59-a957-460b-8aa8-aec44409536d/TCGA-XF-A9SX-01Z-00-DX1.6DB4572E-915C-491F-BE68-99C019799E20.svs 56184 33768 1 +/data/TCGA/d4676c59-a957-460b-8aa8-aec44409536d/TCGA-XF-A9SX-01Z-00-DX1.6DB4572E-915C-491F-BE68-99C019799E20.svs 16355 37876 2 +/data/TCGA/d4676c59-a957-460b-8aa8-aec44409536d/TCGA-XF-A9SX-01Z-00-DX1.6DB4572E-915C-491F-BE68-99C019799E20.svs 61048 17045 3 +/data/TCGA/039371b9-2d73-4eaa-bf51-9958c41aa177/TCGA-ZF-AA5P-01Z-00-DX1.B91697A2-A186-4E67-A818-56271D2009A9.svs 74605 62535 0 +/data/TCGA/039371b9-2d73-4eaa-bf51-9958c41aa177/TCGA-ZF-AA5P-01Z-00-DX1.B91697A2-A186-4E67-A818-56271D2009A9.svs 28340 50106 1 +/data/TCGA/039371b9-2d73-4eaa-bf51-9958c41aa177/TCGA-ZF-AA5P-01Z-00-DX1.B91697A2-A186-4E67-A818-56271D2009A9.svs 97918 32502 2 +/data/TCGA/039371b9-2d73-4eaa-bf51-9958c41aa177/TCGA-ZF-AA5P-01Z-00-DX1.B91697A2-A186-4E67-A818-56271D2009A9.svs 103267 18584 3 +/data/TCGA/4cc4455b-5887-45cc-a2a5-3a80a7d95ff6/TCGA-FG-8186-01Z-00-DX1.61031186-ca17-4c25-b7e8-b9a3f99a8242.svs 77363 29196 0 +/data/TCGA/4cc4455b-5887-45cc-a2a5-3a80a7d95ff6/TCGA-FG-8186-01Z-00-DX1.61031186-ca17-4c25-b7e8-b9a3f99a8242.svs 50040 21452 1 +/data/TCGA/4cc4455b-5887-45cc-a2a5-3a80a7d95ff6/TCGA-FG-8186-01Z-00-DX1.61031186-ca17-4c25-b7e8-b9a3f99a8242.svs 61264 13622 2 +/data/TCGA/4cc4455b-5887-45cc-a2a5-3a80a7d95ff6/TCGA-FG-8186-01Z-00-DX1.61031186-ca17-4c25-b7e8-b9a3f99a8242.svs 7982 49917 3 +/data/TCGA/93a0d268-ae57-4542-b494-03f7c7806e02/TCGA-A5-A0GB-01Z-00-DX1.5B2568B9-F9D6-41AC-A5E9-695A3E7BA751.svs 17058 46142 0 +/data/TCGA/93a0d268-ae57-4542-b494-03f7c7806e02/TCGA-A5-A0GB-01Z-00-DX1.5B2568B9-F9D6-41AC-A5E9-695A3E7BA751.svs 55256 19412 1 +/data/TCGA/93a0d268-ae57-4542-b494-03f7c7806e02/TCGA-A5-A0GB-01Z-00-DX1.5B2568B9-F9D6-41AC-A5E9-695A3E7BA751.svs 69015 24653 2 +/data/TCGA/93a0d268-ae57-4542-b494-03f7c7806e02/TCGA-A5-A0GB-01Z-00-DX1.5B2568B9-F9D6-41AC-A5E9-695A3E7BA751.svs 47564 16019 3 +/data/TCGA/9cdff1f4-7124-4870-b748-fa97601122f2/TCGA-AO-A0JL-01Z-00-DX1.473CC200-221A-4777-B19E-ADC41D10FC94.svs 36364 24023 0 +/data/TCGA/9cdff1f4-7124-4870-b748-fa97601122f2/TCGA-AO-A0JL-01Z-00-DX1.473CC200-221A-4777-B19E-ADC41D10FC94.svs 24996 31519 1 +/data/TCGA/9cdff1f4-7124-4870-b748-fa97601122f2/TCGA-AO-A0JL-01Z-00-DX1.473CC200-221A-4777-B19E-ADC41D10FC94.svs 46984 15623 2 +/data/TCGA/653dc0a3-a5d2-4769-8b1d-acdc358d970c/TCGA-UZ-A9PS-01Z-00-DX1.3CAF5087-CDAB-42B5-BE7C-3D5643AEAA6D.svs 65318 40520 0 +/data/TCGA/653dc0a3-a5d2-4769-8b1d-acdc358d970c/TCGA-UZ-A9PS-01Z-00-DX1.3CAF5087-CDAB-42B5-BE7C-3D5643AEAA6D.svs 22419 44731 1 +/data/TCGA/653dc0a3-a5d2-4769-8b1d-acdc358d970c/TCGA-UZ-A9PS-01Z-00-DX1.3CAF5087-CDAB-42B5-BE7C-3D5643AEAA6D.svs 39391 39414 2 +/data/TCGA/653dc0a3-a5d2-4769-8b1d-acdc358d970c/TCGA-UZ-A9PS-01Z-00-DX1.3CAF5087-CDAB-42B5-BE7C-3D5643AEAA6D.svs 41850 36692 3 +/data/TCGA/0cddd561-4a47-403e-8158-85949929cf68/TCGA-P3-A6T6-01Z-00-DX1.4873798C-A2AD-40D5-B5B3-FCF75735C4F3.svs 89319 27161 0 +/data/TCGA/0cddd561-4a47-403e-8158-85949929cf68/TCGA-P3-A6T6-01Z-00-DX1.4873798C-A2AD-40D5-B5B3-FCF75735C4F3.svs 62418 22063 1 +/data/TCGA/0cddd561-4a47-403e-8158-85949929cf68/TCGA-P3-A6T6-01Z-00-DX1.4873798C-A2AD-40D5-B5B3-FCF75735C4F3.svs 114848 36910 2 +/data/TCGA/0cddd561-4a47-403e-8158-85949929cf68/TCGA-P3-A6T6-01Z-00-DX1.4873798C-A2AD-40D5-B5B3-FCF75735C4F3.svs 94544 15333 3 +/data/TCGA/3e581180-e0e7-4a6d-a96c-81be39f66886/TCGA-GN-A268-06Z-00-DX1.07874075-CD90-4E27-B5AA-D27741047B7B.svs 42389 8104 0 +/data/TCGA/3e581180-e0e7-4a6d-a96c-81be39f66886/TCGA-GN-A268-06Z-00-DX1.07874075-CD90-4E27-B5AA-D27741047B7B.svs 25793 58544 1 +/data/TCGA/3e581180-e0e7-4a6d-a96c-81be39f66886/TCGA-GN-A268-06Z-00-DX1.07874075-CD90-4E27-B5AA-D27741047B7B.svs 24476 26234 2 +/data/TCGA/3e581180-e0e7-4a6d-a96c-81be39f66886/TCGA-GN-A268-06Z-00-DX1.07874075-CD90-4E27-B5AA-D27741047B7B.svs 75512 49182 3 +/data/TCGA/1c08a812-1066-4b50-b27e-689e3d640c02/TCGA-BC-A10T-01Z-00-DX1.2F634D24-C571-49E1-ACAE-B19F8AFF71D3.svs 96846 39855 0 +/data/TCGA/1c08a812-1066-4b50-b27e-689e3d640c02/TCGA-BC-A10T-01Z-00-DX1.2F634D24-C571-49E1-ACAE-B19F8AFF71D3.svs 123730 26759 1 +/data/TCGA/1c08a812-1066-4b50-b27e-689e3d640c02/TCGA-BC-A10T-01Z-00-DX1.2F634D24-C571-49E1-ACAE-B19F8AFF71D3.svs 114605 20048 2 +/data/TCGA/1c08a812-1066-4b50-b27e-689e3d640c02/TCGA-BC-A10T-01Z-00-DX1.2F634D24-C571-49E1-ACAE-B19F8AFF71D3.svs 4240 65770 3 +/data/TCGA/22fddedb-f726-4c11-9ce7-080be5658746/TCGA-D8-A27I-01Z-00-DX1.ACAE0048-7AF0-41C9-992B-6ACDABF80B1C.svs 30345 39004 0 +/data/TCGA/22fddedb-f726-4c11-9ce7-080be5658746/TCGA-D8-A27I-01Z-00-DX1.ACAE0048-7AF0-41C9-992B-6ACDABF80B1C.svs 51374 15852 1 +/data/TCGA/22fddedb-f726-4c11-9ce7-080be5658746/TCGA-D8-A27I-01Z-00-DX1.ACAE0048-7AF0-41C9-992B-6ACDABF80B1C.svs 17883 25546 2 +/data/TCGA/22fddedb-f726-4c11-9ce7-080be5658746/TCGA-D8-A27I-01Z-00-DX1.ACAE0048-7AF0-41C9-992B-6ACDABF80B1C.svs 50947 14367 3 +/data/TCGA/d60a9bb5-d575-40f5-87e4-e0788508537d/TCGA-G7-6790-01Z-00-DX1.273810f2-dee2-4dc9-a8bd-9cbbacd8af3a.svs 64835 28897 0 +/data/TCGA/d60a9bb5-d575-40f5-87e4-e0788508537d/TCGA-G7-6790-01Z-00-DX1.273810f2-dee2-4dc9-a8bd-9cbbacd8af3a.svs 74090 65590 1 +/data/TCGA/d60a9bb5-d575-40f5-87e4-e0788508537d/TCGA-G7-6790-01Z-00-DX1.273810f2-dee2-4dc9-a8bd-9cbbacd8af3a.svs 112770 32174 2 +/data/TCGA/d60a9bb5-d575-40f5-87e4-e0788508537d/TCGA-G7-6790-01Z-00-DX1.273810f2-dee2-4dc9-a8bd-9cbbacd8af3a.svs 59794 44046 3 +/data/TCGA/0d3ec8d4-a8c1-4026-bb88-d94c2a2e4bda/TCGA-CQ-6229-01Z-00-DX1.25c345cc-47e9-4a9f-8402-9ecf7c6b881e.svs 58471 48159 0 +/data/TCGA/0d3ec8d4-a8c1-4026-bb88-d94c2a2e4bda/TCGA-CQ-6229-01Z-00-DX1.25c345cc-47e9-4a9f-8402-9ecf7c6b881e.svs 86269 18947 1 +/data/TCGA/0d3ec8d4-a8c1-4026-bb88-d94c2a2e4bda/TCGA-CQ-6229-01Z-00-DX1.25c345cc-47e9-4a9f-8402-9ecf7c6b881e.svs 29568 29324 2 +/data/TCGA/0d3ec8d4-a8c1-4026-bb88-d94c2a2e4bda/TCGA-CQ-6229-01Z-00-DX1.25c345cc-47e9-4a9f-8402-9ecf7c6b881e.svs 84433 50642 3 +/data/TCGA/ae590619-7b4f-41d2-a56f-2837d91d6403/TCGA-ZB-A96C-01Z-00-DX1.2801BC53-31A4-4CF3-B698-F4C87ACC7C52.svs 32777 26547 0 +/data/TCGA/ae590619-7b4f-41d2-a56f-2837d91d6403/TCGA-ZB-A96C-01Z-00-DX1.2801BC53-31A4-4CF3-B698-F4C87ACC7C52.svs 36948 48515 1 +/data/TCGA/ae590619-7b4f-41d2-a56f-2837d91d6403/TCGA-ZB-A96C-01Z-00-DX1.2801BC53-31A4-4CF3-B698-F4C87ACC7C52.svs 36947 13420 2 +/data/TCGA/ae590619-7b4f-41d2-a56f-2837d91d6403/TCGA-ZB-A96C-01Z-00-DX1.2801BC53-31A4-4CF3-B698-F4C87ACC7C52.svs 28921 20417 3 +/data/TCGA/edf4dd44-d920-49a2-9b43-261baad3f7ba/TCGA-DD-A4NJ-01Z-00-DX1.93D04C1F-3035-4817-9123-5D3523027D4B.svs 41329 25456 0 +/data/TCGA/edf4dd44-d920-49a2-9b43-261baad3f7ba/TCGA-DD-A4NJ-01Z-00-DX1.93D04C1F-3035-4817-9123-5D3523027D4B.svs 42238 25314 1 +/data/TCGA/edf4dd44-d920-49a2-9b43-261baad3f7ba/TCGA-DD-A4NJ-01Z-00-DX1.93D04C1F-3035-4817-9123-5D3523027D4B.svs 49118 18563 2 +/data/TCGA/edf4dd44-d920-49a2-9b43-261baad3f7ba/TCGA-DD-A4NJ-01Z-00-DX1.93D04C1F-3035-4817-9123-5D3523027D4B.svs 78705 51338 3 +/data/TCGA/85634d67-085a-47f1-8f24-bfdd596ba39b/TCGA-ET-A3BO-01Z-00-DX1.4A864B23-7323-4009-BF35-34E3BA399138.svs 21655 81120 0 +/data/TCGA/85634d67-085a-47f1-8f24-bfdd596ba39b/TCGA-ET-A3BO-01Z-00-DX1.4A864B23-7323-4009-BF35-34E3BA399138.svs 55600 69635 1 +/data/TCGA/85634d67-085a-47f1-8f24-bfdd596ba39b/TCGA-ET-A3BO-01Z-00-DX1.4A864B23-7323-4009-BF35-34E3BA399138.svs 36469 61457 2 +/data/TCGA/85634d67-085a-47f1-8f24-bfdd596ba39b/TCGA-ET-A3BO-01Z-00-DX1.4A864B23-7323-4009-BF35-34E3BA399138.svs 96033 55117 3 +/data/TCGA/8e74e6b6-dda4-47a1-b57a-ff5621f8aecd/TCGA-OR-A5JF-01Z-00-DX1.54347E29-F3B6-40EC-BB1B-6136C46E0455.svs 67490 45275 0 +/data/TCGA/8e74e6b6-dda4-47a1-b57a-ff5621f8aecd/TCGA-OR-A5JF-01Z-00-DX1.54347E29-F3B6-40EC-BB1B-6136C46E0455.svs 33665 18959 1 +/data/TCGA/8e74e6b6-dda4-47a1-b57a-ff5621f8aecd/TCGA-OR-A5JF-01Z-00-DX1.54347E29-F3B6-40EC-BB1B-6136C46E0455.svs 32200 71684 2 +/data/TCGA/8e74e6b6-dda4-47a1-b57a-ff5621f8aecd/TCGA-OR-A5JF-01Z-00-DX1.54347E29-F3B6-40EC-BB1B-6136C46E0455.svs 31287 41221 3 +/data/TCGA/fec83654-31b6-41e8-9ee2-061e84b90ca2/TCGA-SR-A6MP-01Z-00-DX1.A15F7FB1-E1AA-459E-BB06-DFDAE6F56B05.svs 8051 49319 0 +/data/TCGA/fec83654-31b6-41e8-9ee2-061e84b90ca2/TCGA-SR-A6MP-01Z-00-DX1.A15F7FB1-E1AA-459E-BB06-DFDAE6F56B05.svs 113206 41492 1 +/data/TCGA/fec83654-31b6-41e8-9ee2-061e84b90ca2/TCGA-SR-A6MP-01Z-00-DX1.A15F7FB1-E1AA-459E-BB06-DFDAE6F56B05.svs 92924 37342 2 +/data/TCGA/fec83654-31b6-41e8-9ee2-061e84b90ca2/TCGA-SR-A6MP-01Z-00-DX1.A15F7FB1-E1AA-459E-BB06-DFDAE6F56B05.svs 79338 9456 3 +/data/TCGA/112437a0-59f1-4855-b58a-ad73f574ea0a/TCGA-3A-A9IV-01Z-00-DX1.82C7069A-3B92-47AF-9522-904F1112141F.svs 57758 36453 0 +/data/TCGA/112437a0-59f1-4855-b58a-ad73f574ea0a/TCGA-3A-A9IV-01Z-00-DX1.82C7069A-3B92-47AF-9522-904F1112141F.svs 10764 27326 1 +/data/TCGA/112437a0-59f1-4855-b58a-ad73f574ea0a/TCGA-3A-A9IV-01Z-00-DX1.82C7069A-3B92-47AF-9522-904F1112141F.svs 61869 20827 2 +/data/TCGA/112437a0-59f1-4855-b58a-ad73f574ea0a/TCGA-3A-A9IV-01Z-00-DX1.82C7069A-3B92-47AF-9522-904F1112141F.svs 37330 8620 3 +/data/TCGA/bd939408-7751-4647-81c1-15e7070761bf/TCGA-FG-5964-01Z-00-DX1.971827c7-4e41-4b8c-af02-01b340cf4cbd.svs 35804 18629 0 +/data/TCGA/bd939408-7751-4647-81c1-15e7070761bf/TCGA-FG-5964-01Z-00-DX1.971827c7-4e41-4b8c-af02-01b340cf4cbd.svs 18875 25778 1 +/data/TCGA/bd939408-7751-4647-81c1-15e7070761bf/TCGA-FG-5964-01Z-00-DX1.971827c7-4e41-4b8c-af02-01b340cf4cbd.svs 15360 31022 2 +/data/TCGA/bd939408-7751-4647-81c1-15e7070761bf/TCGA-FG-5964-01Z-00-DX1.971827c7-4e41-4b8c-af02-01b340cf4cbd.svs 2444 36584 3 +/data/TCGA/1338b0ae-8ad5-4fc5-8de0-233b73e8c771/TCGA-B0-5694-01Z-00-DX1.d33b7c17-1d59-467f-9f33-47158ab5bdf7.svs 82613 66068 0 +/data/TCGA/1338b0ae-8ad5-4fc5-8de0-233b73e8c771/TCGA-B0-5694-01Z-00-DX1.d33b7c17-1d59-467f-9f33-47158ab5bdf7.svs 49898 42945 1 +/data/TCGA/1338b0ae-8ad5-4fc5-8de0-233b73e8c771/TCGA-B0-5694-01Z-00-DX1.d33b7c17-1d59-467f-9f33-47158ab5bdf7.svs 43575 71557 2 +/data/TCGA/1338b0ae-8ad5-4fc5-8de0-233b73e8c771/TCGA-B0-5694-01Z-00-DX1.d33b7c17-1d59-467f-9f33-47158ab5bdf7.svs 25732 46439 3 +/data/TCGA/268825dc-c18c-48eb-9d22-734bc8ed3ac6/TCGA-BG-A0MO-01Z-00-DX1.11F48BAE-82F9-4E24-BF57-8C6A4B05E626.svs 54502 81772 0 +/data/TCGA/268825dc-c18c-48eb-9d22-734bc8ed3ac6/TCGA-BG-A0MO-01Z-00-DX1.11F48BAE-82F9-4E24-BF57-8C6A4B05E626.svs 58113 78117 1 +/data/TCGA/268825dc-c18c-48eb-9d22-734bc8ed3ac6/TCGA-BG-A0MO-01Z-00-DX1.11F48BAE-82F9-4E24-BF57-8C6A4B05E626.svs 85631 38112 2 +/data/TCGA/268825dc-c18c-48eb-9d22-734bc8ed3ac6/TCGA-BG-A0MO-01Z-00-DX1.11F48BAE-82F9-4E24-BF57-8C6A4B05E626.svs 25513 53126 3 +/data/TCGA/6853c29f-247f-4f76-8ab4-34d236854f5a/TCGA-43-A56U-01Z-00-DX1.B60C921A-4EE4-4CAE-9E55-311C7D2DA9E4.svs 64902 9067 0 +/data/TCGA/6853c29f-247f-4f76-8ab4-34d236854f5a/TCGA-43-A56U-01Z-00-DX1.B60C921A-4EE4-4CAE-9E55-311C7D2DA9E4.svs 62925 9788 1 +/data/TCGA/6853c29f-247f-4f76-8ab4-34d236854f5a/TCGA-43-A56U-01Z-00-DX1.B60C921A-4EE4-4CAE-9E55-311C7D2DA9E4.svs 59232 6229 2 +/data/TCGA/6853c29f-247f-4f76-8ab4-34d236854f5a/TCGA-43-A56U-01Z-00-DX1.B60C921A-4EE4-4CAE-9E55-311C7D2DA9E4.svs 55723 9663 3 +/data/TCGA/f70c92b0-76b8-4eb0-8918-a4a0dc911ca3/TCGA-06-1086-01Z-00-DX1.d8749609-d55c-4b29-b489-34f93c6c8e27.svs 45552 15194 0 +/data/TCGA/f70c92b0-76b8-4eb0-8918-a4a0dc911ca3/TCGA-06-1086-01Z-00-DX1.d8749609-d55c-4b29-b489-34f93c6c8e27.svs 34048 9054 1 +/data/TCGA/f70c92b0-76b8-4eb0-8918-a4a0dc911ca3/TCGA-06-1086-01Z-00-DX1.d8749609-d55c-4b29-b489-34f93c6c8e27.svs 5459 11630 2 +/data/TCGA/4a75e17f-7563-446f-a04e-bc64180799a4/TCGA-L5-A4OR-01Z-00-DX1.28601695-B5D5-4F93-8336-F378B1E4377C.svs 26643 35243 0 +/data/TCGA/4a75e17f-7563-446f-a04e-bc64180799a4/TCGA-L5-A4OR-01Z-00-DX1.28601695-B5D5-4F93-8336-F378B1E4377C.svs 28120 48884 1 +/data/TCGA/4a75e17f-7563-446f-a04e-bc64180799a4/TCGA-L5-A4OR-01Z-00-DX1.28601695-B5D5-4F93-8336-F378B1E4377C.svs 90421 66025 2 +/data/TCGA/4a75e17f-7563-446f-a04e-bc64180799a4/TCGA-L5-A4OR-01Z-00-DX1.28601695-B5D5-4F93-8336-F378B1E4377C.svs 87889 66562 3 +/data/TCGA/e941163f-e3b1-4135-b0be-19f80b49ca76/TCGA-26-6173-01Z-00-DX1.A612A5EC-A048-4A8F-AE2D-5A07C8B030D1.svs 108111 33790 0 +/data/TCGA/e941163f-e3b1-4135-b0be-19f80b49ca76/TCGA-26-6173-01Z-00-DX1.A612A5EC-A048-4A8F-AE2D-5A07C8B030D1.svs 41941 37440 1 +/data/TCGA/e941163f-e3b1-4135-b0be-19f80b49ca76/TCGA-26-6173-01Z-00-DX1.A612A5EC-A048-4A8F-AE2D-5A07C8B030D1.svs 37658 41478 2 +/data/TCGA/e941163f-e3b1-4135-b0be-19f80b49ca76/TCGA-26-6173-01Z-00-DX1.A612A5EC-A048-4A8F-AE2D-5A07C8B030D1.svs 61134 20419 3 +/data/TCGA/077768ac-35e9-41c8-82b7-7e822ba89521/TCGA-KK-A6E8-01Z-00-DX1.5A8673FF-44A5-4383-86E8-A830205C99C7.svs 73338 65043 0 +/data/TCGA/077768ac-35e9-41c8-82b7-7e822ba89521/TCGA-KK-A6E8-01Z-00-DX1.5A8673FF-44A5-4383-86E8-A830205C99C7.svs 58621 61066 1 +/data/TCGA/077768ac-35e9-41c8-82b7-7e822ba89521/TCGA-KK-A6E8-01Z-00-DX1.5A8673FF-44A5-4383-86E8-A830205C99C7.svs 64991 26743 2 +/data/TCGA/077768ac-35e9-41c8-82b7-7e822ba89521/TCGA-KK-A6E8-01Z-00-DX1.5A8673FF-44A5-4383-86E8-A830205C99C7.svs 23926 35746 3 +/data/TCGA/acc9e18a-0cdb-4f6e-9ae3-4c5673fd1658/TCGA-CF-A5UA-01Z-00-DX1.7352D4EB-46F5-4EAA-95B9-1D869E8291C3.svs 7897 29646 0 +/data/TCGA/acc9e18a-0cdb-4f6e-9ae3-4c5673fd1658/TCGA-CF-A5UA-01Z-00-DX1.7352D4EB-46F5-4EAA-95B9-1D869E8291C3.svs 24361 48198 1 +/data/TCGA/acc9e18a-0cdb-4f6e-9ae3-4c5673fd1658/TCGA-CF-A5UA-01Z-00-DX1.7352D4EB-46F5-4EAA-95B9-1D869E8291C3.svs 53688 28562 2 +/data/TCGA/acc9e18a-0cdb-4f6e-9ae3-4c5673fd1658/TCGA-CF-A5UA-01Z-00-DX1.7352D4EB-46F5-4EAA-95B9-1D869E8291C3.svs 27893 9590 3 +/data/TCGA/dc1031ce-cc00-4ac9-a877-acb4ee297ef0/TCGA-A7-A6VV-01Z-00-DX2.4C2BF8C1-CC84-4A6E-BC0F-430BC8BE6B26.svs 81404 67819 0 +/data/TCGA/dc1031ce-cc00-4ac9-a877-acb4ee297ef0/TCGA-A7-A6VV-01Z-00-DX2.4C2BF8C1-CC84-4A6E-BC0F-430BC8BE6B26.svs 80510 70309 1 +/data/TCGA/dc1031ce-cc00-4ac9-a877-acb4ee297ef0/TCGA-A7-A6VV-01Z-00-DX2.4C2BF8C1-CC84-4A6E-BC0F-430BC8BE6B26.svs 54627 58843 2 +/data/TCGA/dc1031ce-cc00-4ac9-a877-acb4ee297ef0/TCGA-A7-A6VV-01Z-00-DX2.4C2BF8C1-CC84-4A6E-BC0F-430BC8BE6B26.svs 72607 65794 3 +/data/TCGA/1130ace8-92b2-40d9-8d39-16ed58f7758f/TCGA-BR-8286-01Z-00-DX1.4e8edc91-41c1-4b40-89b5-6f09636e4a3f.svs 43311 63394 0 +/data/TCGA/1130ace8-92b2-40d9-8d39-16ed58f7758f/TCGA-BR-8286-01Z-00-DX1.4e8edc91-41c1-4b40-89b5-6f09636e4a3f.svs 72381 34089 1 +/data/TCGA/1130ace8-92b2-40d9-8d39-16ed58f7758f/TCGA-BR-8286-01Z-00-DX1.4e8edc91-41c1-4b40-89b5-6f09636e4a3f.svs 57403 21155 2 +/data/TCGA/1130ace8-92b2-40d9-8d39-16ed58f7758f/TCGA-BR-8286-01Z-00-DX1.4e8edc91-41c1-4b40-89b5-6f09636e4a3f.svs 25315 22273 3 +/data/TCGA/b2d259f6-7834-43c6-a39d-dc824c85fbea/TCGA-N7-A4Y8-01Z-00-DX5.8024FD57-2A1A-4579-A008-DB0CDDB83A58.svs 63899 67451 0 +/data/TCGA/b2d259f6-7834-43c6-a39d-dc824c85fbea/TCGA-N7-A4Y8-01Z-00-DX5.8024FD57-2A1A-4579-A008-DB0CDDB83A58.svs 66957 48158 1 +/data/TCGA/b2d259f6-7834-43c6-a39d-dc824c85fbea/TCGA-N7-A4Y8-01Z-00-DX5.8024FD57-2A1A-4579-A008-DB0CDDB83A58.svs 17491 49899 2 +/data/TCGA/b2d259f6-7834-43c6-a39d-dc824c85fbea/TCGA-N7-A4Y8-01Z-00-DX5.8024FD57-2A1A-4579-A008-DB0CDDB83A58.svs 39438 55980 3 +/data/TCGA/e38a3818-6a97-4b9e-9c16-be90f10366de/TCGA-B2-4102-01Z-00-DX1.07c9ab3f-27ad-4e12-86e8-0eed36eb30c1.svs 106542 21825 0 +/data/TCGA/e38a3818-6a97-4b9e-9c16-be90f10366de/TCGA-B2-4102-01Z-00-DX1.07c9ab3f-27ad-4e12-86e8-0eed36eb30c1.svs 45267 18498 1 +/data/TCGA/e38a3818-6a97-4b9e-9c16-be90f10366de/TCGA-B2-4102-01Z-00-DX1.07c9ab3f-27ad-4e12-86e8-0eed36eb30c1.svs 43549 34960 2 +/data/TCGA/e38a3818-6a97-4b9e-9c16-be90f10366de/TCGA-B2-4102-01Z-00-DX1.07c9ab3f-27ad-4e12-86e8-0eed36eb30c1.svs 38897 30176 3 +/data/TCGA/9d43bf94-9b53-4cdb-be54-188aab478116/TCGA-AX-A1C9-01Z-00-DX2.70F112B9-7063-4C33-8745-26BFDB8A0CBD.svs 28586 14164 0 +/data/TCGA/9d43bf94-9b53-4cdb-be54-188aab478116/TCGA-AX-A1C9-01Z-00-DX2.70F112B9-7063-4C33-8745-26BFDB8A0CBD.svs 55733 61003 1 +/data/TCGA/9d43bf94-9b53-4cdb-be54-188aab478116/TCGA-AX-A1C9-01Z-00-DX2.70F112B9-7063-4C33-8745-26BFDB8A0CBD.svs 35461 37303 2 +/data/TCGA/9d43bf94-9b53-4cdb-be54-188aab478116/TCGA-AX-A1C9-01Z-00-DX2.70F112B9-7063-4C33-8745-26BFDB8A0CBD.svs 60379 26287 3 +/data/TCGA/9a3a3830-9674-4f9b-985f-e50062e78807/TCGA-A1-A0SJ-01Z-00-DX1.C196FA66-C376-4016-86BC-3D8E745B3A51.svs 67674 30168 0 +/data/TCGA/9a3a3830-9674-4f9b-985f-e50062e78807/TCGA-A1-A0SJ-01Z-00-DX1.C196FA66-C376-4016-86BC-3D8E745B3A51.svs 64382 11038 1 +/data/TCGA/9a3a3830-9674-4f9b-985f-e50062e78807/TCGA-A1-A0SJ-01Z-00-DX1.C196FA66-C376-4016-86BC-3D8E745B3A51.svs 60294 55182 2 +/data/TCGA/9a3a3830-9674-4f9b-985f-e50062e78807/TCGA-A1-A0SJ-01Z-00-DX1.C196FA66-C376-4016-86BC-3D8E745B3A51.svs 66867 45550 3 +/data/TCGA/ca90a8c2-171a-4b9e-ac40-b431205ef7d4/TCGA-D6-6517-01Z-00-DX1.38640ebf-b5c0-4ce3-a731-9013598ac7b4.svs 77900 23405 0 +/data/TCGA/ca90a8c2-171a-4b9e-ac40-b431205ef7d4/TCGA-D6-6517-01Z-00-DX1.38640ebf-b5c0-4ce3-a731-9013598ac7b4.svs 28249 59071 1 +/data/TCGA/ca90a8c2-171a-4b9e-ac40-b431205ef7d4/TCGA-D6-6517-01Z-00-DX1.38640ebf-b5c0-4ce3-a731-9013598ac7b4.svs 32266 60361 2 +/data/TCGA/ca90a8c2-171a-4b9e-ac40-b431205ef7d4/TCGA-D6-6517-01Z-00-DX1.38640ebf-b5c0-4ce3-a731-9013598ac7b4.svs 26154 62066 3 +/data/TCGA/d372a6ee-c594-401d-acab-490016361880/TCGA-EL-A4K4-01Z-00-DX1.77AEEDD8-FFA3-468C-9925-E38348A00381.svs 58673 34758 0 +/data/TCGA/d372a6ee-c594-401d-acab-490016361880/TCGA-EL-A4K4-01Z-00-DX1.77AEEDD8-FFA3-468C-9925-E38348A00381.svs 48994 12390 1 +/data/TCGA/d372a6ee-c594-401d-acab-490016361880/TCGA-EL-A4K4-01Z-00-DX1.77AEEDD8-FFA3-468C-9925-E38348A00381.svs 78443 4807 2 +/data/TCGA/d372a6ee-c594-401d-acab-490016361880/TCGA-EL-A4K4-01Z-00-DX1.77AEEDD8-FFA3-468C-9925-E38348A00381.svs 83747 16358 3 +/data/TCGA/41571666-6171-4f4c-af79-6c09276bd22a/TCGA-GL-7966-01Z-00-DX1.D53E267B-BC0D-43A7-8E89-FCCC2BD5380C.svs 51859 15566 0 +/data/TCGA/41571666-6171-4f4c-af79-6c09276bd22a/TCGA-GL-7966-01Z-00-DX1.D53E267B-BC0D-43A7-8E89-FCCC2BD5380C.svs 38939 14399 1 +/data/TCGA/41571666-6171-4f4c-af79-6c09276bd22a/TCGA-GL-7966-01Z-00-DX1.D53E267B-BC0D-43A7-8E89-FCCC2BD5380C.svs 23657 13078 2 +/data/TCGA/a86e56e0-61bd-43bd-8453-113815e82076/TCGA-CS-4943-01Z-00-DX1.42332d6f-e16e-40ae-a629-69c537d79465.svs 1883 23011 0 +/data/TCGA/a86e56e0-61bd-43bd-8453-113815e82076/TCGA-CS-4943-01Z-00-DX1.42332d6f-e16e-40ae-a629-69c537d79465.svs 116434 22534 1 +/data/TCGA/a86e56e0-61bd-43bd-8453-113815e82076/TCGA-CS-4943-01Z-00-DX1.42332d6f-e16e-40ae-a629-69c537d79465.svs 18218 21262 2 +/data/TCGA/bd670238-6bf6-4745-977e-785ac169700f/TCGA-BC-A112-01Z-00-DX1.4CC4A845-25F1-4DC2-8142-9990A66E9C1B.svs 49135 21203 0 +/data/TCGA/bd670238-6bf6-4745-977e-785ac169700f/TCGA-BC-A112-01Z-00-DX1.4CC4A845-25F1-4DC2-8142-9990A66E9C1B.svs 40774 10795 1 +/data/TCGA/bd670238-6bf6-4745-977e-785ac169700f/TCGA-BC-A112-01Z-00-DX1.4CC4A845-25F1-4DC2-8142-9990A66E9C1B.svs 36473 7700 2 +/data/TCGA/bd670238-6bf6-4745-977e-785ac169700f/TCGA-BC-A112-01Z-00-DX1.4CC4A845-25F1-4DC2-8142-9990A66E9C1B.svs 38342 28677 3 +/data/TCGA/4fc9841f-4e7e-421b-b640-e6568acf6807/TCGA-06-0152-01Z-00-DX4.5403448f-0430-4324-a801-37e597d9a8ff.svs 33649 23865 0 +/data/TCGA/4fc9841f-4e7e-421b-b640-e6568acf6807/TCGA-06-0152-01Z-00-DX4.5403448f-0430-4324-a801-37e597d9a8ff.svs 21037 16922 1 +/data/TCGA/4fc9841f-4e7e-421b-b640-e6568acf6807/TCGA-06-0152-01Z-00-DX4.5403448f-0430-4324-a801-37e597d9a8ff.svs 33488 12245 2 +/data/TCGA/31c72adf-d8ac-4c99-9885-a88b4f806675/TCGA-DD-AADG-01Z-00-DX1.0E38633E-5352-4190-9D58-82753F7BA25E.svs 39502 13079 0 +/data/TCGA/31c72adf-d8ac-4c99-9885-a88b4f806675/TCGA-DD-AADG-01Z-00-DX1.0E38633E-5352-4190-9D58-82753F7BA25E.svs 23698 24538 1 +/data/TCGA/31c72adf-d8ac-4c99-9885-a88b4f806675/TCGA-DD-AADG-01Z-00-DX1.0E38633E-5352-4190-9D58-82753F7BA25E.svs 55222 24925 2 +/data/TCGA/31c72adf-d8ac-4c99-9885-a88b4f806675/TCGA-DD-AADG-01Z-00-DX1.0E38633E-5352-4190-9D58-82753F7BA25E.svs 40109 17055 3 +/data/TCGA/78754454-aaed-482c-a26b-b4825dfd6637/TCGA-AL-3467-01Z-00-DX2.3ADEDD93-AD93-46D8-B3AE-1EBC6BD5EAF2.svs 33146 35180 0 +/data/TCGA/78754454-aaed-482c-a26b-b4825dfd6637/TCGA-AL-3467-01Z-00-DX2.3ADEDD93-AD93-46D8-B3AE-1EBC6BD5EAF2.svs 45623 27489 1 +/data/TCGA/78754454-aaed-482c-a26b-b4825dfd6637/TCGA-AL-3467-01Z-00-DX2.3ADEDD93-AD93-46D8-B3AE-1EBC6BD5EAF2.svs 12723 29434 2 +/data/TCGA/78754454-aaed-482c-a26b-b4825dfd6637/TCGA-AL-3467-01Z-00-DX2.3ADEDD93-AD93-46D8-B3AE-1EBC6BD5EAF2.svs 13480 32655 3 +/data/TCGA/184e3c8d-fcaf-42ed-9165-74603803f87e/TCGA-X6-A8C7-01Z-00-DX2.5C5871B4-5971-4482-B8ED-642FB3F38B02.svs 56712 24856 0 +/data/TCGA/184e3c8d-fcaf-42ed-9165-74603803f87e/TCGA-X6-A8C7-01Z-00-DX2.5C5871B4-5971-4482-B8ED-642FB3F38B02.svs 19611 28744 1 +/data/TCGA/184e3c8d-fcaf-42ed-9165-74603803f87e/TCGA-X6-A8C7-01Z-00-DX2.5C5871B4-5971-4482-B8ED-642FB3F38B02.svs 40468 74446 2 +/data/TCGA/184e3c8d-fcaf-42ed-9165-74603803f87e/TCGA-X6-A8C7-01Z-00-DX2.5C5871B4-5971-4482-B8ED-642FB3F38B02.svs 48472 63961 3 +/data/TCGA/479341d8-2acd-4aa9-afe2-9d29e9b0f5ac/TCGA-25-1317-01Z-00-DX1.2E7A7AF9-4D04-4EBD-8C79-7117F76511D5.svs 102815 27531 0 +/data/TCGA/479341d8-2acd-4aa9-afe2-9d29e9b0f5ac/TCGA-25-1317-01Z-00-DX1.2E7A7AF9-4D04-4EBD-8C79-7117F76511D5.svs 56062 25920 1 +/data/TCGA/479341d8-2acd-4aa9-afe2-9d29e9b0f5ac/TCGA-25-1317-01Z-00-DX1.2E7A7AF9-4D04-4EBD-8C79-7117F76511D5.svs 130240 12452 2 +/data/TCGA/479341d8-2acd-4aa9-afe2-9d29e9b0f5ac/TCGA-25-1317-01Z-00-DX1.2E7A7AF9-4D04-4EBD-8C79-7117F76511D5.svs 15186 54348 3 +/data/TCGA/5588dcbb-ac44-4127-8a1f-5b5e547cf23c/TCGA-A8-A085-01Z-00-DX1.0DA29016-AEA4-4E5F-B679-83095A79F5B3.svs 13919 17905 0 +/data/TCGA/5588dcbb-ac44-4127-8a1f-5b5e547cf23c/TCGA-A8-A085-01Z-00-DX1.0DA29016-AEA4-4E5F-B679-83095A79F5B3.svs 19194 24231 1 +/data/TCGA/5588dcbb-ac44-4127-8a1f-5b5e547cf23c/TCGA-A8-A085-01Z-00-DX1.0DA29016-AEA4-4E5F-B679-83095A79F5B3.svs 25135 30122 2 +/data/TCGA/5588dcbb-ac44-4127-8a1f-5b5e547cf23c/TCGA-A8-A085-01Z-00-DX1.0DA29016-AEA4-4E5F-B679-83095A79F5B3.svs 14988 19595 3 +/data/TCGA/9ad4d0d2-a9a5-4b63-9479-16f3b1d949c3/TCGA-12-0821-01Z-00-DX2.E0F30115-B141-451C-84F1-64839ED91D24.svs 17001 20681 0 +/data/TCGA/9ad4d0d2-a9a5-4b63-9479-16f3b1d949c3/TCGA-12-0821-01Z-00-DX2.E0F30115-B141-451C-84F1-64839ED91D24.svs 19212 18843 1 +/data/TCGA/9ad4d0d2-a9a5-4b63-9479-16f3b1d949c3/TCGA-12-0821-01Z-00-DX2.E0F30115-B141-451C-84F1-64839ED91D24.svs 178 15627 2 +/data/TCGA/d5651e1b-8633-45dc-b19a-310510608ac1/TCGA-3A-A9IN-01Z-00-DX1.A4FED037-D993-4F71-B422-14FC4E468B4C.svs 36985 24317 0 +/data/TCGA/d5651e1b-8633-45dc-b19a-310510608ac1/TCGA-3A-A9IN-01Z-00-DX1.A4FED037-D993-4F71-B422-14FC4E468B4C.svs 71669 30728 1 +/data/TCGA/d5651e1b-8633-45dc-b19a-310510608ac1/TCGA-3A-A9IN-01Z-00-DX1.A4FED037-D993-4F71-B422-14FC4E468B4C.svs 71352 46175 2 +/data/TCGA/d5651e1b-8633-45dc-b19a-310510608ac1/TCGA-3A-A9IN-01Z-00-DX1.A4FED037-D993-4F71-B422-14FC4E468B4C.svs 42531 42902 3 +/data/TCGA/ad205df2-5eae-466c-b4af-b05b269752af/TCGA-CQ-7072-01Z-00-DX1.5932E8B0-B5B3-4ECC-AC61-A85FEE443536.svs 44060 34735 0 +/data/TCGA/ad205df2-5eae-466c-b4af-b05b269752af/TCGA-CQ-7072-01Z-00-DX1.5932E8B0-B5B3-4ECC-AC61-A85FEE443536.svs 30420 13829 1 +/data/TCGA/ad205df2-5eae-466c-b4af-b05b269752af/TCGA-CQ-7072-01Z-00-DX1.5932E8B0-B5B3-4ECC-AC61-A85FEE443536.svs 42420 36440 2 +/data/TCGA/dae970fa-f0fb-4b93-b655-550dade806e1/TCGA-12-0707-01Z-00-DX5.72af8ec5-7d2d-45a4-a40c-cdbe9ae72100.svs 17350 29448 0 +/data/TCGA/dae970fa-f0fb-4b93-b655-550dade806e1/TCGA-12-0707-01Z-00-DX5.72af8ec5-7d2d-45a4-a40c-cdbe9ae72100.svs 23174 25925 1 +/data/TCGA/dae970fa-f0fb-4b93-b655-550dade806e1/TCGA-12-0707-01Z-00-DX5.72af8ec5-7d2d-45a4-a40c-cdbe9ae72100.svs 20636 30900 2 +/data/TCGA/d32d8225-d50f-4bbb-b8a3-eecc74dbab1c/TCGA-06-0124-01Z-00-DX3.30f5dfb8-2160-4abb-94fe-26a979e23638.svs 14945 6771 0 +/data/TCGA/d32d8225-d50f-4bbb-b8a3-eecc74dbab1c/TCGA-06-0124-01Z-00-DX3.30f5dfb8-2160-4abb-94fe-26a979e23638.svs 5392 1364 1 +/data/TCGA/d32d8225-d50f-4bbb-b8a3-eecc74dbab1c/TCGA-06-0124-01Z-00-DX3.30f5dfb8-2160-4abb-94fe-26a979e23638.svs 7025 7971 2 +/data/TCGA/e453a985-13c5-4de2-8c34-2ab41b544a17/TCGA-DD-A3A1-01Z-00-DX1.B836DA77-CAB4-4991-91A6-A1D46C7C1E99.svs 49503 9326 0 +/data/TCGA/e453a985-13c5-4de2-8c34-2ab41b544a17/TCGA-DD-A3A1-01Z-00-DX1.B836DA77-CAB4-4991-91A6-A1D46C7C1E99.svs 24060 58893 1 +/data/TCGA/e453a985-13c5-4de2-8c34-2ab41b544a17/TCGA-DD-A3A1-01Z-00-DX1.B836DA77-CAB4-4991-91A6-A1D46C7C1E99.svs 9407 19679 2 +/data/TCGA/e453a985-13c5-4de2-8c34-2ab41b544a17/TCGA-DD-A3A1-01Z-00-DX1.B836DA77-CAB4-4991-91A6-A1D46C7C1E99.svs 92001 20550 3 +/data/TCGA/625ae478-a0a5-492b-8e8e-a0763008f960/TCGA-AA-A00Q-01Z-00-DX1.D427F78B-6640-400B-B8F8-B5568B1C4321.svs 29410 23271 0 +/data/TCGA/625ae478-a0a5-492b-8e8e-a0763008f960/TCGA-AA-A00Q-01Z-00-DX1.D427F78B-6640-400B-B8F8-B5568B1C4321.svs 32506 28759 1 +/data/TCGA/625ae478-a0a5-492b-8e8e-a0763008f960/TCGA-AA-A00Q-01Z-00-DX1.D427F78B-6640-400B-B8F8-B5568B1C4321.svs 35488 7661 2 +/data/TCGA/625ae478-a0a5-492b-8e8e-a0763008f960/TCGA-AA-A00Q-01Z-00-DX1.D427F78B-6640-400B-B8F8-B5568B1C4321.svs 32794 16094 3 +/data/TCGA/a14c4110-b51d-4ae8-90f2-86575d38b6b5/TCGA-2Y-A9GZ-01Z-00-DX1.4E8C9A7D-D21D-4B6E-8C1B-DC520309AB91.svs 58110 39975 0 +/data/TCGA/a14c4110-b51d-4ae8-90f2-86575d38b6b5/TCGA-2Y-A9GZ-01Z-00-DX1.4E8C9A7D-D21D-4B6E-8C1B-DC520309AB91.svs 69671 19933 1 +/data/TCGA/a14c4110-b51d-4ae8-90f2-86575d38b6b5/TCGA-2Y-A9GZ-01Z-00-DX1.4E8C9A7D-D21D-4B6E-8C1B-DC520309AB91.svs 1806 43774 2 +/data/TCGA/a14c4110-b51d-4ae8-90f2-86575d38b6b5/TCGA-2Y-A9GZ-01Z-00-DX1.4E8C9A7D-D21D-4B6E-8C1B-DC520309AB91.svs 60391 32856 3 +/data/TCGA/32132032-c0fa-4ad9-97a5-10b42d7bf160/TCGA-VQ-A8P3-01Z-00-DX1.1B018BDB-5C60-46D8-A014-CE8CA8ADA191.svs 61457 30824 0 +/data/TCGA/32132032-c0fa-4ad9-97a5-10b42d7bf160/TCGA-VQ-A8P3-01Z-00-DX1.1B018BDB-5C60-46D8-A014-CE8CA8ADA191.svs 61700 48601 1 +/data/TCGA/32132032-c0fa-4ad9-97a5-10b42d7bf160/TCGA-VQ-A8P3-01Z-00-DX1.1B018BDB-5C60-46D8-A014-CE8CA8ADA191.svs 56899 15859 2 +/data/TCGA/32132032-c0fa-4ad9-97a5-10b42d7bf160/TCGA-VQ-A8P3-01Z-00-DX1.1B018BDB-5C60-46D8-A014-CE8CA8ADA191.svs 19083 64599 3 +/data/TCGA/b56bd20c-f866-4f6a-8748-583f50c81421/TCGA-BS-A0UV-01Z-00-DX1.6C4E2500-1689-451B-BFBF-DB599177F9CB.svs 52367 27033 0 +/data/TCGA/b56bd20c-f866-4f6a-8748-583f50c81421/TCGA-BS-A0UV-01Z-00-DX1.6C4E2500-1689-451B-BFBF-DB599177F9CB.svs 54622 11387 1 +/data/TCGA/b56bd20c-f866-4f6a-8748-583f50c81421/TCGA-BS-A0UV-01Z-00-DX1.6C4E2500-1689-451B-BFBF-DB599177F9CB.svs 40786 21440 2 +/data/TCGA/b56bd20c-f866-4f6a-8748-583f50c81421/TCGA-BS-A0UV-01Z-00-DX1.6C4E2500-1689-451B-BFBF-DB599177F9CB.svs 6783 47373 3 +/data/TCGA/f7abab4e-54fa-491e-a67a-d401cdc23e1e/TCGA-BH-A0C7-01Z-00-DX1.C70D358E-C48F-4F69-86CE-3218E9C95837.svs 96840 29998 0 +/data/TCGA/f7abab4e-54fa-491e-a67a-d401cdc23e1e/TCGA-BH-A0C7-01Z-00-DX1.C70D358E-C48F-4F69-86CE-3218E9C95837.svs 37954 59121 1 +/data/TCGA/f7abab4e-54fa-491e-a67a-d401cdc23e1e/TCGA-BH-A0C7-01Z-00-DX1.C70D358E-C48F-4F69-86CE-3218E9C95837.svs 62737 40201 2 +/data/TCGA/f7abab4e-54fa-491e-a67a-d401cdc23e1e/TCGA-BH-A0C7-01Z-00-DX1.C70D358E-C48F-4F69-86CE-3218E9C95837.svs 57128 27592 3 +/data/TCGA/3985ea64-d68f-4539-a4d3-65ff4a7b98be/TCGA-EW-A2FW-01Z-00-DX1.4F948681-81F3-46C5-A4E8-FDE8A4116F7A.svs 62285 52380 0 +/data/TCGA/3985ea64-d68f-4539-a4d3-65ff4a7b98be/TCGA-EW-A2FW-01Z-00-DX1.4F948681-81F3-46C5-A4E8-FDE8A4116F7A.svs 80004 54681 1 +/data/TCGA/3985ea64-d68f-4539-a4d3-65ff4a7b98be/TCGA-EW-A2FW-01Z-00-DX1.4F948681-81F3-46C5-A4E8-FDE8A4116F7A.svs 51812 17824 2 +/data/TCGA/3985ea64-d68f-4539-a4d3-65ff4a7b98be/TCGA-EW-A2FW-01Z-00-DX1.4F948681-81F3-46C5-A4E8-FDE8A4116F7A.svs 104989 39332 3 +/data/TCGA/a4e25e73-263e-42a0-9cc2-5fa6fd09e083/TCGA-BH-A0BD-01Z-00-DX1.CD4A6FC2-BA8C-4E30-972A-E6CD1BEAD8AD.svs 64326 41223 0 +/data/TCGA/a4e25e73-263e-42a0-9cc2-5fa6fd09e083/TCGA-BH-A0BD-01Z-00-DX1.CD4A6FC2-BA8C-4E30-972A-E6CD1BEAD8AD.svs 59019 33109 1 +/data/TCGA/a4e25e73-263e-42a0-9cc2-5fa6fd09e083/TCGA-BH-A0BD-01Z-00-DX1.CD4A6FC2-BA8C-4E30-972A-E6CD1BEAD8AD.svs 67131 35020 2 +/data/TCGA/a4e25e73-263e-42a0-9cc2-5fa6fd09e083/TCGA-BH-A0BD-01Z-00-DX1.CD4A6FC2-BA8C-4E30-972A-E6CD1BEAD8AD.svs 61503 45767 3 +/data/TCGA/aefd8fd8-2d4c-455d-b5c0-1c6bac6c0870/TCGA-CN-6010-01Z-00-DX1.8a82a2d0-c687-4b75-922f-b5b64b5a99df.svs 6863 27583 0 +/data/TCGA/aefd8fd8-2d4c-455d-b5c0-1c6bac6c0870/TCGA-CN-6010-01Z-00-DX1.8a82a2d0-c687-4b75-922f-b5b64b5a99df.svs 8058 8349 1 +/data/TCGA/aefd8fd8-2d4c-455d-b5c0-1c6bac6c0870/TCGA-CN-6010-01Z-00-DX1.8a82a2d0-c687-4b75-922f-b5b64b5a99df.svs 69135 32969 2 +/data/TCGA/aefd8fd8-2d4c-455d-b5c0-1c6bac6c0870/TCGA-CN-6010-01Z-00-DX1.8a82a2d0-c687-4b75-922f-b5b64b5a99df.svs 66198 24233 3 +/data/TCGA/e286ad6b-9ee2-477b-ae2c-c831e50390e2/TCGA-12-0769-01Z-00-DX1.ebd0fe2a-1113-413f-a04d-e5cf7c0335ff.svs 10875 8284 0 +/data/TCGA/e286ad6b-9ee2-477b-ae2c-c831e50390e2/TCGA-12-0769-01Z-00-DX1.ebd0fe2a-1113-413f-a04d-e5cf7c0335ff.svs 20636 9185 1 +/data/TCGA/e286ad6b-9ee2-477b-ae2c-c831e50390e2/TCGA-12-0769-01Z-00-DX1.ebd0fe2a-1113-413f-a04d-e5cf7c0335ff.svs 17983 9921 2 +/data/TCGA/7cab68a5-c499-4c4f-8807-08be3f79fbc8/TCGA-HT-7607-01Z-00-DX16.3B3E33BB-2B4A-4600-8474-62AFCC9F99A4.svs 59915 22654 0 +/data/TCGA/7cab68a5-c499-4c4f-8807-08be3f79fbc8/TCGA-HT-7607-01Z-00-DX16.3B3E33BB-2B4A-4600-8474-62AFCC9F99A4.svs 21081 40627 1 +/data/TCGA/7cab68a5-c499-4c4f-8807-08be3f79fbc8/TCGA-HT-7607-01Z-00-DX16.3B3E33BB-2B4A-4600-8474-62AFCC9F99A4.svs 26886 33219 2 +/data/TCGA/7cab68a5-c499-4c4f-8807-08be3f79fbc8/TCGA-HT-7607-01Z-00-DX16.3B3E33BB-2B4A-4600-8474-62AFCC9F99A4.svs 72753 25835 3 +/data/TCGA/6016e929-ad86-4de4-a523-8ba4427d7f18/TCGA-43-7658-01Z-00-DX1.db69fbb6-59d7-49f5-adbf-f9c030b85b73.svs 39191 14840 0 +/data/TCGA/6016e929-ad86-4de4-a523-8ba4427d7f18/TCGA-43-7658-01Z-00-DX1.db69fbb6-59d7-49f5-adbf-f9c030b85b73.svs 36019 13507 1 +/data/TCGA/6016e929-ad86-4de4-a523-8ba4427d7f18/TCGA-43-7658-01Z-00-DX1.db69fbb6-59d7-49f5-adbf-f9c030b85b73.svs 39665 11472 2 +/data/TCGA/ece7c729-f4f7-483f-a39b-ab9d52af89f7/TCGA-OR-A5JG-01Z-00-DX5.C14583E6-FBE2-45A4-9557-D9CEE737AB82.svs 32595 26411 0 +/data/TCGA/ece7c729-f4f7-483f-a39b-ab9d52af89f7/TCGA-OR-A5JG-01Z-00-DX5.C14583E6-FBE2-45A4-9557-D9CEE737AB82.svs 59834 14140 1 +/data/TCGA/ece7c729-f4f7-483f-a39b-ab9d52af89f7/TCGA-OR-A5JG-01Z-00-DX5.C14583E6-FBE2-45A4-9557-D9CEE737AB82.svs 66334 6992 2 +/data/TCGA/ece7c729-f4f7-483f-a39b-ab9d52af89f7/TCGA-OR-A5JG-01Z-00-DX5.C14583E6-FBE2-45A4-9557-D9CEE737AB82.svs 70302 13529 3 +/data/TCGA/b58e69c3-e152-4a8f-a710-6760547578bc/TCGA-B6-A0WT-01Z-00-DX1.7ED21DA2-A3D8-4DCA-9742-963879A658D8.svs 106092 40236 0 diff --git a/OpenMidnight/pyproject.toml b/OpenMidnight/pyproject.toml new file mode 100644 index 0000000000000000000000000000000000000000..78d51bb41674e9e2c2ece25b7d3dd8f9e9e66c29 --- /dev/null +++ b/OpenMidnight/pyproject.toml @@ -0,0 +1,58 @@ +[project] +name = "pathologydino" +version = "0.1.0" +description = "Add your description here" +readme = "README.md" +requires-python = "==3.10.12" +dependencies = [ + "pillow-simd", + "einops>=0.8.1", + "datasets>=2.20.0", + "fvcore>=0.1.5.post20221221", + "iopath>=0.1.10", + "matplotlib", + "omegaconf>=2.3.0", + "opencv-python>=4.12.0.88", + "pyarrow>=20.0.0", + "openslide-bin>=4.0.0.8", + "openslide-python>=1.4.2", + "scikit-image>=0.25.2", + "submitit>=1.5.3", + "torchmetrics>=1.8.0", + "wandb>=0.21.0", + "huggingface-hub==1.2.3", + "torch==2.8.0", + "torchvision", + "xformers>=0.0.32.post2", + # for Eva benchmarking: + "imagesize>=1.4.1", + "scipy>=1.14.0", + "monai>=1.3.2", + "lightning>=2.2.0", + "jsonargparse[omegaconf]>=4.30.0", + "tensorboard>=2.16.2", + "loguru>=0.7.2", + "transformers==5.0.0rc1", + "onnxruntime>=1.15.1", + "onnx>=1.16.0", + "toolz>=0.12.1", + "rich>=13.7.1", + "nibabel>=3.2.2", + "timm>=1.0.9", + # for HEST benchmarking: + "hestcore==1.0.4", +] + +[tool.setuptools.packages.find] +include = ["dinov2*"] + +[build-system] +requires = ["setuptools>=68", "wheel"] +build-backend = "setuptools.build_meta" + +[tool.uv.pip] +# Use uv's auto detection when installing via `uv pip` +torch-backend = "auto" + +[tool.uv] +exclude-dependencies= ["pillow"] \ No newline at end of file diff --git a/OpenMidnight/run.sh b/OpenMidnight/run.sh new file mode 100644 index 0000000000000000000000000000000000000000..2c38be7828ae0797fb49421660d271175e5858f8 --- /dev/null +++ b/OpenMidnight/run.sh @@ -0,0 +1,3 @@ +source .venv/bin/activate +CUDA_VISIBLE_DEVICES=0 torchrun --master_port=34001 --nproc_per_node=1 dinov2/train/train.py --config-file ./dinov2/configs/train/vits14_reg4.yaml --output-dir ./output_pretrained_on_test train.dataset_path=pathology:root=/teamspace/studios/this_studio/tcga/ + diff --git a/OpenMidnight/run_1node.sbatch b/OpenMidnight/run_1node.sbatch new file mode 100644 index 0000000000000000000000000000000000000000..ad16b7f374a32e90dd6de1d0f7412c764e103e8d --- /dev/null +++ b/OpenMidnight/run_1node.sbatch @@ -0,0 +1,45 @@ +#!/usr/bin/env bash +#SBATCH --job-name=dinov2 +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-task=8 +#SBATCH --time=infinite +#SBATCH --output=slurms/%j.out +#SBATCH --error=slurms/%j.err +#SBATCH --partition=main +#SBATCH --account=training + +set -euo pipefail + +# ---- Training config ---- +CONFIG_FILE="./dinov2/configs/train/vitg14_reg4.yaml" +OUTPUT_DIR="/data/rename_this_to_your_output_dir_name" +RESUME="True" # "True" to keep OUTPUT_DIR and resume if checkpoints exist + +# ---- Repo env ---- +REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)" +export DINOV2_RUN_SCRIPT="${REPO_ROOT}/$(basename "${BASH_SOURCE[0]}")" +export PYTHONPATH="${REPO_ROOT}${PYTHONPATH:+:${PYTHONPATH}}" + +# Clean output directory +if [[ "${RESUME}" == "True" ]]; then + RESUME_FLAG="" +else + RESUME_FLAG="--no-resume" + if [[ "${SLURM_PROCID}" == "0" ]]; then + rm -rf "${OUTPUT_DIR}" + fi +fi +mkdir -p "${OUTPUT_DIR}" + +echo "CONFIG_FILE=${CONFIG_FILE}" +echo "OUTPUT_DIR=${OUTPUT_DIR}" + +uv run torchrun \ + --nnodes 1 \ + --nproc_per_node 8 \ + --node_rank 0 \ + dinov2/train/train.py \ + --config-file "${CONFIG_FILE}" \ + --output-dir "${OUTPUT_DIR}" \ + ${RESUME_FLAG} diff --git a/OpenMidnight/run_1node.sh b/OpenMidnight/run_1node.sh new file mode 100644 index 0000000000000000000000000000000000000000..731d61c2c1fa9e5270c14321f5614eb0db5fb5a5 --- /dev/null +++ b/OpenMidnight/run_1node.sh @@ -0,0 +1,52 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Master node configuration +export MASTER_ADDR=$(hostname -I | awk '{print $1}') +export MASTER_PORT=29500 + +export NNODES=1 # number of nodes you are using +export NPROC_PER_NODE=8 # number of GPUs per node +export CUDA_VISIBLE_DEVICES="0,1,2,3,4,5,6,7" # specific devices to use on this node +export NODE_RANK=0 # the node running this script will be master node (rank 0) + +# Training config +CONFIG_FILE="./dinov2/configs/train/vitg14_reg4.yaml" +OUTPUT_DIR="./output_vitg14" +RESUME="True" # set string to "True" to resume from last checkpoint in OUTPUT_DIR if it exists + +# Set Python path for imports +# Provide script path so train.py can attach the right launcher script to WandB. +REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)" +export DINOV2_RUN_SCRIPT="${REPO_ROOT}/$(basename "${BASH_SOURCE[0]}")" +export PYTHONPATH="${REPO_ROOT}${PYTHONPATH:+:${PYTHONPATH}}" + +# Clean output directory only when not resuming +if [[ "${RESUME}" == "True" ]]; then + echo "Resume enabled; preserving ${OUTPUT_DIR}" + RESUME_FLAG="" +else + echo "Resume disabled; cleaning ${OUTPUT_DIR}" + rm -rf "${OUTPUT_DIR}" + RESUME_FLAG="--no-resume" +fi +mkdir -p "${OUTPUT_DIR}" + +echo "[Master Node] Starting training..." +echo "MASTER_ADDR=${MASTER_ADDR}" +echo "MASTER_PORT=${MASTER_PORT}" +echo "NNODES=${NNODES}, NPROC_PER_NODE=${NPROC_PER_NODE}" +echo "CONFIG_FILE=${CONFIG_FILE}" +echo "OUTPUT_DIR=${OUTPUT_DIR}" +echo "CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES}" + +uv run torchrun \ + --nnodes "${NNODES}" \ + --nproc_per_node "${NPROC_PER_NODE}" \ + --node_rank "${NODE_RANK}" \ + --master_addr "${MASTER_ADDR}" \ + --master_port "${MASTER_PORT}" \ + dinov2/train/train.py \ + --config-file "${CONFIG_FILE}" \ + --output-dir "${OUTPUT_DIR}" \ + ${RESUME_FLAG} diff --git a/OpenMidnight/run_ablation.sh b/OpenMidnight/run_ablation.sh new file mode 100644 index 0000000000000000000000000000000000000000..13dc257d33143307a8bfa9af4b152f6111fcfcd5 --- /dev/null +++ b/OpenMidnight/run_ablation.sh @@ -0,0 +1,52 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Master node configuration +export MASTER_ADDR=$(hostname -I | awk '{print $1}') +export MASTER_PORT=29500 + +export NNODES=1 # number of nodes you are using +export NPROC_PER_NODE=1 # number of GPUs per node +export CUDA_VISIBLE_DEVICES="0" # specific devices to use on this node +export NODE_RANK=0 # the node running this script will be master node (rank 0) + +# Training config +CONFIG_FILE="./dinov2/configs/train/vits14_reg_ablations.yaml" +OUTPUT_DIR="./output_ablation" +RESUME="True" # set string to "True" to resume from last checkpoint in OUTPUT_DIR if it exists + +# Set Python path for imports +# Provide script path so train.py can attach the right launcher script to WandB. +REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)" +export DINOV2_RUN_SCRIPT="${REPO_ROOT}/$(basename "${BASH_SOURCE[0]}")" +export PYTHONPATH="${REPO_ROOT}${PYTHONPATH:+:${PYTHONPATH}}" + +# Clean output directory only when not resuming +if [[ "${RESUME}" == "True" ]]; then + echo "Resume enabled; preserving ${OUTPUT_DIR}" + RESUME_FLAG="" +else + echo "Resume disabled; cleaning ${OUTPUT_DIR}" + rm -rf "${OUTPUT_DIR}" + RESUME_FLAG="--no-resume" +fi +mkdir -p "${OUTPUT_DIR}" + +echo "[Master Node] Starting training..." +echo "MASTER_ADDR=${MASTER_ADDR}" +echo "MASTER_PORT=${MASTER_PORT}" +echo "NNODES=${NNODES}, NPROC_PER_NODE=${NPROC_PER_NODE}" +echo "CONFIG_FILE=${CONFIG_FILE}" +echo "OUTPUT_DIR=${OUTPUT_DIR}" +echo "CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES}" + +uv run torchrun \ + --nnodes "${NNODES}" \ + --nproc_per_node "${NPROC_PER_NODE}" \ + --node_rank "${NODE_RANK}" \ + --master_addr "${MASTER_ADDR}" \ + --master_port "${MASTER_PORT}" \ + dinov2/train/train.py \ + --config-file "${CONFIG_FILE}" \ + --output-dir "${OUTPUT_DIR}" \ + ${RESUME_FLAG} diff --git a/OpenMidnight/run_master_node.sh b/OpenMidnight/run_master_node.sh new file mode 100644 index 0000000000000000000000000000000000000000..e00d641c5b631720a6ef33903846c2e9e626c430 --- /dev/null +++ b/OpenMidnight/run_master_node.sh @@ -0,0 +1,52 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Master node configuration +export MASTER_ADDR=$(hostname -I | awk '{print $1}') +export MASTER_PORT=29500 + +export NNODES=2 # number of nodes you are using +export NPROC_PER_NODE=8 # number of GPUs per node +export CUDA_VISIBLE_DEVICES="0,1,2,3,4,5,6,7" # specific devices to use on this node +export NODE_RANK=0 # the node running this script will be master node (rank 0) + +# Training config +CONFIG_FILE="./dinov2/configs/train/vitg14_reg4.yaml" +OUTPUT_DIR="./output_vitg14" +RESUME="True" # set string to "True" to resume from last checkpoint in OUTPUT_DIR if it exists + +# Set Python path for imports +# Provide script path so train.py can attach the right launcher script to WandB. +REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)" +export DINOV2_RUN_SCRIPT="${REPO_ROOT}/$(basename "${BASH_SOURCE[0]}")" +export PYTHONPATH="${REPO_ROOT}${PYTHONPATH:+:${PYTHONPATH}}" + +# Clean output directory only when not resuming +if [[ "${RESUME}" == "True" ]]; then + echo "Resume enabled; preserving ${OUTPUT_DIR}" + RESUME_FLAG="" +else + echo "Resume disabled; cleaning ${OUTPUT_DIR}" + rm -rf "${OUTPUT_DIR}" + RESUME_FLAG="--no-resume" +fi +mkdir -p "${OUTPUT_DIR}" + +echo "[Master Node] Starting training..." +echo "MASTER_ADDR=${MASTER_ADDR}" +echo "MASTER_PORT=${MASTER_PORT}" +echo "NNODES=${NNODES}, NPROC_PER_NODE=${NPROC_PER_NODE}" +echo "CONFIG_FILE=${CONFIG_FILE}" +echo "OUTPUT_DIR=${OUTPUT_DIR}" +echo "CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES}" + +uv run torchrun \ + --nnodes "${NNODES}" \ + --nproc_per_node "${NPROC_PER_NODE}" \ + --node_rank "${NODE_RANK}" \ + --master_addr "${MASTER_ADDR}" \ + --master_port "${MASTER_PORT}" \ + dinov2/train/train.py \ + --config-file "${CONFIG_FILE}" \ + --output-dir "${OUTPUT_DIR}" \ + ${RESUME_FLAG} diff --git a/OpenMidnight/run_other_nodes.sh b/OpenMidnight/run_other_nodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..bc0eb85e397113325c21c737824722d74a3a5b2f --- /dev/null +++ b/OpenMidnight/run_other_nodes.sh @@ -0,0 +1,48 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Worker node configuration +export MASTER_ADDR="10.128.0.10" # <-- Replace this with master node IP +export MASTER_PORT=29500 + +export NNODES=2 +export NPROC_PER_NODE=8 +export CUDA_VISIBLE_DEVICES="0,1,2,3,4,5,6,7" # specific devices to use on this node +export NODE_RANK=$(( NODE_RANK + 1 )) # non-master node rank (1 for first worker, etc.) + +# Training config (must match master node! double-check your run.sh script!) +CONFIG_FILE="./dinov2/configs/train/vitg14_reg4.yaml" +OUTPUT_DIR="./output_vitg14" +RESUME="True" # set string to "True" to resume from last checkpoint in OUTPUT_DIR if it exists + +# Set Python path for imports +# Provide script path so train.py can attach the right launcher script to WandB. +REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)" +export DINOV2_RUN_SCRIPT="${REPO_ROOT}/$(basename "${BASH_SOURCE[0]}")" +export PYTHONPATH="${REPO_ROOT}${PYTHONPATH:+:${PYTHONPATH}}" + +# Clean output directory only when not resuming +if [[ "${RESUME}" == "True" ]]; then + RESUME_FLAG="" +else + RESUME_FLAG="--no-resume" +fi + +echo "[Worker Node ${NODE_RANK}] Joining training..." +echo "MASTER_ADDR=${MASTER_ADDR}" +echo "MASTER_PORT=${MASTER_PORT}" +echo "NNODES=${NNODES}, NPROC_PER_NODE=${NPROC_PER_NODE}" +echo "CONFIG_FILE=${CONFIG_FILE}" +echo "OUTPUT_DIR=${OUTPUT_DIR}" +echo "CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES}" + +uv run torchrun \ + --nnodes "${NNODES}" \ + --nproc_per_node "${NPROC_PER_NODE}" \ + --node_rank "${NODE_RANK}" \ + --master_addr "${MASTER_ADDR}" \ + --master_port "${MASTER_PORT}" \ + dinov2/train/train.py \ + --config-file "${CONFIG_FILE}" \ + --output-dir "${OUTPUT_DIR}" \ + ${RESUME_FLAG} diff --git a/OpenMidnight/run_short_1gpu.sh b/OpenMidnight/run_short_1gpu.sh new file mode 100644 index 0000000000000000000000000000000000000000..63c95256c99b26d208572d01bac95b49ac526463 --- /dev/null +++ b/OpenMidnight/run_short_1gpu.sh @@ -0,0 +1,52 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Master node configuration +export MASTER_ADDR=$(hostname -I | awk '{print $1}') +export MASTER_PORT=29501 + +export NNODES=1 # number of nodes you are using +export NPROC_PER_NODE=1 # number of GPUs per node +export CUDA_VISIBLE_DEVICES="0" # specific devices to use on this node +export NODE_RANK=0 # the node running this script will be master node (rank 0) + +# Training config +CONFIG_FILE="./dinov2/configs/train/vitg14_reg4_short1.yaml" +OUTPUT_DIR="./output_vitg14_short1" +RESUME="False" # set string to "True" to resume from last checkpoint in OUTPUT_DIR if it exists + +# Set Python path for imports +# Provide script path so train.py can attach the right launcher script to WandB. +REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)" +export DINOV2_RUN_SCRIPT="${REPO_ROOT}/$(basename "${BASH_SOURCE[0]}")" +export PYTHONPATH="${REPO_ROOT}${PYTHONPATH:+:${PYTHONPATH}}" + +# Clean output directory only when not resuming +if [[ "${RESUME}" == "True" ]]; then + echo "Resume enabled; preserving ${OUTPUT_DIR}" + RESUME_FLAG="" +else + echo "Resume disabled; cleaning ${OUTPUT_DIR}" + rm -rf "${OUTPUT_DIR}" + RESUME_FLAG="--no-resume" +fi +mkdir -p "${OUTPUT_DIR}" + +echo "[Master Node] Starting training..." +echo "MASTER_ADDR=${MASTER_ADDR}" +echo "MASTER_PORT=${MASTER_PORT}" +echo "NNODES=${NNODES}, NPROC_PER_NODE=${NPROC_PER_NODE}" +echo "CONFIG_FILE=${CONFIG_FILE}" +echo "OUTPUT_DIR=${OUTPUT_DIR}" +echo "CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES}" + +uv run torchrun \ + --nnodes "${NNODES}" \ + --nproc_per_node "${NPROC_PER_NODE}" \ + --node_rank "${NODE_RANK}" \ + --master_addr "${MASTER_ADDR}" \ + --master_port "${MASTER_PORT}" \ + dinov2/train/train.py \ + --config-file "${CONFIG_FILE}" \ + --output-dir "${OUTPUT_DIR}" \ + ${RESUME_FLAG} diff --git a/README.md b/README.md new file mode 100644 index 0000000000000000000000000000000000000000..65cfadb0c7e7f3eeff6b461f607a7455fe306833 --- /dev/null +++ b/README.md @@ -0,0 +1,48 @@ +# OpenPath — 병리 Foundation Model 학습 코드 (run6 기준) + +공개 병리 데이터만으로 학습한 ViT-g/14 pathology FM(OpenPath)의 **학습 재현 코드**. +run6 = **native 40× 코퍼스 + DINOv2(OpenMidnight fork) + gram anchoring** 구성. + +## 구성 +``` +OpenMidnight/ # DINOv2 학습 fork (dinov2 패키지 + 우리 수정) + dinov2/train/train.py # 학습 루프 (+ gram weight 스케줄) + dinov2/train/ssl_meta_arch.py # SSL 아키텍처 (+ gram anchor teacher) + dinov2/loss/gram_loss.py # ★ gram anchoring loss (DINOv3서 이식) + dinov2/data/openpath_wds.py # openpath 코퍼스 WebDataset 로더 (openpath:glob=...) + dinov2/configs/train/openpath_vitg14_run6_native_gram.yaml # ★ run6 config +scripts/ + launch_om_run2.sh # 멀티노드 런처 (40 GPU: host + 4 workers) + autoresume_run6.sh # 크래시 내성 자동 재개 + watch_eval_run6.sh # 실시간 HEST probe (체크포인트별) + run_hest_3way.py # HEST 평가 (Meta DINOv2 / Phikon-v2 / OpenPath 비교) +requirements.txt +``` + +## 데이터 +- **`taejoon89/openpath-corpus`** (HF, public+gated) — native 40× 병리 타일 33,991 shard / 17TB. +- config의 `train.sample_list_path` = `openpath:glob=<코퍼스경로>/*/tiles/shards/w*/*.tar` 로 지정. + +## 앵커 (gram) +- run6의 gram anchor = **run5 training_63250** teacher checkpoint (HEST 0.3834). +- `taejoon89/openpath-checkpoints` (HF, private)에서 받아 config의 `gram.ckpt`에 지정. + +## 핵심 설정 (run6) +- ViT-g/14 reg4, patch14, warm-start = Meta DINOv2 ViT-g/14-reg. +- flat-LR (epochs 8000 지평, early_stop 276=345k=native 1 epoch), base_lr 2e-4 (실효 3.16e-4 @global 2560). +- **gram anchoring**: weight 40, it_first_update 57500(peak 직전 활성), ramp 3000. loss = 정규화 patch Gram matrix MSE(student vs anchor). +- FSDP SHARD_GRAD_OP, bf16, sinkhorn-knopp centering, DINO+iBOT+KDE loss. + +## 학습 실행 (멀티노드 40 GPU 예) +```bash +export PYTHONPATH=$PWD/OpenMidnight +CFG=OpenMidnight/dinov2/configs/train/openpath_vitg14_run6_native_gram.yaml +bash scripts/launch_om_run2.sh omvitgrun6 "$CFG" <출력디렉토리> <로그디렉토리> +# + autoresume_run6.sh (백그라운드), watch_eval_run6.sh (실시간 HEST) +``` + +## 결과 (오염-free HCC-ST Visium 벤치, LOPO Pearson) +- best 모델 = run5 training_63250: HEST 0.3834, HCC-ST 0.3244 (> OpenMidnight 0.3004). +- run6(gram) = 후반 하락 완화(안정화) + dense feature. HCC-ST 대부분 체크포인트가 OpenMidnight 상회. + +라이선스: 코드 = OpenMidnight/DINOv2 fork(해당 LICENSE 참조). 데이터 = 공개 병리(CC-BY/CC0/NIH-open). diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..9a0345173b2bd10a00491486ee16ebb17d96acec --- /dev/null +++ b/requirements.txt @@ -0,0 +1,14 @@ +fvcore==0.1.5.post20221221 +iopath==0.1.10 +numpy==2.4.6 +omegaconf==2.3.1 +pandas==2.2.3 +pillow==12.2.0 +scikit-learn==1.8.0 +scipy==1.17.1 +submitit==1.5.4 +timm==1.0.27 +torch==2.11.0+cu128 +torchvision==0.26.0+cu128 +webdataset==1.0.2 +xformers==0.0.35 diff --git a/scripts/autoresume_run6.sh b/scripts/autoresume_run6.sh new file mode 100644 index 0000000000000000000000000000000000000000..dfe232f5b401f1c0ee828b015b852c666747acd2 --- /dev/null +++ b/scripts/autoresume_run6.sh @@ -0,0 +1,45 @@ +#!/usr/bin/env bash +# run6(om_vitg14_run6) 크래시 내성 자동 재개 waiter. TJ-1(오케스트레이터)서 백그라운드 실행. +# - 완주(training_230000) 감지 → exit 0 +# - NaN 감지 → exit 2 (재개 안 함) +# - 크래시(전멸, 완주/NaN 아님) → 전노드 shm정리 후 launch_om_run6.sh로 resume(같은 OUT=마지막 체크포인트), 최대 MAX회 +# ★ host=TJ-2(alive/NaN 체크도 TJ-2). TJ-1은 학습 제외라 대상 아님. +set -u +P=/NHNHOME/WORKSPACE/0526040027_A/OpenPath +CFG=$P/third_party/OpenMidnight/dinov2/configs/train/openpath_vitg14_run6_native_gram.yaml +OUT=$P/data/runs/om_vitg14_run6 +LOG=$P/data/runs/om_logs/vitg_run6 +DONE=$OUT/eval/training_345000/teacher_checkpoint.pth +TJLOG=$LOG/TJ-2.log +NODES="TJ-2 TJ-3 TJ-4 TJ-5 TJ-6" +MAX=40 +retry=0 + +alive_count() { + timeout 12 ssh -o BatchMode=yes -o ConnectTimeout=8 TJ-2 "ps -eo args 2>/dev/null | grep '[t]rain.py' | wc -l" 2>/dev/null || echo 1 +} + +echo "[autoresume-run6] watching $OUT (host TJ-2, max $MAX auto-resumes)" +while true; do + [ -f "$DONE" ] && { echo "RUN2_DONE: 완주 (training_230000)"; exit 0; } + if grep -qiE "NaN detected" "$TJLOG" 2>/dev/null; then echo "RUN2_NAN: NaN 감지 — 자동재개 중단"; exit 2; fi + + a=$(alive_count) + if [ "${a:-1}" = "0" ]; then + sleep 60 + a2=$(alive_count) + if [ "${a2:-1}" = "0" ] && [ ! -f "$DONE" ]; then + grep -qiE "NaN detected" "$TJLOG" 2>/dev/null && { echo "RUN2_NAN"; exit 2; } + retry=$((retry+1)) + if [ "$retry" -gt "$MAX" ]; then echo "RUN2_GIVEUP: 자동재개 $MAX회 초과 — 수동 개입"; exit 3; fi + lastit=$(grep -E "helpers.py:110] Training" "$TJLOG" 2>/dev/null | tail -1 | grep -oE "\[ *[0-9]+/" | head -1) + echo "[autoresume-run6] CRASH detected at $lastit — auto-resume #$retry/$MAX" + for n in $NODES; do timeout 10 ssh -o BatchMode=yes "$n" "pkill -9 -f 'dinov2/train/train.py' 2>/dev/null; pkill -9 -f torchrun 2>/dev/null; rm -f /dev/shm/nccl* 2>/dev/null" 2>/dev/null; done + sleep 30 + bash "$P/scripts/launch_om_run2.sh" "omvitgrun6r${retry}" "$CFG" "$OUT" "$LOG" >/dev/null 2>&1 + echo "[autoresume-run6] relaunched (rdzv omvitgrun6r${retry}) — resume from last checkpoint" + sleep 180 + fi + fi + sleep 240 +done diff --git a/scripts/launch_om_run2.sh b/scripts/launch_om_run2.sh new file mode 100644 index 0000000000000000000000000000000000000000..f681d85697510cca40b0a7bfef31c1bb7721b89e --- /dev/null +++ b/scripts/launch_om_run2.sh @@ -0,0 +1,38 @@ +#!/usr/bin/env bash +# run2 학습 런처: TJ-2~6(5노드×8=40 GPU) FSDP. host=TJ-2, 워커=TJ-3~6. ★TJ-1은 학습 제외(eval watcher 전용). +# TJ-1(오케스트레이터)에서 실행 — 로컬 학습 프로세스 없음. host도 원격(ssh TJ-2)이라 자기참조 함정 없음. +# 사용: scripts/launch_om_run2.sh [extra train.py args...] +set -u +R=/NHNHOME/WORKSPACE/0526040027_A/OpenPath +RDZV="$1"; CFG="$2"; OUTDIR="$3"; LOGDIR="$4"; shift 4 +EXTRA="$*" +HOST="TJ-2" +EP="10.34.15.21:29500" # TJ-2 IB IP (rendezvous rank0) +WORKERS="TJ-3 TJ-4 TJ-5 TJ-6" +PYC="\$HOME/.cache/op_pyc_$RDZV" # 노드-로컬. 원격 셸에서 확장되도록 escape +ENV="WANDB_MODE=disabled NCCL_DEBUG=WARN NCCL_IB_HCA=mlx5_1,mlx5_2,mlx5_4,mlx5_9 \ +NCCL_SOCKET_IFNAME=bond0 GLOO_SOCKET_IFNAME=bond0 \ +NCCL_IB_TIMEOUT=22 NCCL_IB_RETRY_CNT=13 NCCL_IB_QPS_PER_CONNECTION=4 \ +PYTHONDONTWRITEBYTECODE=1 PYTHONPYCACHEPREFIX=$PYC PYTHONPATH=$R/third_party/OpenMidnight" +TR="venv/bin/torchrun --nnodes=5 --nproc-per-node=8 --rdzv-backend=c10d \ +--rdzv-endpoint=$EP --rdzv-id=$RDZV \ +third_party/OpenMidnight/dinov2/train/train.py --config-file $CFG --output-dir $OUTDIR $EXTRA" + +mkdir -p "$LOGDIR" "$OUTDIR" + +# 1) host(TJ-2) 원격 기동 — ★ssh를 &로 백그라운드(안 그러면 원격 setsid의 상속 fd를 물고 ssh가 반환 안 함=런처 행) +echo "launching host on $HOST ..." +ssh -n -o BatchMode=yes "$HOST" "mkdir -p $PYC; cd $R && setsid env $ENV $TR > $LOGDIR/${HOST}.log 2>&1 < /dev/null & echo ${HOST}-host-fired" & + +# 2) host torchrun가 store 바인딩할 시간(고정 대기). c10d는 워커가 재시도로 붙으므로 ss폴링 불필요. +echo "waiting 30s for host store bind on $EP ..." +sleep 30 +echo "firing 4 workers" + +# 3) 워커(TJ-3~6) 병렬 기동 +for n in $WORKERS; do + ssh -n -o BatchMode=yes "$n" "mkdir -p $PYC; cd $R && setsid env $ENV $TR > $LOGDIR/${n}.log 2>&1 < /dev/null & echo ${n}-fired" & +done +# ★ wait 대신 고정 sleep — bg ssh가 원격 setsid의 fd를 물어 반환 안 할 수 있어 wait는 영원히 멈춤(autoresume blocking 호출도 막힘). +sleep 20 +echo "ALL launched: host $HOST + workers $WORKERS | rdzv=$RDZV | logs=$LOGDIR | out=$OUTDIR" diff --git a/scripts/run_hest_3way.py b/scripts/run_hest_3way.py new file mode 100644 index 0000000000000000000000000000000000000000..c77af1f766189ad419a77545991270e619fb0f92 --- /dev/null +++ b/scripts/run_hest_3way.py @@ -0,0 +1,117 @@ +#!/usr/bin/env python3 +"""HEST-Benchmark 3자 비교 — Meta DINOv2 baseline / Phikon-v2 / OpenPath. +9 task(유전자발현 회귀, top-50 HVG, Ridge+PCA256, Pearson). 224px@0.5MPP, ImageNet norm. +benchmark()는 resnet50을 자동 기준으로 포함하므로 출력에 resnet50도 함께 나온다. + +실행(venv_hest): + PYTHONPATH=third_party/OpenMidnight:. venv_hest/bin/python scripts/run_hest_3way.py \ + --backbone om --weights data/runs/om_vitl14/eval/training_0/teacher_checkpoint.pth \ + --exp-code meta_dinov2_vitl14 [task1 ...] + PYTHONPATH=. venv_hest/bin/python scripts/run_hest_3way.py --backbone phikon --exp-code phikon_v2 +""" +import argparse +import os +import sys + +import torch +import torch.nn as nn +from torchvision import transforms + +ROOT = "/NHNHOME/WORKSPACE/0526040027_A/OpenPath" +BENCH = os.environ.get("HEST_BENCH_ROOT", f"{ROOT}/data/eva/hest_bench") +ALL = ["IDC", "PRAD", "PAAD", "SKCM", "COAD", "READ", "CCRCC", "LUNG", "LYMPH_IDC"] + +eval_tf = transforms.Compose([ + transforms.Resize(224), transforms.CenterCrop(224), transforms.ToTensor(), + transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), +]) + + +def build_om(weights): + """OpenMidnight teacher_checkpoint(ViT-L/14 reg4) → CLS nn.Module.""" + _OM = f"{ROOT}/third_party/OpenMidnight" + sys.path = [_OM] + [p for p in sys.path if "third_party/dinov2" not in p] + import dinov2.models.vision_transformer as vits + ck = torch.load(weights, map_location="cpu", weights_only=False) + t = ck["teacher"] if "teacher" in ck else ck + sd = {k[len("backbone."):]: v for k, v in t.items() if k.startswith("backbone.")} + # arch 자동감지: embed_dim 1536=giant(swiglu), 1024=large(mlp) + embed_dim = sd["cls_token"].shape[-1] + if embed_dim == 1536: + arch, ffn = "vit_giant2", "swiglufused" + else: + arch, ffn = "vit_large", "mlp" + m = getattr(vits, arch)(patch_size=14, img_size=224, block_chunks=4, num_register_tokens=4, + ffn_layer=ffn, init_values=1.0e-05, + interpolate_antialias=True, interpolate_offset=0.0) + miss, unexp = m.load_state_dict(sd, strict=True) + assert not miss and not unexp, f"miss={miss} unexp={unexp}" + print(f"[hest] arch={arch} embed_dim={embed_dim}", flush=True) + + class W(nn.Module): + def __init__(s, mm): super().__init__(); s.m = mm + @torch.no_grad() + def forward(s, x): return s.m.forward_features(x)["x_norm_clstoken"] + print(f"[hest] backbone=OM vit_large/14 reg4 tensors={len(sd)}", flush=True) + return W(m) + + +def build_phikon(): + from transformers import AutoModel + base = AutoModel.from_pretrained("owkin/phikon-v2") + + class W(nn.Module): + def __init__(s, b): super().__init__(); s.b = b + @torch.no_grad() + def forward(s, x): return s.b(pixel_values=x).last_hidden_state[:, 0, :] + print("[hest] backbone=Phikon-v2 (CLS)", flush=True) + return W(base) + + +def build_dinov3(model_id): + from transformers import AutoModel + base = AutoModel.from_pretrained(model_id) + + class W(nn.Module): + def __init__(s, b): super().__init__(); s.b = b + @torch.no_grad() + def forward(s, x): + out = s.b(pixel_values=x) + po = getattr(out, "pooler_output", None) + return po if po is not None else out.last_hidden_state[:, 0, :] + print(f"[hest] backbone=DINOv3 {model_id} (pooler/CLS)", flush=True) + return W(base) + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--backbone", required=True, choices=["om", "phikon", "dinov3"]) + ap.add_argument("--weights", default=None) + ap.add_argument("--dinov3-id", default=None, help="HF repo id, e.g. facebook/dinov3-vitl16-pretrain-lvd1689m") + ap.add_argument("--exp-code", required=True) + ap.add_argument("tasks", nargs="*") + args = ap.parse_args() + + if args.backbone == "om": + model = build_om(args.weights) + elif args.backbone == "dinov3": + model = build_dinov3(args.dinov3_id) + else: + model = build_phikon() + model = model.cuda().eval() + from hest.bench import benchmark + tasks = args.tasks or ALL + print(f"[hest] exp={args.exp_code} tasks={tasks}", flush=True) + dataset_perfs, perf_per_enc = benchmark( + model, eval_tf, torch.float32, + exp_code=args.exp_code, datasets=tasks, bench_data_root=BENCH, + embed_dataroot=os.environ.get("HEST_EMBED_ROOT", f"eval/ST_data_emb_{args.exp_code}"), + dimreduce="PCA", latent_dim=256, method="ridge", normalize=True, + ) + print(f"=== HEST per-encoder avg Pearson [{args.exp_code}] ===", perf_per_enc, flush=True) + for d in dataset_perfs: + print(f" {d.get('dataset_name')}: {d.get('results')}", flush=True) + + +if __name__ == "__main__": + main() diff --git a/scripts/watch_eval_run6.sh b/scripts/watch_eval_run6.sh new file mode 100644 index 0000000000000000000000000000000000000000..b7fdc24d2c6e4bb185e52ec2e3bb5a3c7d21b92a --- /dev/null +++ b/scripts/watch_eval_run6.sh @@ -0,0 +1,43 @@ +#!/usr/bin/env bash +# TJ-1 실시간 HEST eval watcher. run6 학습이 뱉는 teacher_checkpoint를 감지→probe→곡선 append. +# TJ-1 로컬 실행(venv_hest·GPU 로컬). 1개씩 순차(동시 HDF5 버그 회피, ~60min<체크포인트간격 ~84min라 페이스 유지). +# per-exp embed 분리(/dev/shm/hest_emb_run6_), pkill 미포함(self-kill 회피). +set -u +R=/NHNHOME/WORKSPACE/0526040027_A/OpenPath +OUTDIR=$R/data/runs/om_vitg14_run6 +EVALDIR=$OUTDIR/eval +RESDIR=$R/data/runs/hest_3way +CURVE=$RESDIR/run6_curve.txt +BENCH=/dev/shm/hest_bench +GPU=0 +mkdir -p "$RESDIR" + +# hest_bench를 TJ-1 /dev/shm에 확보(없으면 Lustre서 복사, 40G) +if [ ! -d "$BENCH" ] || [ "$(ls "$BENCH" 2>/dev/null | wc -l)" -lt 5 ]; then + echo "[watch] copying hest_bench -> $BENCH (40G, 수분) ..." + rm -rf "$BENCH"; cp -r "$R/data/eva/hest_bench" "$BENCH" +fi +echo "[watch] START — watching $EVALDIR (TJ-1 GPU$GPU, 1-at-a-time) | curve=$CURVE" + +cd "$R" +while true; do + for ck in $(ls -d "$EVALDIR"/training_* 2>/dev/null | sort -t_ -k2 -n); do + N=$(basename "$ck" | sed 's/training_//') + W="$ck/teacher_checkpoint.pth" + LOG="$RESDIR/run6_$N.log" + [ -f "$W" ] || continue + grep -q "per-encoder avg Pearson" "$LOG" 2>/dev/null && continue # 이미 완료 + EMB="/dev/shm/hest_emb_run6_$N" + rm -rf "$EMB" + echo "[watch] $(date '+%F %T') probing training_$N ..." + HEST_EMBED_ROOT="$EMB" HEST_BENCH_ROOT="$BENCH" HDF5_USE_FILE_LOCKING=FALSE \ + CUDA_VISIBLE_DEVICES=$GPU PYTHONPATH=third_party/OpenMidnight:. \ + venv_hest/bin/python -u scripts/run_hest_3way.py --backbone om --weights "$W" --exp-code "run6_$N" > "$LOG" 2>&1 + rm -rf "$EMB" + ce=$(grep "per-encoder avg Pearson" "$LOG" 2>/dev/null | tail -1 | grep -oE "'custom_encoder': [0-9.]+" | grep -oE "[0-9.]+") + rn=$(grep "per-encoder avg Pearson" "$LOG" 2>/dev/null | tail -1 | grep -oE "'resnet50': [0-9.]+" | grep -oE "[0-9.]+") + printf "%s\tours=%s\tresnet50=%s\t%s\n" "training_$N" "${ce:-FAIL}" "${rn:-NA}" "$(date '+%F %T')" >> "$CURVE" + echo "[watch] training_$N = ${ce:-FAIL}" + done + sleep 120 +done