Upload folder using huggingface_hub

OpenMidnight/.gitignore

@@ -1,46 +0,0 @@
-# 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

OpenMidnight/HEST_evaluation.py

@@ -1,51 +0,0 @@
-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, 
-)

OpenMidnight/LICENSE

@@ -1,203 +0,0 @@
-
-
-                                 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.

OpenMidnight/README.md

@@ -1,225 +0,0 @@
-<h1> OpenMidnight </h1>
-
-<p align="center"><img width="735" height="400" alt="2PJpVl2k51pfjFg2Vs-oS" src="https://github.com/user-attachments/assets/fd00a9f5-3248-46ed-883a-f423e54ac2b6" /></p>
-<p align="center">Fully open-source and improved replication of Kaiko.AI's pathology foundation model <a href="https://arxiv.org/abs/2504.05186v1">Midnight</a>.</p>
-<div id="badges" align="center">
-  <a href="https://sophont.med/blog/openmidnight"><img src="https://img.shields.io/badge/Blog-Training%20SOTA%20Pathology%20Foundation%20Model%20with%20%241.6k-111827?style=for-the-badge&logo=read.cv&logoColor=white" /> </a>
-  <a href="https://discord.gg/tVR4TWnRM9"><img src="https://img.shields.io/badge/Discord-Collaborate%20with%20us-5865F2?style=for-the-badge&logo=discord&logoColor=white" /></a>     
-</div>
-<p align="center"> <a href="https://sophont.med">Sophont</a> · <a href="https://medarc.ai">MedARC</a> </p>
-
-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=<your HF token here>` 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_<iter>/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}, 
-}
-```
-

OpenMidnight/_utils.py

@@ -1,166 +0,0 @@
-"""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 ``<hub_dir>/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))

OpenMidnight/dinov2/__init__.py

@@ -1,6 +0,0 @@
-# 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"

OpenMidnight/dinov2/configs/__init__.py

@@ -1,22 +0,0 @@
-# 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)

OpenMidnight/dinov2/configs/eval/vitb14_pretrain.yaml

@@ -1,6 +0,0 @@
-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

OpenMidnight/dinov2/configs/eval/vitb14_reg4_pretrain.yaml

@@ -1,9 +0,0 @@
-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

OpenMidnight/dinov2/configs/eval/vitg14_pretrain.yaml

@@ -1,7 +0,0 @@
-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

OpenMidnight/dinov2/configs/eval/vitg14_reg4_pretrain.yaml

@@ -1,10 +0,0 @@
-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

OpenMidnight/dinov2/configs/eval/vitl14_pretrain.yaml

@@ -1,6 +0,0 @@
-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

OpenMidnight/dinov2/configs/eval/vitl14_reg4_pretrain.yaml

@@ -1,9 +0,0 @@
-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

OpenMidnight/dinov2/configs/eval/vits14_pretrain.yaml

@@ -1,6 +0,0 @@
-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

OpenMidnight/dinov2/configs/eval/vits14_reg4_pretrain.yaml

@@ -1,9 +0,0 @@
-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

OpenMidnight/dinov2/configs/ssl_default_config.yaml

@@ -1,129 +0,0 @@
-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: ""

OpenMidnight/dinov2/configs/train/openpath_vitg14.yaml

@@ -1,95 +0,0 @@
-# OpenPath — ViT-g/14 pathology FM pre-training config.
-# DINOv2 (DINO + iBOT + KDE) + gram anchoring, warm-started from Meta DINOv2 ViT-g/14-reg,
-# on the public OpenPath corpus (native 40x tiles). Global batch = 64/GPU x 40 GPU = 2560.
-#
-# LR regime: near-constant (flat). `epochs` only sets the schedule horizon (very large), so the
-# cosine barely descends; the run actually stops at `early_stop`. This keeps LR/wd/momentum
-# near their initial values throughout training.
-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:
-  # OpenPath corpus (taejoon89/openpath-corpus). Point to the downloaded shards:
-  sample_list_path: "openpath:glob=/path/to/openpath-corpus/*/tiles/shards/w*/*.tar"
-  streaming_from_hf: false
-  batch_size_per_gpu: 64          # x 40 GPU = global 2560
-  centering: sinkhorn_knopp
-  use_pretrained: True            # Meta DINOv2 ViT-g/14-reg warm-start (set MODEL.WEIGHTS)
-  OFFICIAL_EPOCH_LENGTH: 1250
-  saveckp_freq: 8                 # resume ckpt every 8 x 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
-optim:
-  epochs: 8000                    # schedule horizon only (=10,000,000 iter); LR/wd/momentum near-constant
-  early_stop: 276                 # actual stop: 276 x 1250 = 345,000 iters (~1 native epoch)
-  weight_decay_end: 0.2           # not reached within early_stop (wd stays ~0.040)
-  base_lr: 2.0e-04                # sqrt_wrt_1024 -> effective ~3.16e-4 @ global 2560
-  warmup_epochs: 9                # ~11,250 iter (~4.9%); must be an integer
-  freeze_last_layer_epochs: 1
-  layerwise_decay: 1.0
-crops:
-  local_crops_size: 98
-evaluation:
-  eval_period_iterations: 5750    # save a teacher checkpoint every 5,750 iters
-  bach_root: ""
-  breakhis_root: ""
-  pcam_root: ""
-
-# Gram anchoring (ported from DINOv3): MSE between L2-normalized patch-token Gram matrices of
-# student vs a frozen anchor. Dampens dense-feature degradation during long training.
-gram:
-  use_loss: true
-  normalized: true
-  remove_neg: true
-  loss_weight: 40.0            # ~5-8% of total loss; lower if it over-constrains DINO/iBOT
-  it_first_update: 57500       # activate near the dense-feature peak
-  ramp_iters: 3000             # linear ramp of the gram weight
-  # Anchor = a strong earlier OpenPath teacher checkpoint (see taejoon89/openpath-checkpoints):
-  ckpt: /path/to/openpath-checkpoints/training_63250/teacher_checkpoint.pth

OpenMidnight/dinov2/configs/train/openpath_vitg14_bs64_test.yaml

@@ -1,84 +0,0 @@
-# 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: ""

OpenMidnight/dinov2/configs/train/openpath_vitg14_curated.yaml

@@ -1,57 +0,0 @@
-# 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: ""

OpenMidnight/dinov2/configs/train/openpath_vitg14_final.yaml

@@ -1,80 +0,0 @@
-# ★★ 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: ""

OpenMidnight/dinov2/configs/train/openpath_vitg14_final_1ep.yaml

@@ -1,59 +0,0 @@
-# ★ 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: ""

OpenMidnight/dinov2/configs/train/openpath_vitg14_final_1ep_bs64.yaml

@@ -1,59 +0,0 @@
-# ★ 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: ""

OpenMidnight/dinov2/configs/train/openpath_vitg14_full.yaml

@@ -1,55 +0,0 @@
-# 풀코퍼스 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: ""

OpenMidnight/dinov2/configs/train/openpath_vitg14_full_cptac.yaml

@@ -1,55 +0,0 @@
-# 풀코퍼스 + 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: ""

OpenMidnight/dinov2/configs/train/openpath_vitg14_run2.yaml

@@ -1,84 +0,0 @@
-# ★★ 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: ""

OpenMidnight/dinov2/configs/train/openpath_vitg14_run3_gram.yaml

@@ -1,92 +0,0 @@
-# ★★ 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

OpenMidnight/dinov2/configs/train/openpath_vitg14_run3_smoke.yaml

@@ -1,92 +0,0 @@
-# ★★ 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

OpenMidnight/dinov2/configs/train/openpath_vitg14_run4_gram.yaml

@@ -1,92 +0,0 @@
-# ★★ 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

OpenMidnight/dinov2/configs/train/openpath_vitg14_run5_native.yaml

@@ -1,84 +0,0 @@
-# ★★ 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: ""

OpenMidnight/dinov2/configs/train/openpath_vitg14_run6_native_gram.yaml

@@ -1,93 +0,0 @@
-# ★★ 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

OpenMidnight/dinov2/configs/train/openpath_vitg14_testB.yaml

@@ -1,54 +0,0 @@
-# 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: ""

OpenMidnight/dinov2/configs/train/openpath_vitl14_reg4.yaml

@@ -1,58 +0,0 @@
-# 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: ""

OpenMidnight/dinov2/configs/train/openpath_vitl14_reg4_curated.yaml

@@ -1,58 +0,0 @@
-# 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: ""

OpenMidnight/dinov2/configs/train/openpath_vitl14_testB.yaml

@@ -1,59 +0,0 @@
-# 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: ""

OpenMidnight/dinov2/configs/train/vitg14_reg4.yaml

@@ -1,51 +0,0 @@
-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

OpenMidnight/dinov2/configs/train/vits14_reg4.yaml

@@ -1,51 +0,0 @@
-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

OpenMidnight/dinov2/data/__init__.py

@@ -1,10 +0,0 @@
-# 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

OpenMidnight/dinov2/data/adapters.py

@@ -1,28 +0,0 @@
-# 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)

OpenMidnight/dinov2/data/augmentations.py

@@ -1,383 +0,0 @@
-# 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

OpenMidnight/dinov2/data/collate.py

@@ -1,62 +0,0 @@
-# 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
-    }

OpenMidnight/dinov2/data/datasets/__init__.py

@@ -1,9 +0,0 @@
-# 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

OpenMidnight/dinov2/data/datasets/decoders.py

@@ -1,31 +0,0 @@
-# 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

OpenMidnight/dinov2/data/datasets/extended.py

@@ -1,38 +0,0 @@
-# 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

OpenMidnight/dinov2/data/datasets/image_net.py

@@ -1,290 +0,0 @@
-# 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", "<u4"),
-                ("class_index", "<u4"),
-                ("class_id", f"U{max_class_id_length}"),
-                ("class_name", f"U{max_class_name_length}"),
-            ]
-        )
-        entries_array = np.empty(sample_count, dtype=dtype)
-
-        if split == ImageNet.Split.TEST:
-            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
-
-                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()

OpenMidnight/dinov2/data/datasets/image_net_22k.py

@@ -1,302 +0,0 @@
-# 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", "<u4"),
-                ("class_id", f"U{max_class_id_length}"),
-                ("start_offset", "<u4"),
-                ("end_offset", "<u4"),
-                ("filename", f"U{max_filename_length}"),
-            ]
-        )
-        sample_count = len(entries)
-        entries_array = np.empty(sample_count, dtype=dtype)
-        for i, entry in enumerate(entries):
-            class_index = entry.class_index
-            class_id = class_ids[class_index]
-            start_offset = entry.start_offset
-            end_offset = entry.end_offset
-            filename = entry.filename
-            entries_array[i] = (
-                class_index,
-                class_id,
-                start_offset,
-                end_offset,
-                filename,
-            )
-
-        entries_path = self._get_entries_path(*args, **kwargs)
-        self._save_extra(entries_array, entries_path)
-
-    def _dump_class_ids(self, *args, **kwargs) -> 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)

OpenMidnight/dinov2/data/datasets/slide_dataset.py

@@ -1,99 +0,0 @@
-# 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)

OpenMidnight/dinov2/data/loaders.py

@@ -1,229 +0,0 @@
-# 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

OpenMidnight/dinov2/data/masking.py

@@ -1,86 +0,0 @@
-# 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

OpenMidnight/dinov2/data/openpath_wds.py

@@ -1,229 +0,0 @@
-# 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,
-    )

OpenMidnight/dinov2/data/samplers.py

@@ -1,229 +0,0 @@
-# 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