Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,11 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Hugging Face Hub / Git LFS — большие бинарники
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+assets/architecture_pipeline.png filter=lfs diff=lfs merge=lfs -text
+assets/interpretability_pca_saliency.png filter=lfs diff=lfs merge=lfs -text
+assets/learning_curves.png filter=lfs diff=lfs merge=lfs -text
+assets/teaser_ordinal_scale.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+# Не скрывать веса при подготовке к upload_folder — только мусор среды
+__pycache__/
+# Локальный список картинок для пересборки README (не в assets/)
+figures_config.yaml
+*.py[cod]
+.venv/
+venv/
+.env
+.DS_Store

LICENSE

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

LICENSE-DINOv3-Meta.txt

@@ -0,0 +1,65 @@
+# DINOv3 License
+
+Last Updated: August 19, 2025
+
+“Agreement” means the terms and conditions for use, reproduction, distribution and modification of the DINO Materials set forth herein.
+
+“DINO Materials” means, collectively, Documentation and the models, software and algorithms, including machine-learning model code, trained model weights, inference-enabling code, training-enabling code, fine-tuning enabling code, and other elements of the foregoing distributed by Meta and made available under this Agreement.
+
+“Documentation” means the specifications, manuals and documentation accompanying DINO Materials distributed by Meta.
+
+“Licensee” or “you” means you, or your employer or any other person or entity (if you are entering into this Agreement on such person or entity’s behalf), of the age required under applicable laws, rules or regulations to provide legal consent and that has legal authority to bind your employer or such other person or entity if you are entering in this Agreement on their behalf.
+
+“Meta” or “we” means Meta Platforms Ireland Limited (if you are located in or, if you are an entity, your principal place of business is in the EEA or Switzerland) or Meta Platforms, Inc. (if you are located outside of the EEA or Switzerland).
+
+“Sanctions” means any economic or trade sanctions or restrictions administered or enforced by the United States (including the Office of Foreign Assets Control of the U.S. Department of the Treasury (“OFAC”), the U.S. Department of State and the U.S. Department of Commerce), the United Nations, the European Union, or the United Kingdom.
+
+“Trade Controls” means any of the following: Sanctions and applicable export and import controls.
+
+By clicking “I Accept” below or by using or distributing any portion or element of the DINO Materials, you agree to be bound by this Agreement.
+
+## 1. License Rights and Redistribution.
+
+a. Grant of Rights. You are granted a non-exclusive, worldwide, non-transferable and royalty-free limited license under Meta’s intellectual property or other rights owned by Meta embodied in the DINO Materials to use, reproduce, distribute, copy, create derivative works of, and make modifications to the DINO Materials.
+
+b. Redistribution and Use.
+
+i. Distribution of DINO Materials, and any derivative works thereof, are subject to the terms of this Agreement. If you distribute or make the DINO Materials, or any derivative works thereof, available to a third party, you may only do so under the terms of this Agreement and you shall provide a copy of this Agreement with any such DINO Materials.
+
+ii. If you submit for publication the results of research you perform on, using, or otherwise in connection with DINO Materials, you must acknowledge the use of DINO Materials in your publication.
+
+iii. Your use of the DINO Materials must comply with applicable laws and regulations, including Trade Control Laws and applicable privacy and data protection laws.
+
+iv. Your use of the DINO Materials will not involve or encourage others to reverse engineer, decompile or discover the underlying components of the DINO Materials.
+
+v. You are not the target of Trade Controls and your use of DINO Materials must comply with Trade Controls. You agree not to use, or permit others to use, DINO Materials for any activities subject to the International Traffic in Arms Regulations (ITAR) or end uses prohibited by Trade Controls, including those related to military or warfare purposes, nuclear industries or applications, espionage, or the development or use of guns or illegal weapons.
+
+## 2. User Support.
+
+Your use of the DINO Materials is done at your own discretion; Meta does not process any information nor provide any service in relation to such use. Meta is under no obligation to provide any support services for the DINO Materials. Any support provided is “as is”, “with all faults”, and without warranty of any kind.
+
+## 3. Disclaimer of Warranty.
+
+UNLESS REQUIRED BY APPLICABLE LAW, THE DINO MATERIALS AND ANY OUTPUT AND RESULTS THEREFROM ARE PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OF ANY KIND, AND META DISCLAIMS ALL WARRANTIES OF ANY KIND, BOTH EXPRESS AND IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING THE DINO MATERIALS AND ASSUME ANY RISKS ASSOCIATED WITH YOUR USE OF THE DINO MATERIALS AND ANY OUTPUT AND RESULTS.
+
+## 4. Limitation of Liability.
+
+IN NO EVENT WILL META OR ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, ARISING OUT OF THIS AGREEMENT, FOR ANY LOST PROFITS OR ANY DIRECT OR INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL, EXEMPLARY OR PUNITIVE DAMAGES, EVEN IF META OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF ANY OF THE FOREGOING.
+
+## 5. Intellectual Property.
+
+a. Subject to Meta’s ownership of DINO Materials and derivatives made by or for Meta, with respect to any derivative works and modifications of the DINO Materials that are made by you, as between you and Meta, you are and will be the owner of such derivative works and modifications.
+
+b. If you institute litigation or other proceedings against Meta or any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the DINO Materials, outputs or results, or any portion of any of the foregoing, constitutes infringement of intellectual property or other rights owned or licensable by you, then any licenses granted to you under this Agreement shall terminate as of the date such litigation or claim is filed or instituted. You will indemnify and hold harmless Meta from and against any claim by any third party arising out of or related to your use or distribution of the DINO Materials.
+
+## 6. Term and Termination.
+
+The term of this Agreement will commence upon your acceptance of this Agreement or access to the DINO Materials and will continue in full force and effect until terminated in accordance with the terms and conditions herein. Meta may terminate this Agreement if you are in breach of any term or condition of this Agreement. Upon termination of this Agreement, you shall delete and cease use of the DINO Materials. Sections 3, 4 and 7 shall survive the termination of this Agreement.
+
+## 7. Governing Law and Jurisdiction.
+
+This Agreement will be governed and construed under the laws of the State of California without regard to choice of law principles, and the UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement. The courts of California shall have exclusive jurisdiction of any dispute arising out of this Agreement.
+
+## 8. Modifications and Amendments.
+
+Meta may modify this Agreement from time to time; provided that they are similar in spirit to the current version of the Agreement, but may differ in detail to address new problems or concerns. All such changes will be effective immediately. Your continued use of the DINO Materials after any modification to this Agreement constitutes your agreement to such modification. Except as provided in this Agreement, no modification or addition to any provision of this Agreement will be binding unless it is in writing and signed by an authorized representative of both you and Meta.

NOTICE

@@ -0,0 +1,22 @@
+Anime.MILI Ordinal — Hugging Face model repository
+
+This repository includes:
+
+1) Inference code (Python package `mili_score_inference/`), `example_predict.py`,
+   `requirements.txt`, and documentation in `README.md`, licensed under the
+   Apache License, Version 2.0 — see the file `LICENSE`.
+
+2) Fine-tuned checkpoint weights (`weights/anime_mili_ordinal_corn_vitl16.pth`)
+   are distributed by the repository authors under the Apache License, Version 2.0,
+   to the extent they constitute an original contribution separate from Meta’s
+   DINO Materials. Such weights are a derivative of a DINOv3-based backbone;
+   use and redistribution of the backbone weights themselves are governed by
+   Meta’s DINOv3 License — see `LICENSE-DINOv3-Meta.txt`.
+
+3) Optional bundled pretrained backbone files under `backbone/dinov3_vitl16/`
+   (and users who load DINOv3 from Hugging Face, e.g.
+   `facebook/dinov3-vitl16-pretrain-lvd1689m`) must comply with Meta’s DINOv3
+   License and the terms on the model card.
+
+For third-party notices required by the Apache License, see this file and
+`LICENSE-DINOv3-Meta.txt`.

README.md

@@ -1,3 +1,192 @@
 ---
 license: apache-2.0
+language:
+  - en
+library_name: pytorch
+tags:
+  - pytorch
+  - vision
+  - ordinal-regression
+  - dinov3
+  - anime
+  - anime-mili-ordinal
+pipeline_tag: image-classification
 ---
+
+# Anime.MILI Ordinal
+
+*Ordinal Regression of Subjective Visual Characteristics via Feature Adaptation of Self-Supervised Vision Transformers*
+
+Release weights: **`anime_mili_ordinal_corn_vitl16.pth`** — full `state_dict` (DINOv3 ViT-L/16 + CORN head). Outputs a continuous subjective score in **[0, 1]**. A local DINOv3 backbone may be included under `backbone/dinov3_vitl16/` (Meta DINOv3 License); the same architecture can be loaded from Hugging Face by model id.
+
+## Abstract
+
+Estimating subjective visual metrics, such as the mili characteristic, requires models capable of mapping input images to a strictly ordered scale. Traditional multiclass classification ignores the internal hierarchy of quality levels. Standard continuous regression approaches suffer from vanishing gradients at scale boundaries and instability when processing unevenly distributed ordinal data. This technical release presents an architecture based on the DINOv3 vision transformer, adapted specifically for ordinal regression. The implementation utilizes a two-phase training method: initial freezing of the backbone to warm up a specialized multi-layer perceptron, followed by partial fine-tuning of the final transformer blocks. Employing a Conditional Ordinal Regression Network (CORN) loss function allows the model to explicitly enforce rank monotonicity. Evaluation on a dataset of 4,715 images demonstrates a Quadratic Weighted Kappa (QWK) of 0.74. The results confirm the efficacy of combining self-supervised features with ordinal-aware architectures for visual quality assessment.
+
+### Teaser: ordinal scale with validation examples
+
+Two validation images per ordinal bin (columns **0.00 … 1.00**).
+
+![Teaser: ordinal scale and example images per bin](assets/teaser_ordinal_scale.png)
+
+## Introduction
+
+Human assessment of visual characteristics frequently relies on discrete quality levels that form an ordinal structure. The mili attribute represents a human-centric score measured on a scale from 0 to 1 with fixed 0.25 increments. Standard neural network architectures typically process such values either as independent classes, discarding the distance information between them, or as continuous regression targets. Utilizing Mean Squared Error (MSE) for regression tasks with fixed boundaries minimizes derivatives during extreme predictions, restricting the ability of the model to correct severe errors.
+
+The development of self-supervised methods, particularly the DINOv3 architecture, provides access to universal visual features that encode both high-level semantics and low-level structural patterns. Applying frozen DINOv3 features to highly specialized downstream tasks necessitates specific adaptation mechanisms. The current architecture transforms the base DINOv3 representations into a probabilistic representation of an ordinal scale. Replacing standard classification layers with an architecture that predicts the conditional probabilities of exceeding each scale threshold ensures increased prediction accuracy and stability.
+
+## Related Work
+
+Vision transformers consistently demonstrate high efficiency in feature extraction tasks compared to convolutional neural networks. Self-supervised methods utilize feature distillation and regularization to construct robust global and local descriptors. Adapting these models for regression tasks traditionally relies on L1 and L2 loss functions, which assume symmetric error penalties.
+
+Ordinal regression accounts for label ranking, a critical requirement for subjective evaluations. The CORN framework addresses this by decomposing the ordinal problem into a series of binary classifications for each rank threshold. The implementation detailed here extends the application of CORN logic by integrating it on top of the high-capacity DINOv3 transformer architecture. It employs partial weight unfreezing strategies to preserve the generalization capabilities of the self-supervised features while adapting to the target domain.
+
+## Method
+
+The architecture utilizes a pre-trained DINOv3 ViT-L/16 backbone as the primary feature extractor. Input images are processed at a resolution of 224×224 pixels. To maintain the integrity of the self-supervised representations, the base network remains frozen during the initial training phase. The output of the base network is the **[CLS]** token: a vector whose dimension matches the backbone hidden size (1024 in the released checkpoint), aggregating global image information.
+
+### Pipeline diagram (CORN on frozen / partially unfrozen DINOv3)
+
+![Architecture: image → DINOv3 → CLS → MLP head → CORN logits → expected ordinal score](assets/architecture_pipeline.png)
+
+The specialized head is a multi-layer perceptron optimized for ordinal estimation. The sequence consists of a LayerNorm operation, a Dropout layer with a 0.2 probability, a linear projection into a 256-dimensional hidden space, a GELU activation function, an additional Dropout layer at 0.1, and a final linear projection. Unlike standard DINOv3 classification usage, the final layer returns K−1 logits for K quality levels, specifically yielding 4 logits for the 5 target classes.
+
+Optimization is driven by the CORN loss function, calculated as the sum of binary cross-entropy terms for each ordinal threshold. For a target label belonging to the set of ranks 0 through 4, the model predicts the probability of the rank exceeding a threshold k. The expected class is computed as the sum of probabilities across all thresholds. This loss function forces the model to learn the cumulative distribution of quality levels, guaranteeing the mathematical consistency of the ordinal scale.
+
+## Experiments
+
+The dataset comprises 4,715 images, partitioned into a 3,771-image training split and a 944-image validation split. Labels are distributed unevenly across five classes: 1,204 samples for class 0.00, 513 for class 0.25, 949 for class 0.50, 1,394 for class 0.75, and 655 for class 1.00.
+
+### Train / validation distribution (real counts)
+
+Bar heights are **file counts per ordinal bin** in the training and validation splits used for this release.
+
+![Dataset distribution: train vs validation per ordinal bin](assets/dataset_distribution.png)
+
+The training procedure spans two phases. In the first phase, spanning 5 epochs, only the head weights are updated with a learning rate of 3e-4. This calibrates the classifier to the fixed DINOv3 features. In the second phase, lasting 30 epochs, the final 6 transformer blocks are unfrozen. The learning rate is reduced to 2e-5 and regulated by a Cosine Annealing schedule. Optimization utilizes the AdamW algorithm with a weight decay coefficient of 1e-3.
+
+To increase inference reliability, Test-Time Augmentation (TTA) is applied. Each validation image is processed in three variations: original, horizontally flipped, and center-cropped. The logits from the three passes are averaged before calculating the expected class. Model evaluation relies on the Quadratic Weighted Kappa metric, which penalizes predictions proportionally to the squared distance between the true and predicted ranks.
+
+## Results
+
+The two-phase training strategy produces a consistent performance increase. During the first phase, utilizing a completely frozen backbone, the model reaches a QWK of 0.54. This establishes a strong baseline derived entirely from the raw DINOv3 features. Transitioning to the second phase with partial unfreezing of the transformer blocks facilitates further metric growth.
+
+The validation loss steadily decreases, reaching a minimum of 0.38, while the QWK stabilizes at 0.74. The discrepancy between training and validation errors remains minimal throughout the training process. The combination of the CORN loss function and the TTA algorithm prevents the severe overfitting observed in early experimental iterations that utilized standard MSE and a fully unfrozen backbone.
+
+### Learning curves
+
+Train/val CORN loss and validation QWK by epoch (dashed line: start of phase 2 — last six transformer blocks unfrozen). The GIF animates the QWK curve over epochs.
+
+![Learning curves: CORN loss and validation QWK](assets/learning_curves.png)
+
+![Animation: validation QWK over training](assets/learning_qwk_animation.gif)
+
+## Discussion
+
+The efficiency of the described architecture stems from the mathematical alignment between the CORN loss function and the QWK metric. Decomposing the task into predicting conditional probabilities for each threshold eliminates the vanishing gradient problem. The model receives a stable error signal even when predictions deviate significantly from the true value.
+
+The success of incorporating DINOv3 lies in the high resilience of its self-supervised features to visual noise. The two-phase training strategy is critical for preserving these features. The initial freezing prevents the destruction of the complex transformer attention system by random gradients from the uninitialized head. The subsequent unfreezing of the final layers allows the model to adjust its perception of specific textural and geometric patterns relevant exclusively to the mili characteristic. The stabilization of the metric by the 30th epoch indicates complete assimilation of patterns from the available training volume.
+
+### Ordinal confusion matrix (validation, single-view inference)
+
+Cell counts: validation labels vs. predicted bins (rounded). Weights file: `anime_mili_ordinal_corn_vitl16.pth`.
+
+![Confusion matrix on validation set](assets/confusion_matrix.png)
+
+### Self-supervised features vs. gradient saliency
+
+Each row: input · PCA of DINOv3 patch tokens (after register tokens) · saliency from the CORN head path.
+
+![Interpretability: PCA of DINOv3 patches and input saliency](assets/interpretability_pca_saliency.png)
+
+## Limitations
+
+1. The computational complexity of the ViT-L/16 architecture requires significant hardware resources for inference, complicating deployment on memory-constrained devices.
+2. The mathematical formulation for calculating the expected class implicitly assumes equidistant intervals between classes, potentially failing to fully reflect the non-linear nature of human quality perception.
+3. The dataset imbalance, specifically the prevalence of the 0.00 and 0.75 classes over the 0.25 class, introduces a risk of prediction bias toward majority classes despite the use of robust loss functions.
+4. The performance improvement achieved through Test-Time Augmentation triples the inference latency, severely limiting application in real-time systems.
+
+## Conclusion
+
+The described architecture provides a framework for ordinal regression of subjective visual evaluations using DINOv3 features. The methodology connects self-supervised visual representations with domain-specific ordinal classification via a CORN head and phased fine-tuning. The reported metrics support ordinal consistency as a training objective for human-centric quality scores.
+
+---
+
+## Repository layout
+
+| Path | Description |
+|------|-------------|
+| `mili_score_inference/` | Package: architecture, preprocessing, `load_model`, `predict_pil` |
+| `weights/anime_mili_ordinal_corn_vitl16.pth` | Fine-tuned full checkpoint (backbone + CORN head) |
+| `backbone/dinov3_vitl16/` | Local DINOv3 ViT-L/16 HF-format checkpoint (`config.json`, `model.safetensors`, …) for offline inference |
+| `requirements.txt` | Inference dependencies |
+| `example_predict.py` | CLI: image → score |
+| `LICENSE` | Apache 2.0 — code and Anime.MILI Ordinal weights in this repository |
+| `LICENSE-DINOv3-Meta.txt` | Meta DINOv3 License (bundled backbone and Hub DINOv3 use) |
+| `NOTICE` | Licensing summary |
+| `assets/` | Figures for this README |
+
+## Installation
+
+```bash
+pip install -r requirements.txt
+export PYTHONPATH="$PWD"   # Linux/macOS
+# set PYTHONPATH=%CD%       # Windows cmd
+```
+
+## Quick start (local backbone)
+
+```python
+from pathlib import Path
+from PIL import Image
+import torch
+from mili_score_inference.predict import load_model, predict_pil
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = load_model(
+    Path("weights/anime_mili_ordinal_corn_vitl16.pth"),
+    Path("backbone/dinov3_vitl16"),
+    device=device,
+    local_backbone=True,
+)
+score = predict_pil(model, Image.open("photo.jpg"), device=device)
+print(score)
+```
+
+## Backbone from Hugging Face Hub
+
+`load_model` accepts either a path to `backbone/dinov3_vitl16` or the Hub model id **`facebook/dinov3-vitl16-pretrain-lvd1689m`** (gated; Meta terms on the model card apply).
+
+```python
+model = load_model(
+    Path("weights/anime_mili_ordinal_corn_vitl16.pth"),
+    "facebook/dinov3-vitl16-pretrain-lvd1689m",
+    device=device,
+    local_backbone=False,
+)
+```
+
+Use the same model id as in training (`from_pretrained`).
+
+## CLI
+
+```bash
+python example_predict.py \
+  --weights weights/anime_mili_ordinal_corn_vitl16.pth \
+  --backbone backbone/dinov3_vitl16 \
+  --image photo.jpg
+```
+
+For Hub-only backbone, pass `--backbone facebook/dinov3-vitl16-pretrain-lvd1689m` instead of a local directory.
+
+## Licensing
+
+- **Code, documentation, and fine-tuned checkpoint** in this repository: **Apache License 2.0** (`LICENSE`).
+- **DINOv3 architecture and pretrained weights** are subject to Meta’s **DINOv3 License** (`LICENSE-DINOv3-Meta.txt`). When loading a backbone from the Hub, follow that model card’s terms.
+- Details: **`NOTICE`**.
+
+Domain-specific scores reflect the training distribution; use only in appropriate scenarios.
+
+## Citation
+
+Cite this repository when using the release. For research publications, acknowledge use of DINO Materials per Meta’s requirements (see `LICENSE-DINOv3-Meta.txt`).

backbone/README.txt

@@ -0,0 +1,5 @@
+Directory `dinov3_vitl16/` holds a Hugging Face–format DINOv3 ViT-L/16 checkpoint
+(`config.json`, `model.safetensors`, `preprocessor_config.json`) for offline inference.
+
+Weights are DINO Materials under Meta’s DINOv3 License — see `../LICENSE-DINOv3-Meta.txt`.
+Upstream Hub id: `facebook/dinov3-vitl16-pretrain-lvd1689m` (gated).

backbone/dinov3_vitl16/config.json

@@ -0,0 +1,32 @@
+{
+  "architectures": [
+    "DINOv3ViTModel"
+  ],
+  "attention_dropout": 0.0,
+  "drop_path_rate": 0.0,
+  "dtype": "float32",
+  "hidden_act": "gelu",
+  "hidden_size": 1024,
+  "image_size": 224,
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "key_bias": false,
+  "layer_norm_eps": 1e-05,
+  "layerscale_value": 1.0,
+  "mlp_bias": true,
+  "model_type": "dinov3_vit",
+  "num_attention_heads": 16,
+  "num_channels": 3,
+  "num_hidden_layers": 24,
+  "num_register_tokens": 4,
+  "patch_size": 16,
+  "pos_embed_jitter": null,
+  "pos_embed_rescale": 2.0,
+  "pos_embed_shift": null,
+  "proj_bias": true,
+  "query_bias": true,
+  "rope_theta": 100.0,
+  "transformers_version": "4.57.6",
+  "use_gated_mlp": false,
+  "value_bias": true
+}

backbone/dinov3_vitl16/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dcb2e45127cccbf1601e5f42fef165eea275c8e5213197e8dcf3f48822718179
+size 1212559808

backbone/dinov3_vitl16/preprocessor_config.json

@@ -0,0 +1,33 @@
+{
+  "crop_size": null,
+  "data_format": "channels_first",
+  "default_to_square": true,
+  "device": null,
+  "disable_grouping": null,
+  "do_center_crop": null,
+  "do_convert_rgb": null,
+  "do_normalize": true,
+  "do_pad": null,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.485,
+    0.456,
+    0.406
+  ],
+  "image_processor_type": "DINOv3ViTImageProcessorFast",
+  "image_std": [
+    0.229,
+    0.224,
+    0.225
+  ],
+  "input_data_format": null,
+  "pad_size": null,
+  "resample": 2,
+  "rescale_factor": 0.00392156862745098,
+  "return_tensors": null,
+  "size": {
+    "height": 224,
+    "width": 224
+  }
+}

example_predict.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""CLI: image path to mili score in [0, 1]. --backbone: local directory or Hugging Face model id."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import torch
+from PIL import Image
+
+from mili_score_inference.predict import load_model, predict_pil
+
+
+def main() -> int:
+    p = argparse.ArgumentParser()
+    p.add_argument("--weights", type=Path, required=True)
+    p.add_argument(
+        "--backbone",
+        type=str,
+        required=True,
+        help="Local checkpoint directory or Hugging Face model id",
+    )
+    p.add_argument("--image", type=Path, required=True)
+    p.add_argument("--device", default="auto")
+    args = p.parse_args()
+
+    if args.device == "auto":
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    else:
+        device = torch.device(args.device)
+
+    bb = Path(args.backbone)
+    if bb.is_dir():
+        backbone_arg: Path | str = bb
+        local_bb = True
+    else:
+        backbone_arg = args.backbone
+        local_bb = False
+
+    model = load_model(
+        args.weights,
+        backbone_arg,
+        device=device,
+        local_backbone=local_bb,
+    )
+    score = predict_pil(model, Image.open(args.image), device=device)
+    print(f"score={score:.6f}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mili_score_inference/__init__.py

@@ -0,0 +1,15 @@
+"""Inference: ordinal (CORN) score on top of DINOv3 ViT."""
+
+from mili_score_inference.model import MiliModelCORN
+from mili_score_inference.predict import (
+    logits_to_score_01,
+    predict_expected_class,
+    predict_pil,
+)
+
+__all__ = [
+    "MiliModelCORN",
+    "predict_expected_class",
+    "logits_to_score_01",
+    "predict_pil",
+]

mili_score_inference/model.py

@@ -0,0 +1,60 @@
+"""CORN head + DINOv3 ViT (Hugging Face) — matches `anime_mili_ordinal_corn_vitl16` state_dict."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import torch
+import torch.nn as nn
+from transformers import AutoConfig, AutoModel
+
+
+def backbone_transformer_blocks(backbone: nn.Module) -> list[nn.Module]:
+    enc = getattr(backbone, "encoder", None)
+    if enc is not None and hasattr(enc, "layer"):
+        return list(enc.layer)
+    if hasattr(backbone, "layer"):
+        return list(backbone.layer)
+    raise AttributeError("expected backbone.encoder.layer or backbone.layer")
+
+
+class MiliModelCORN(nn.Module):
+    """DINOv3 (HF) + CORN: outputs (B, K-1) logits; score in [0,1] via predict_expected_class in predict.py."""
+
+    def __init__(
+        self,
+        backbone_checkpoint_dir: Path | str,
+        *,
+        dropout_head: float = 0.2,
+        drop_path_rate: float = 0.2,
+        num_classes: int = 5,
+        local_files_only: bool = True,
+    ) -> None:
+        super().__init__()
+        raw = backbone_checkpoint_dir
+        p = Path(raw)
+        if p.exists() and p.is_dir():
+            ckpt_str = str(p.resolve())
+        else:
+            ckpt_str = raw if isinstance(raw, str) else str(raw)
+        config = AutoConfig.from_pretrained(ckpt_str, local_files_only=local_files_only)
+        if hasattr(config, "drop_path_rate"):
+            config.drop_path_rate = drop_path_rate
+        self.backbone = AutoModel.from_pretrained(ckpt_str, config=config, local_files_only=local_files_only)
+        embed_dim = int(self.backbone.config.hidden_size)
+
+        self.head = nn.Sequential(
+            nn.Dropout(dropout_head),
+            nn.Linear(embed_dim, 256),
+            nn.GELU(),
+            nn.Dropout(dropout_head / 2),
+            nn.Linear(256, num_classes - 1),
+        )
+        for p in self.backbone.parameters():
+            p.requires_grad = False
+        self.blocks = backbone_transformer_blocks(self.backbone)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        out = self.backbone(pixel_values=x)
+        cls_token = out.last_hidden_state[:, 0, :]
+        return self.head(cls_token)

mili_score_inference/predict.py

@@ -0,0 +1,59 @@
+"""Load weights and predict score in [0, 1]."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import torch
+from PIL import Image
+
+from mili_score_inference.model import MiliModelCORN
+from mili_score_inference.transforms import build_val_transform
+
+
+def predict_expected_class(logits: torch.Tensor) -> torch.Tensor:
+    probs = torch.sigmoid(logits)
+    return probs.sum(dim=1)
+
+
+def logits_to_score_01(logits: torch.Tensor) -> torch.Tensor:
+    return predict_expected_class(logits) / 4.0
+
+
+def load_model(
+    weights_path: Path | str,
+    backbone_checkpoint_dir: Path | str,
+    *,
+    dropout_head: float = 0.2,
+    drop_path_rate: float = 0.2,
+    num_classes: int = 5,
+    device: torch.device | None = None,
+    local_backbone: bool = True,
+) -> MiliModelCORN:
+    device = device or torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = MiliModelCORN(
+        backbone_checkpoint_dir,
+        dropout_head=dropout_head,
+        drop_path_rate=drop_path_rate,
+        num_classes=num_classes,
+        local_files_only=local_backbone,
+    )
+    state = torch.load(weights_path, map_location="cpu", weights_only=True)
+    model.load_state_dict(state)
+    model.to(device)
+    model.eval()
+    return model
+
+
+@torch.inference_mode()
+def predict_pil(
+    model: MiliModelCORN,
+    image: Image.Image,
+    *,
+    device: torch.device,
+    img_size: int = 224,
+) -> float:
+    tf = build_val_transform(img_size)
+    t = tf(image.convert("RGB")).unsqueeze(0).to(device)
+    logits = model(t)
+    return float(logits_to_score_01(logits)[0].item())

mili_score_inference/transforms.py

@@ -0,0 +1,17 @@
+"""Validation-style preprocessing: resize + ImageNet normalization."""
+
+from __future__ import annotations
+
+from torchvision import transforms
+
+
+def build_val_transform(img_size: int = 224) -> transforms.Compose:
+    mean = (0.485, 0.456, 0.406)
+    std = (0.229, 0.224, 0.225)
+    return transforms.Compose(
+        [
+            transforms.Resize((img_size, img_size)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean, std),
+        ]
+    )

requirements.txt

@@ -0,0 +1,6 @@
+# Инференс MILI score (CORN head + DINOv3 backbone из локального или HF чекпоинта)
+torch>=2.2.0,<2.7.0
+torchvision>=0.17.0,<0.22.0
+transformers>=4.48.0,<5.0.0
+numpy>=1.26.0,<3.0.0
+pillow>=10.2.0,<12.0.0

weights/README.txt

@@ -0,0 +1,5 @@
+Fine-tuned full-model checkpoint (Apache 2.0, derivative of DINOv3):
+
+  anime_mili_ordinal_corn_vitl16.pth
+
+Contains the backbone + CORN head state_dict for use with mili_score_inference.

weights/anime_mili_ordinal_corn_vitl16.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:372b9dc22759635f555e94b7a921b903232ad035b6475a8edabfdca44e0b32aa
+size 1213732210