Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,2 @@
-*.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
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+.venv/
+__pycache__/
+*.pyc
+node_modules/
+dist/

CITATION.cff

@@ -0,0 +1,10 @@
+cff-version: 1.2.0
+title: Veritiana Prompt Task & Complexity Classifier
+message: If you use this model, please cite this software release.
+type: software
+authors:
+  - name: Veritiana AI
+version: 3.1.0
+date-released: 2026-08-05
+license: Apache-2.0
+url: https://www.veritiana.com/prompt_classifier.html

LICENSE

@@ -0,0 +1,204 @@
+
+                                 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.
+
+Copyright 2026 Veritiana

NOTICE

@@ -0,0 +1,14 @@
+Veritiana Prompt Task & Complexity Classifier v3.1.0
+Copyright 2026 Veritiana
+
+Model and software release license: Apache License 2.0.
+
+Training sources used by the recorded preparation run:
+- OpenAssistant/oasst1 — Apache License 2.0
+- grammarly/coedit — Apache License 2.0
+- evalplus/mbppplus — Apache License 2.0
+- google/IFEval — Apache License 2.0
+
+The source datasets are not redistributed in this repository. Their original authors retain attribution and rights in their respective works. Training used prompt/instruction fields only as described in dataset-manifest.json.
+
+Provenance limitation: the exact Hugging Face dataset revisions were not captured by the original download run. Exact reproduction of the released ONNX SHA-256 therefore requires the archived dataset.jsonl whose SHA-256 is recorded in dataset-manifest.json.

README.md

@@ -1,3 +1,297 @@
 ---
 license: apache-2.0
+language:
+- en
+pipeline_tag: text-classification
+inference: false
+tags:
+- onnx
+- onnxruntime
+- browser
+- local-inference
+- prompt-classification
+- task-classification
+- complexity-estimation
+- ai-routing
+- green-ai
+- veritiana
+datasets:
+- OpenAssistant/oasst1
+- grammarly/coedit
+- evalplus/mbppplus
+- google/IFEval
+metrics:
+- accuracy
+- f1
 ---
+
+# Veritiana Prompt Task & Complexity Classifier
+
+![Veritiana Prompt Classifier architecture](assets/veritiana-prompt-classifier-architecture.png)
+
+A compact ONNX classifier from **Veritiana AI** that identifies the type of work requested by an AI prompt and estimates its complexity **before generative execution begins**.
+
+The model runs locally, including directly in a browser through ONNX Runtime Web. It does not generate text and does not require prompt content to be sent to a remote classification service.
+
+**Live browser test:** https://www.veritiana.com/prompt_classifier.html
+
+## What it returns
+
+The model produces two independent probability distributions.
+
+### Task — 9 classes
+
+`general_chat`, `writing`, `translation`, `summarization`, `research`, `coding`, `mathematics`, `document_analysis`, `high_stakes`
+
+### Complexity — 3 classes
+
+`low`, `medium`, `high`
+
+Example result:
+
+```text
+task: coding
+complexity: high
+```
+
+## Intended role
+
+This release is a public recognition layer, not a complete AI router.
+
+```text
+Prompt
+  → local feature extraction
+  → ONNX task and complexity classifier
+  → probabilities and confidence
+  → future routing policy
+  → model, tools, context, safeguards and budget
+```
+
+The open model answers **what kind of request this is** and **how demanding it appears**. Commercial routing value begins when those signals are combined with provider capabilities, prices, latency, organizational policies, tool access, execution quality and feedback history to decide how the request should be executed.
+
+The classifier is also part of the product direction behind **Veritiana AI Meter**, where local recognition helps distinguish the type and estimated complexity of visible AI work.
+
+## Model architecture
+
+The input is a fixed vector of 1,544 float32 features:
+
+- 1,024 hashed word and word-bigram bins
+- 512 hashed character-trigram bins
+- 8 numerical and structural features
+
+Two independent multinomial logistic-regression heads produce task and complexity probabilities.
+
+```text
+input
+  features                  float32 [batch, 1544]
+
+outputs
+  task_probabilities        float32 [batch, 9]
+  complexity_probabilities  float32 [batch, 3]
+```
+
+The released ONNX model is approximately 75 KB and uses ONNX opset 13.
+
+## Feature contract
+
+The feature extractor is part of the model contract. Raw text cannot be passed directly to `model.onnx`.
+
+The repository includes the exact implementation in `features.py`, with matching browser logic in `examples/browser/src/main.js`.
+
+The eight numerical features encode:
+
+1. normalized character length
+2. normalized word count
+3. question-mark count
+4. newline count
+5. technical-symbol count
+6. URL presence
+7. document/file-term presence
+8. constant bias value
+
+Hashing uses FNV-1a 32-bit over JavaScript UTF-16 code units so Python and browser implementations remain compatible.
+
+## Internal evaluation
+
+The recorded internal split contains 1,287 examples.
+
+| Output | Accuracy | Macro-F1 |
+|---|---:|---:|
+| Task | 91.22% | 91.04% |
+| Complexity | 86.79% | 87.24% |
+
+These are **internal weak-label evaluation results**, not independently established real-world accuracy.
+
+Important limitations:
+
+- labels include source-fixed labels, deterministic weak rules and deterministic lexical augmentation
+- augmented rows are variants, not independent human examples
+- minority-class support is uneven
+- the translation test support is only 4 examples and its reported score is not meaningful as a production claim
+- multilingual behavior has not been independently benchmarked
+- the classifier does not semantically reason like a large language model
+
+Full per-class reports and confusion matrices are in `evaluation.json`.
+
+## Training data
+
+The original normalized import contained 19,087 prompts:
+
+| Source | Imported rows | Recorded use |
+|---|---:|---|
+| OpenAssistant/oasst1 | 10,170 | filtered root prompter messages |
+| grammarly/coedit | 8,000 | source text, task fixed to writing |
+| evalplus/mbppplus | 376 | prompt field, task fixed to coding |
+| google/IFEval | 541 | prompt field, weak task labels and instruction-count complexity signal |
+
+After filtering, balancing and deterministic augmentation, the prepared set contained 6,349 rows.
+
+The datasets themselves are not redistributed. Data provenance, row counts, SHA-256 values and the known revision limitation are documented in `dataset-manifest.json`.
+
+## Browser use
+
+A complete minimal Vite example is included in `examples/browser`.
+
+```bash
+cd examples/browser
+npm install
+npm run dev
+```
+
+The example loads `model.onnx`, reproduces the 1,544-feature contract and prints both probability distributions.
+
+For the complete production interface, use the live Veritiana test:
+
+https://www.veritiana.com/prompt_classifier.html
+
+## Python use
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements-inference.txt
+python examples/python/classify.py "Refactor this API and add rollback tests."
+```
+
+Expected output structure:
+
+```json
+{
+  "task": {
+    "label": "coding",
+    "confidence": 0.0,
+    "probabilities": {}
+  },
+  "complexity": {
+    "label": "high",
+    "confidence": 0.0,
+    "probabilities": {}
+  }
+}
+```
+
+The numerical values depend on the supplied prompt. The example does not send data to an external service.
+
+## Reproducing training
+
+Exact reproduction requires either:
+
+- `dataset.jsonl` with SHA-256 `1d56520b25809488fa8be91bcd14219accdb31146e1ca56686ff805d34c21649`, or
+- prepared `training-balanced.jsonl` with SHA-256 `ab2665fcd75800b2350593b7af4222e81d8cc93a34f2bf67320514a92526f44c`.
+
+The datasets are not included in this repository.
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements-training.txt
+
+python prepare_training_set.py dataset.jsonl \
+  --output training-balanced.jsonl \
+  --report training-balanced-report.json \
+  --seed 42 \
+  --confidence 0.65 \
+  --target-per-task 800 \
+  --max-per-task 2000
+
+python train.py training-balanced.jsonl \
+  --output-dir reproduced-output \
+  --version 3.1.0-multisource-balanced \
+  --test-size 0.20 \
+  --seed 42 \
+  --c 4.0
+```
+
+Reference model SHA-256:
+
+```text
+dca7560742f19207d089d469c2907e7a1b7c06e2bbf14d2404a5d9359043f572
+```
+
+Exact byte reproduction can also depend on the numerical environment and BLAS implementation. The feature contract and output probabilities are the primary compatibility target.
+
+## Repository contents
+
+```text
+README.md
+model.onnx
+config.json
+classifier-meta.json
+evaluation.json
+dataset-manifest.json
+training-config.json
+features.py
+prepare_training_set.py
+train.py
+requirements-inference.txt
+requirements-training.txt
+LICENSE
+NOTICE
+assets/
+  veritiana-prompt-classifier-architecture.png
+examples/
+  python/
+  browser/
+upload_to_hub.py
+```
+
+## Appropriate uses
+
+- local prompt analytics
+- task-distribution measurement
+- complexity estimation
+- pre-routing signals
+- browser-native AI usage instrumentation
+- research and prototyping around deterministic pre-LLM decision layers
+
+## Out-of-scope uses
+
+Do not use the classifier as:
+
+- a medical, legal, financial or safety decision maker
+- proof that a prompt is safe
+- a factual-answer evaluator
+- an authorization layer
+- a universal language detector
+- a guaranteed model-selection engine
+- a replacement for human review in high-stakes workflows
+
+## Privacy
+
+Inference can run entirely on the user device. The model itself does not upload, store or transmit prompt content. Integrators remain responsible for the behavior of the surrounding application.
+
+## License
+
+The model and repository code are released under Apache License 2.0. See `LICENSE` and `NOTICE`.
+
+## Citation
+
+```bibtex
+@software{veritiana_prompt_classifier_2026,
+  title        = {Veritiana Prompt Task and Complexity Classifier},
+  author       = {Veritiana AI},
+  year         = {2026},
+  version      = {3.1.0},
+  url          = {https://www.veritiana.com/prompt_classifier.html}
+}
+```

SHA256SUMS

@@ -0,0 +1,27 @@
+ffda9ef77ab85b9d12041edee241d106a4761b93a25ab5c312eb16450c844080  .gitattributes
+123fc16609d7b9cc84dabfd9ddd304b9d5b729a52efc6bcf4cec58fdfc2a7624  .gitignore
+7b959ae91f75e218db985d565a35abed62dbf4fa1a1573be3d7484e0f01190a1  CITATION.cff
+601ee540b197abb7f596f6138cc2845158b48bbad1afd364e0aef3a745fe8153  LICENSE
+0e2951233817f9692d784c33f5206f3120e8dbf5fdddf187d32f32a2f1bebf39  NOTICE
+55e89f0b8919d40e57bf52ae8785cce815c74d26df858f8aea88786fe231f536  README.md
+561550c1010619147e6190604adb0f239068eae27439e578c04102b0b2d410b6  UPLOAD.md
+5b533b27eea3e364070f5fb31c1bcab73efcbe02c5a31244c187954fd6845a9c  assets/veritiana-prompt-classifier-architecture.png
+794da8ad12b6382117724f9ef84ee7a4869090d604b7ca4b98d32dfc2a781a05  classifier-meta.json
+05c2cc137b882f2fcd787a37a5044da7e162b4bcfc987b5060a89aebde137fac  config.json
+cb9e983f679a87479bf4f5cbe47ebcc816a1cb8f31ba8ccfbd0b7f3c856317c1  dataset-manifest.json
+163c7c98362e88a7a6cce2f6523d6f64f58a1f19afe2b0e09d69e319244c4986  evaluation.json
+4aeeafe4041d6489ae6c7caa81802ad48cd0734992f47f5e1d0d669e012489e4  examples/browser/README.md
+5b3ebb10fd2817dca98f6d8a8278062c3d6574ea3f97fc57a1d8a502f4315c08  examples/browser/index.html
+6df3e570901c32423204c6eb672387677840c8226712e221ab259c220fa48f42  examples/browser/package.json
+aa0fefc04cfe62222760b44cadfbf63a519f58ed4de799ac23ca0efb045a9fb2  examples/browser/src/main.js
+e5b1fea5c12849246fb69ce467d0dc38f892bcb7f65ddf1c3af7a1a001a61489  examples/browser/src/style.css
+2e8b8142dc7f29326fa98ca3b2ad43a7e6e8aa07ea7c6bf00bb4232508a8a7f7  examples/python/classify.py
+f232bf95cdb53088b1dc15df7b6a0ca174ba04b930b0f0baaa1d1cbb29bdfa15  features.py
+dca7560742f19207d089d469c2907e7a1b7c06e2bbf14d2404a5d9359043f572  model.onnx
+3330c8077f015bb153b3865a5994cdc0151f61975a1a46b9c93c948926be9a1c  prepare_training_set.py
+ed89e010a3e30b99e4ffb83898328d98fc471573922d4fc734267ac53a8bada5  requirements-inference.txt
+b893fa86c1d13abad802057d4c0702900f321cd0bec41700b756c3bc32e5ac51  requirements-training.txt
+e661b27c32be22e4b3064eb4b46c4e5453c31bc5f0d1983f223cfa48770446ce  requirements-upload.txt
+5df357c377930a256c56d2a3acc2b083feae17a6cd82d375d2e9c86f123903b8  train.py
+a3768583ffae24d9b875fe577eb8a44e09614088460a2a5013a8c9427fe2c7a0  training-config.json
+2bcf8d1d7fafb54f440d3a218760fb0847e39e4c639d1a66a404f0e0937e2471  upload_to_hub.py

UPLOAD.md

@@ -0,0 +1,29 @@
+# Upload instructions
+
+Recommended repository ID:
+
+```text
+Veritiana-AI/prompt-task-complexity-classifier
+```
+
+## Web upload
+
+Create a new **Model** repository on Hugging Face and upload the contents of this directory. Upload the files themselves, not the enclosing ZIP directory.
+
+## CLI upload
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements-upload.txt
+huggingface-cli login
+python upload_to_hub.py Veritiana-AI/prompt-task-complexity-classifier
+```
+
+After upload, confirm:
+
+- `README.md` renders the architecture image
+- `model.onnx` SHA-256 is `dca7560742f19207d089d469c2907e7a1b7c06e2bbf14d2404a5d9359043f572`
+- the live demo link opens `https://www.veritiana.com/prompt_classifier.html`
+- the license displays as Apache-2.0
+- the repository does not show an automatic inference widget, because raw text requires the custom feature extractor

classifier-meta.json

@@ -0,0 +1,73 @@
+{
+  "model": "Veritiana Prompt Task & Complexity Classifier",
+  "version": "3.1.0-multisource-balanced",
+  "engine": "ONNX Runtime Web",
+  "architecture": "1544 hashed lexical/character/numeric features; dual multinomial logistic heads",
+  "input": {
+    "name": "features",
+    "dtype": "float32",
+    "shape": [
+      "batch",
+      1544
+    ]
+  },
+  "outputs": [
+    {
+      "name": "task_probabilities",
+      "dtype": "float32",
+      "shape": [
+        "batch",
+        9
+      ]
+    },
+    {
+      "name": "complexity_probabilities",
+      "dtype": "float32",
+      "shape": [
+        "batch",
+        3
+      ]
+    }
+  ],
+  "task_labels": [
+    "general_chat",
+    "writing",
+    "translation",
+    "summarization",
+    "research",
+    "coding",
+    "mathematics",
+    "document_analysis",
+    "high_stakes"
+  ],
+  "complexity_labels": [
+    "low",
+    "medium",
+    "high"
+  ],
+  "training_data": {
+    "sources": [
+      "OpenAssistant/oasst1",
+      "grammarly/coedit",
+      "evalplus/mbppplus",
+      "google/IFEval"
+    ],
+    "balanced_rows": 6349,
+    "train_rows": 5062,
+    "test_rows": 1287,
+    "notes": "Low-confidence weak labels excluded; dominant tasks capped; deterministic lexical augmentations grouped with their source during split."
+  },
+  "validation": {
+    "task_accuracy": 0.9121989121989122,
+    "task_macro_f1": 0.9103734961055048,
+    "complexity_accuracy": 0.8679098679098679,
+    "complexity_macro_f1": 0.8723688079771166,
+    "runtime": "AI Meter bundled ONNX Runtime Web 1.22.0",
+    "runtime_max_abs_diff": 1.1920928955078125e-07
+  },
+  "onnx_sha256": "dca7560742f19207d089d469c2907e7a1b7c06e2bbf14d2404a5d9359043f572",
+  "limitations": "Validation uses weak labels and deterministic augmentations. Do not present these metrics as independent human-ground-truth production accuracy.",
+  "model_file": "model.onnx",
+  "live_demo": "https://www.veritiana.com/prompt_classifier.html",
+  "intended_role": "Local task and complexity recognition before generative execution; input signal for future routing policies."
+}

config.json

@@ -0,0 +1,63 @@
+{
+  "model_type": "veritiana_prompt_classifier",
+  "model_version": "3.1.0-multisource-balanced",
+  "architecture": "dual_multinomial_logistic_regression",
+  "model_file": "model.onnx",
+  "input": {
+    "name": "features",
+    "dtype": "float32",
+    "shape": [
+      "batch",
+      1544
+    ]
+  },
+  "outputs": {
+    "task_probabilities": {
+      "dtype": "float32",
+      "shape": [
+        "batch",
+        9
+      ]
+    },
+    "complexity_probabilities": {
+      "dtype": "float32",
+      "shape": [
+        "batch",
+        3
+      ]
+    }
+  },
+  "features": {
+    "total": 1544,
+    "word_bigram_bins": 1024,
+    "character_trigram_bins": 512,
+    "numeric_features": 8,
+    "hash": "FNV-1a 32-bit over JavaScript UTF-16 code units"
+  },
+  "task_labels": [
+    "general_chat",
+    "writing",
+    "translation",
+    "summarization",
+    "research",
+    "coding",
+    "mathematics",
+    "document_analysis",
+    "high_stakes"
+  ],
+  "complexity_labels": [
+    "low",
+    "medium",
+    "high"
+  ],
+  "thresholds": {
+    "task_classified": 0.72,
+    "complexity_classified": 0.66,
+    "likely": 0.45
+  },
+  "runtime": {
+    "browser": "ONNX Runtime Web 1.22.0",
+    "onnx_opset": 13
+  },
+  "live_demo": "https://www.veritiana.com/prompt_classifier.html"
+}

dataset-manifest.json

@@ -0,0 +1,88 @@
+{
+  "manifest_version": "1.0",
+  "model_version": "3.1.0-multisource-balanced",
+  "source_dataset": {
+    "file": "dataset.jsonl (not redistributed in this release)",
+    "sha256": "1d56520b25809488fa8be91bcd14219accdb31146e1ca56686ff805d34c21649",
+    "rows": 19087,
+    "source_revisions": "Exact Hugging Face revisions were not captured by the original download run."
+  },
+  "prepared_dataset": {
+    "file": "training-balanced.jsonl (not redistributed in this release)",
+    "sha256": "ab2665fcd75800b2350593b7af4222e81d8cc93a34f2bf67320514a92526f44c",
+    "rows": 6349
+  },
+  "sources": [
+    {
+      "name": "OpenAssistant/oasst1",
+      "url": "https://huggingface.co/datasets/OpenAssistant/oasst1",
+      "license": "Apache-2.0",
+      "rows_after_import": 10170,
+      "use": "root prompter messages after filters"
+    },
+    {
+      "name": "grammarly/coedit",
+      "url": "https://huggingface.co/datasets/grammarly/coedit",
+      "license": "Apache-2.0",
+      "rows_after_import": 8000,
+      "use": "src field only; task fixed to writing"
+    },
+    {
+      "name": "evalplus/mbppplus",
+      "url": "https://huggingface.co/datasets/evalplus/mbppplus",
+      "license": "Apache-2.0",
+      "rows_after_import": 376,
+      "use": "prompt field only; task fixed to coding"
+    },
+    {
+      "name": "google/IFEval",
+      "url": "https://huggingface.co/datasets/google/IFEval",
+      "license": "Apache-2.0",
+      "rows_after_import": 541,
+      "use": "prompt field; weak task labels; instruction count informs complexity"
+    }
+  ],
+  "preparation_report": {
+    "input_rows": 19087,
+    "accepted_rows": 10696,
+    "rejected_low_confidence": 8391,
+    "output_rows": 6349,
+    "confidence_threshold": 0.65,
+    "by_task": {
+      "writing": 2000,
+      "coding": 1228,
+      "general_chat": 800,
+      "mathematics": 410,
+      "summarization": 139,
+      "high_stakes": 425,
+      "translation": 92,
+      "document_analysis": 455,
+      "research": 800
+    },
+    "by_complexity": {
+      "low": 4307,
+      "medium": 1816,
+      "high": 226
+    },
+    "by_label_method": {
+      "source_fixed": 2216,
+      "weak_rule": 1810,
+      "deterministic_augmentation": 2323
+    },
+    "augmented_by_task": {
+      "general_chat": 575,
+      "translation": 74,
+      "summarization": 112,
+      "research": 526,
+      "mathematics": 328,
+      "document_analysis": 367,
+      "high_stakes": 341
+    },
+    "warning": "Augmented rows are lexical variants, not independent human examples."
+  },
+  "model": {
+    "file": "model.onnx",
+    "sha256": "dca7560742f19207d089d469c2907e7a1b7c06e2bbf14d2404a5d9359043f572",
+    "bytes": 75346
+  }
+}

evaluation.json

@@ -0,0 +1,229 @@
+{
+  "summary": {
+    "task_accuracy": 0.9121989121989122,
+    "task_macro_f1": 0.9103734961055048,
+    "complexity_accuracy": 0.8679098679098679,
+    "complexity_macro_f1": 0.8723688079771166,
+    "training_seconds": 13.171398878097534
+  },
+  "task_report": {
+    "general_chat": {
+      "precision": 0.9310344827586207,
+      "recall": 0.9204545454545454,
+      "f1-score": 0.9257142857142857,
+      "support": 176.0
+    },
+    "writing": {
+      "precision": 0.974025974025974,
+      "recall": 0.9566326530612245,
+      "f1-score": 0.9652509652509652,
+      "support": 392.0
+    },
+    "translation": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1-score": 1.0,
+      "support": 4.0
+    },
+    "summarization": {
+      "precision": 0.9655172413793104,
+      "recall": 0.9655172413793104,
+      "f1-score": 0.9655172413793104,
+      "support": 29.0
+    },
+    "research": {
+      "precision": 0.8372093023255814,
+      "recall": 0.8944099378881988,
+      "f1-score": 0.8648648648648649,
+      "support": 161.0
+    },
+    "coding": {
+      "precision": 0.9132231404958677,
+      "recall": 0.9057377049180327,
+      "f1-score": 0.9094650205761317,
+      "support": 244.0
+    },
+    "mathematics": {
+      "precision": 0.8641975308641975,
+      "recall": 0.8536585365853658,
+      "f1-score": 0.8588957055214724,
+      "support": 82.0
+    },
+    "document_analysis": {
+      "precision": 0.8165137614678899,
+      "recall": 0.9081632653061225,
+      "f1-score": 0.8599033816425121,
+      "support": 98.0
+    },
+    "high_stakes": {
+      "precision": 0.8901098901098901,
+      "recall": 0.801980198019802,
+      "f1-score": 0.84375,
+      "support": 101.0
+    },
+    "accuracy": 0.9121989121989122,
+    "macro avg": {
+      "precision": 0.9102034803808147,
+      "recall": 0.9118393425125113,
+      "f1-score": 0.9103734961055048,
+      "support": 1287.0
+    },
+    "weighted avg": {
+      "precision": 0.913815881736539,
+      "recall": 0.9121989121989122,
+      "f1-score": 0.912490699441833,
+      "support": 1287.0
+    }
+  },
+  "complexity_report": {
+    "low": {
+      "precision": 0.9166666666666666,
+      "recall": 0.8856476079346558,
+      "f1-score": 0.9008902077151335,
+      "support": 857.0
+    },
+    "medium": {
+      "precision": 0.7555555555555555,
+      "recall": 0.8225806451612904,
+      "f1-score": 0.7876447876447876,
+      "support": 372.0
+    },
+    "high": {
+      "precision": 0.9629629629629629,
+      "recall": 0.896551724137931,
+      "f1-score": 0.9285714285714286,
+      "support": 58.0
+    },
+    "accuracy": 0.8679098679098679,
+    "macro avg": {
+      "precision": 0.878395061728395,
+      "recall": 0.8682599924112924,
+      "f1-score": 0.8723688079771166,
+      "support": 1287.0
+    },
+    "weighted avg": {
+      "precision": 0.8721848110736999,
+      "recall": 0.8679098679098679,
+      "f1-score": 0.8694047489299714,
+      "support": 1287.0
+    }
+  },
+  "task_confusion_matrix": [
+    [
+      162,
+      2,
+      0,
+      0,
+      1,
+      3,
+      4,
+      0,
+      4
+    ],
+    [
+      1,
+      375,
+      0,
+      0,
+      5,
+      10,
+      1,
+      0,
+      0
+    ],
+    [
+      0,
+      0,
+      4,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0
+    ],
+    [
+      0,
+      0,
+      0,
+      28,
+      0,
+      0,
+      1,
+      0,
+      0
+    ],
+    [
+      4,
+      1,
+      0,
+      1,
+      144,
+      3,
+      0,
+      5,
+      3
+    ],
+    [
+      3,
+      5,
+      0,
+      0,
+      6,
+      221,
+      0,
+      6,
+      3
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      4,
+      2,
+      70,
+      6,
+      0
+    ],
+    [
+      4,
+      0,
+      0,
+      0,
+      5,
+      0,
+      0,
+      89,
+      0
+    ],
+    [
+      0,
+      2,
+      0,
+      0,
+      7,
+      3,
+      5,
+      3,
+      81
+    ]
+  ],
+  "complexity_confusion_matrix": [
+    [
+      759,
+      98,
+      0
+    ],
+    [
+      64,
+      306,
+      2
+    ],
+    [
+      5,
+      1,
+      52
+    ]
+  ]
+}

examples/browser/README.md

@@ -0,0 +1,10 @@
+# Browser example
+
+This Vite example performs local ONNX Runtime Web inference and implements the same 1,544-feature contract as the released model.
+
+```bash
+npm install
+npm run dev
+```
+
+The prompt remains in the browser. No classification API is called.

examples/browser/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+<head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Veritiana Classifier Example</title></head>
+<body>
+  <main>
+    <h1>Veritiana Prompt Classifier</h1>
+    <textarea id="prompt" rows="8">Refactor this authentication service, preserve API compatibility, migrate the database schema and add rollback tests.</textarea>
+    <button id="classify">Classify locally</button>
+    <pre id="result">Loading model…</pre>
+  </main>
+  <script type="module" src="/src/main.js"></script>
+</body>
+</html>

examples/browser/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "veritiana-prompt-classifier-browser-example",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "onnxruntime-web": "1.22.0"
+  },
+  "devDependencies": {
+    "vite": "^7.0.0"
+  }
+}

examples/browser/src/main.js

@@ -0,0 +1,75 @@
+import * as ort from "onnxruntime-web";
+import "./style.css";
+
+const TASK_LABELS = ["general_chat", "writing", "translation", "summarization", "research", "coding", "mathematics", "document_analysis", "high_stakes"];
+const COMPLEXITY_LABELS = ["low", "medium", "high"];
+const WORD_BINS = 1024;
+const CHAR_BINS = 512;
+const INPUT_SIZE = 1544;
+
+function fnv1a(text) {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i += 1) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+function buildFeatures(text) {
+  const source = String(text || "");
+  const lower = source.toLocaleLowerCase();
+  const values = new Float32Array(INPUT_SIZE);
+  const words = lower.match(/[\p{L}\p{N}_]+/gu) || [];
+  const grams = [...words];
+  for (let i = 0; i + 1 < words.length; i += 1) grams.push(`${words[i]}_${words[i + 1]}`);
+  for (const gram of grams) values[fnv1a(gram) % WORD_BINS] += 1;
+
+  const compact = lower.replace(/\s+/g, " ");
+  for (let i = 0; i + 2 < compact.length; i += 1) {
+    values[WORD_BINS + (fnv1a(compact.slice(i, i + 3)) % CHAR_BINS)] += 0.25;
+  }
+
+  const sparseCount = WORD_BINS + CHAR_BINS;
+  let norm = 0;
+  for (let i = 0; i < sparseCount; i += 1) norm += values[i] * values[i];
+  norm = Math.sqrt(norm);
+  if (norm > 0) for (let i = 0; i < sparseCount; i += 1) values[i] /= norm;
+
+  const base = sparseCount;
+  values[base] = Math.min(source.length, 4000) / 4000;
+  values[base + 1] = Math.min(words.length, 800) / 800;
+  values[base + 2] = Math.min((source.match(/\?/g) || []).length, 10) / 10;
+  values[base + 3] = Math.min((source.match(/\n/g) || []).length, 30) / 30;
+  values[base + 4] = Math.min((source.match(/[{}[\]();=<>/]/g) || []).length, 100) / 100;
+  values[base + 5] = /https?:\/\/|www\./i.test(source) ? 1 : 0;
+  values[base + 6] = /\b(pdf|document|dokument|file|súbor|attachment|príloha)\b/i.test(source) ? 1 : 0;
+  values[base + 7] = 1;
+  return values;
+}
+
+function argMax(values) {
+  let index = 0;
+  for (let i = 1; i < values.length; i += 1) if (values[i] > values[index]) index = i;
+  return index;
+}
+
+const result = document.querySelector("#result");
+const modelUrl = new URL("../../../model.onnx", import.meta.url).href;
+ort.env.wasm.numThreads = 1;
+const session = await ort.InferenceSession.create(modelUrl, { executionProviders: ["wasm"] });
+result.textContent = "Model ready.";
+
+document.querySelector("#classify").addEventListener("click", async () => {
+  const text = document.querySelector("#prompt").value;
+  const features = buildFeatures(text);
+  const outputs = await session.run({ features: new ort.Tensor("float32", features, [1, INPUT_SIZE]) });
+  const task = Array.from(outputs.task_probabilities.data);
+  const complexity = Array.from(outputs.complexity_probabilities.data);
+  const taskIndex = argMax(task);
+  const complexityIndex = argMax(complexity);
+  result.textContent = JSON.stringify({
+    task: { label: TASK_LABELS[taskIndex], confidence: task[taskIndex], probabilities: Object.fromEntries(TASK_LABELS.map((label, i) => [label, task[i]])) },
+    complexity: { label: COMPLEXITY_LABELS[complexityIndex], confidence: complexity[complexityIndex], probabilities: Object.fromEntries(COMPLEXITY_LABELS.map((label, i) => [label, complexity[i]])) }
+  }, null, 2);
+});

examples/browser/src/style.css

@@ -0,0 +1 @@
+body{margin:0;background:#06111f;color:#eefbf7;font:16px/1.5 system-ui,sans-serif}main{max-width:850px;margin:60px auto;padding:24px}textarea,pre{box-sizing:border-box;width:100%;border:1px solid #294155;border-radius:12px;background:#0a1928;color:#fff;padding:16px}button{margin:14px 0;padding:12px 18px;border:0;border-radius:9px;background:#24d3a4;color:#06111f;font-weight:800;cursor:pointer}pre{white-space:pre-wrap;overflow:auto}

examples/python/classify.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import onnxruntime as ort
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+from features import build_features  # noqa: E402
+
+TASK_LABELS = [
+    "general_chat", "writing", "translation", "summarization", "research",
+    "coding", "mathematics", "document_analysis", "high_stakes",
+]
+COMPLEXITY_LABELS = ["low", "medium", "high"]
+
+
+def distribution(labels, values):
+    return {label: float(value) for label, value in zip(labels, values, strict=True)}
+
+
+def classify(text: str) -> dict:
+    model_path = REPO_ROOT / "model.onnx"
+    session = ort.InferenceSession(str(model_path), providers=["CPUExecutionProvider"])
+    features = build_features(text).astype(np.float32).reshape(1, -1)
+    outputs = session.run(None, {"features": features})
+    task_probs = outputs[0][0]
+    complexity_probs = outputs[1][0]
+    task_index = int(np.argmax(task_probs))
+    complexity_index = int(np.argmax(complexity_probs))
+    return {
+        "task": {
+            "label": TASK_LABELS[task_index],
+            "confidence": float(task_probs[task_index]),
+            "probabilities": distribution(TASK_LABELS, task_probs),
+        },
+        "complexity": {
+            "label": COMPLEXITY_LABELS[complexity_index],
+            "confidence": float(complexity_probs[complexity_index]),
+            "probabilities": distribution(COMPLEXITY_LABELS, complexity_probs),
+        },
+    }
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        raise SystemExit('Usage: python examples/python/classify.py "your prompt"')
+    print(json.dumps(classify(" ".join(sys.argv[1:])), indent=2))
+
+
+if __name__ == "__main__":
+    main()

features.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""AI Meter v1.4.9-compatible 1544-dimensional feature extraction."""
+from __future__ import annotations
+import re
+from typing import Iterable
+import numpy as np
+import regex
+
+WORD_BINS = 1024
+CHAR_BINS = 512
+NUMERIC_FEATURES = 8
+INPUT_SIZE = WORD_BINS + CHAR_BINS + NUMERIC_FEATURES
+
+TECH_RE = re.compile(r"[{}\[\]();=<>/]")
+URL_RE = re.compile(r"https?://|www\.", re.I)
+DOC_RE = re.compile(r"\b(pdf|document|dokument|file|súbor|attachment|príloha)\b", re.I)
+
+def _utf16_units(text: str) -> Iterable[int]:
+    raw = text.encode("utf-16-le", errors="surrogatepass")
+    for index in range(0, len(raw), 2):
+        yield raw[index] | (raw[index + 1] << 8)
+
+def fnv1a_js(text: str) -> int:
+    """32-bit FNV-1a over JavaScript-compatible UTF-16 code units."""
+    value = 2166136261
+    for unit in _utf16_units(text):
+        value ^= unit
+        value = (value * 16777619) & 0xFFFFFFFF
+    return value
+
+def build_features(text: str) -> np.ndarray:
+    source = str(text or "")
+    lower = source.lower()
+    values = np.zeros(INPUT_SIZE, dtype=np.float32)
+    words = regex.findall(r"[\p{L}\p{N}_]+", lower)
+    grams = list(words)
+    grams.extend(f"{words[i]}_{words[i + 1]}" for i in range(len(words) - 1))
+    for gram in grams:
+        values[fnv1a_js(gram) % WORD_BINS] += 1.0
+    compact = regex.sub(r"\s+", " ", lower)
+    for index in range(max(0, len(compact) - 2)):
+        trigram = compact[index:index + 3]
+        values[WORD_BINS + (fnv1a_js(trigram) % CHAR_BINS)] += 0.25
+    sparse = values[:WORD_BINS + CHAR_BINS]
+    norm = float(np.linalg.norm(sparse))
+    if norm > 0:
+        sparse /= norm
+    base = WORD_BINS + CHAR_BINS
+    values[base] = min(len(source), 4000) / 4000
+    values[base + 1] = min(len(words), 800) / 800
+    values[base + 2] = min(source.count("?"), 10) / 10
+    values[base + 3] = min(source.count("\n"), 30) / 30
+    values[base + 4] = min(len(TECH_RE.findall(source)), 100) / 100
+    values[base + 5] = 1.0 if URL_RE.search(source) else 0.0
+    values[base + 6] = 1.0 if DOC_RE.search(source) else 0.0
+    values[base + 7] = 1.0
+    return values

model.onnx

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

prepare_training_set.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+import argparse, json, random, re
+from collections import Counter, defaultdict
+from pathlib import Path
+
+TASKS=['general_chat','writing','translation','summarization','research','coding','mathematics','document_analysis','high_stakes']
+POLITE_PREFIXES=['Please ','Could you ','I need you to ','Help me to ']
+
+def normalize(s): return re.sub(r'\s+',' ',s).strip()
+def variants(text):
+    base=normalize(text)
+    out=[]
+    if base:
+        out.append(base)
+        if base[0].islower(): out.append(base[0].upper()+base[1:])
+        if not base.endswith(('?','.','!')): out.append(base+'.')
+        for p in POLITE_PREFIXES:
+            if not base.lower().startswith(('please ','could you ','i need you to ','help me to ')):
+                out.append(p+base[0].lower()+base[1:])
+    seen=[]
+    for x in out:
+        if x not in seen: seen.append(x)
+    return seen
+
+def main():
+    ap=argparse.ArgumentParser()
+    ap.add_argument('input',type=Path)
+    ap.add_argument('--output',type=Path,default=Path('data/processed/training-balanced.jsonl'))
+    ap.add_argument('--report',type=Path,default=Path('data/processed/training-balanced-report.json'))
+    ap.add_argument('--seed',type=int,default=42)
+    ap.add_argument('--confidence',type=float,default=.65)
+    ap.add_argument('--target-per-task',type=int,default=800)
+    ap.add_argument('--max-per-task',type=int,default=2000)
+    args=ap.parse_args(); rng=random.Random(args.seed)
+    rows=[json.loads(x) for x in args.input.read_text(encoding='utf-8').splitlines() if x.strip()]
+    accepted=[]; rejected=[]
+    for r in rows:
+        fixed=r.get('label_method') in {'source_fixed','human_override'}
+        if fixed or float(r.get('label_confidence',0))>=args.confidence:
+            accepted.append(r)
+        else: rejected.append(r)
+    groups=defaultdict(list)
+    for r in accepted: groups[r['task']].append(r)
+    output=[]; augmented=Counter()
+    for task in TASKS:
+        group=groups[task]
+        rng.shuffle(group)
+        selected=group[:args.max_per_task]
+        output.extend(selected)
+        needed=max(0,args.target_per_task-len(selected))
+        if needed and selected:
+            pool=[]
+            for r in selected:
+                for i,v in enumerate(variants(r['text'])[1:],1):
+                    n=dict(r); n['id']=f"{r['id']}:aug{i}"; n['text']=v
+                    n['label_method']='deterministic_augmentation'; n['derived_from']=r['id']; n['label_confidence']=r.get('label_confidence',1.0)
+                    pool.append(n)
+            rng.shuffle(pool)
+            take=pool[:needed]
+            output.extend(take); augmented[task]+=len(take)
+    rng.shuffle(output)
+    args.output.parent.mkdir(parents=True,exist_ok=True)
+    with args.output.open('w',encoding='utf-8') as f:
+        for r in output: f.write(json.dumps(r,ensure_ascii=False)+'\n')
+    report={
+      'input_rows':len(rows),'accepted_rows':len(accepted),'rejected_low_confidence':len(rejected),
+      'output_rows':len(output),'confidence_threshold':args.confidence,
+      'by_task':dict(Counter(r['task'] for r in output)),
+      'by_complexity':dict(Counter(r['complexity'] for r in output)),
+      'by_label_method':dict(Counter(r.get('label_method','unknown') for r in output)),
+      'augmented_by_task':dict(augmented),
+      'warning':'Augmented rows are lexical variants, not independent human examples.'
+    }
+    args.report.write_text(json.dumps(report,indent=2),encoding='utf-8')
+    print(json.dumps(report,indent=2))
+if __name__=='__main__': main()

requirements-inference.txt

@@ -0,0 +1,3 @@
+numpy==2.3.5
+onnxruntime>=1.22,<2
+regex==2026.5.9

requirements-training.txt

@@ -0,0 +1,4 @@
+numpy==2.3.5
+scikit-learn==1.8.0
+regex==2026.5.9
+onnx>=1.17,<2

requirements-upload.txt

@@ -0,0 +1 @@
+huggingface_hub>=0.34,<1

train.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""Reproduce Veritiana AI Meter classifier v3.1.0 from training-balanced.jsonl."""
+from __future__ import annotations
+import argparse, hashlib, json, struct, sys, time
+from collections import Counter
+from pathlib import Path
+import numpy as np
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import classification_report, confusion_matrix
+from sklearn.model_selection import GroupShuffleSplit
+from features import INPUT_SIZE, build_features
+
+TASK_LABELS = ["general_chat","writing","translation","summarization","research","coding","mathematics","document_analysis","high_stakes"]
+COMPLEXITY_LABELS = ["low","medium","high"]
+
+def sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _varint(number: int) -> bytes:
+    number = int(number)
+    if number < 0: number = (1 << 64) + number
+    output = bytearray()
+    while True:
+        byte = number & 0x7F; number >>= 7
+        output.append(byte | (0x80 if number else 0))
+        if not number: return bytes(output)
+def _key(field: int, wire: int) -> bytes: return _varint((field << 3) | wire)
+def _fv(field: int, value: int) -> bytes: return _key(field,0)+_varint(value)
+def _fb(field: int, value: bytes) -> bytes: return _key(field,2)+_varint(len(value))+value
+def _fs(field: int, value: str) -> bytes: return _fb(field,value.encode())
+def _msg(field: int, value: bytes) -> bytes: return _fb(field,value)
+def _packed(field: int, values) -> bytes: return _fb(field,b''.join(_varint(v) for v in values))
+def _tensor(name: str, array: np.ndarray) -> bytes:
+    array=np.ascontiguousarray(array.astype(np.float32))
+    return _packed(1,array.shape)+_fv(2,1)+_fs(8,name)+_fb(9,array.tobytes(order='C'))
+def _dim(value): return _fs(2,value) if isinstance(value,str) else _fv(1,value)
+def _shape(dims): return b''.join(_msg(1,_dim(value)) for value in dims)
+def _tensor_type(element,dims): return _fv(1,element)+_msg(2,_shape(dims))
+def _type_proto(element,dims): return _msg(1,_tensor_type(element,dims))
+def _value_info(name,dims): return _fs(1,name)+_msg(2,_type_proto(1,dims))
+def _attr_int(name,value): return _fs(1,name)+_fv(3,value)+_fv(20,2)
+def _node(inputs,outputs,operation,name='',attributes=None):
+    value=b''.join(_fs(1,item) for item in inputs)+b''.join(_fs(2,item) for item in outputs)
+    if name: value += _fs(3,name)
+    value += _fs(4,operation)
+    for attribute in attributes or []: value += _msg(5,attribute)
+    return value
+def _graph(nodes,initializers,inputs,outputs,name):
+    return (b''.join(_msg(1,node) for node in nodes)+_fs(2,name)+
+            b''.join(_msg(5,item) for item in initializers)+
+            b''.join(_msg(11,item) for item in inputs)+
+            b''.join(_msg(12,item) for item in outputs))
+def _opset(version): return _fv(2,version)
+def _kv(key,value): return _fs(1,key)+_fs(2,value)
+
+def export_onnx(task_model, complexity_model, destination: Path, version: str) -> None:
+    initializers=[
+        _tensor('task_weights',task_model.coef_.astype(np.float32).T.copy()),
+        _tensor('task_bias',task_model.intercept_.astype(np.float32).copy()),
+        _tensor('complexity_weights',complexity_model.coef_.astype(np.float32).T.copy()),
+        _tensor('complexity_bias',complexity_model.intercept_.astype(np.float32).copy()),
+    ]
+    nodes=[
+        _node(['features','task_weights'],['task_mm'],'MatMul','TaskMatMul'),
+        _node(['task_mm','task_bias'],['task_logits'],'Add','TaskAdd'),
+        _node(['task_logits'],['task_probabilities'],'Softmax','TaskSoftmax',[_attr_int('axis',1)]),
+        _node(['features','complexity_weights'],['complexity_mm'],'MatMul','ComplexityMatMul'),
+        _node(['complexity_mm','complexity_bias'],['complexity_logits'],'Add','ComplexityAdd'),
+        _node(['complexity_logits'],['complexity_probabilities'],'Softmax','ComplexitySoftmax',[_attr_int('axis',1)]),
+    ]
+    graph=_graph(nodes,initializers,[_value_info('features',['batch',1544])],
+                 [_value_info('task_probabilities',['batch',9]),_value_info('complexity_probabilities',['batch',3])],
+                 'VeritianaAIMeterClassifier')
+    metadata={
+        'model':'Veritiana Multilingual Intent Classifier','version':version,'input_size':'1544',
+        'task_labels':json.dumps(TASK_LABELS),'complexity_labels':json.dumps(COMPLEXITY_LABELS),
+        'training_data':'OASST1 + CoEdIT + MBPP+ + IFEval; filtered, weak-labeled, balanced',
+        'feature_contract':'AI Meter v1.4.9 compatible'
+    }
+    payload=(_fv(1,8)+_fs(2,'veritiana-ai-meter-model-trainer')+_fs(3,version)+
+             _msg(7,graph)+_msg(8,_opset(13))+b''.join(_msg(14,_kv(k,v)) for k,v in metadata.items()))
+    destination.write_bytes(payload)
+
+def main() -> int:
+    parser=argparse.ArgumentParser()
+    parser.add_argument('dataset',type=Path,help='Prepared training-balanced.jsonl')
+    parser.add_argument('--output-dir',type=Path,default=Path('output'))
+    parser.add_argument('--version',default='3.1.0-multisource-balanced')
+    parser.add_argument('--test-size',type=float,default=0.20)
+    parser.add_argument('--seed',type=int,default=42)
+    parser.add_argument('--c',type=float,default=4.0)
+    args=parser.parse_args()
+    rows=[json.loads(line) for line in args.dataset.read_text(encoding='utf-8').splitlines() if line.strip()]
+    if not rows: raise ValueError('Empty dataset')
+    task_map={label:index for index,label in enumerate(TASK_LABELS)}
+    complexity_map={label:index for index,label in enumerate(COMPLEXITY_LABELS)}
+    X=np.vstack([build_features(row['text']) for row in rows]).astype(np.float32)
+    task_y=np.asarray([task_map[row['task']] for row in rows],dtype=np.int64)
+    complexity_y=np.asarray([complexity_map[row['complexity']] for row in rows],dtype=np.int64)
+    groups=[row.get('derived_from') or row.get('normalized_hash') or row.get('id') for row in rows]
+    splitter=GroupShuffleSplit(n_splits=1,test_size=args.test_size,random_state=args.seed)
+    train_index,test_index=next(splitter.split(X,task_y,groups=groups))
+    def fit(target):
+        model=LogisticRegression(C=args.c,max_iter=3000,solver='lbfgs',class_weight='balanced',random_state=args.seed)
+        model.fit(X[train_index],target[train_index]); return model
+    started=time.perf_counter(); task_model=fit(task_y); complexity_model=fit(complexity_y); seconds=time.perf_counter()-started
+    task_prediction=task_model.predict(X[test_index]); complexity_prediction=complexity_model.predict(X[test_index])
+    task_report=classification_report(task_y[test_index],task_prediction,labels=list(range(9)),target_names=TASK_LABELS,output_dict=True,zero_division=0)
+    complexity_report=classification_report(complexity_y[test_index],complexity_prediction,labels=list(range(3)),target_names=COMPLEXITY_LABELS,output_dict=True,zero_division=0)
+    evaluation={
+        'summary':{'task_accuracy':task_report['accuracy'],'task_macro_f1':task_report['macro avg']['f1-score'],
+                   'complexity_accuracy':complexity_report['accuracy'],'complexity_macro_f1':complexity_report['macro avg']['f1-score'],
+                   'training_seconds':seconds},
+        'task_report':task_report,'complexity_report':complexity_report,
+        'task_confusion_matrix':confusion_matrix(task_y[test_index],task_prediction,labels=list(range(9))).tolist(),
+        'complexity_confusion_matrix':confusion_matrix(complexity_y[test_index],complexity_prediction,labels=list(range(3))).tolist()
+    }
+    args.output_dir.mkdir(parents=True,exist_ok=True)
+    model_path=args.output_dir/'veritiana-classifier-v2.onnx'; export_onnx(task_model,complexity_model,model_path,args.version)
+    (args.output_dir/'evaluation.json').write_text(json.dumps(evaluation,ensure_ascii=False,indent=2),encoding='utf-8')
+    meta={
+        'model':'Veritiana Multilingual Intent Classifier','version':args.version,'engine':'ONNX Runtime Web',
+        'architecture':'1544 hashed lexical/character/numeric features; dual multinomial logistic heads',
+        'input':{'name':'features','dtype':'float32','shape':['batch',1544]},
+        'outputs':[{'name':'task_probabilities','dtype':'float32','shape':['batch',9]},
+                   {'name':'complexity_probabilities','dtype':'float32','shape':['batch',3]}],
+        'task_labels':TASK_LABELS,'complexity_labels':COMPLEXITY_LABELS,
+        'training_data':{'dataset_sha256':sha256(args.dataset),'balanced_rows':len(rows),'train_rows':len(train_index),'test_rows':len(test_index),
+                         'label_method_counts':dict(Counter(row.get('label_method','unknown') for row in rows))},
+        'validation':evaluation['summary'],'onnx_sha256':sha256(model_path),
+        'limitations':'Validation uses weak labels and deterministic augmentations; it is not an independent human-ground-truth benchmark.'
+    }
+    (args.output_dir/'classifier-meta.json').write_text(json.dumps(meta,ensure_ascii=False,indent=2),encoding='utf-8')
+    print(json.dumps({'model':str(model_path),'onnx_sha256':sha256(model_path),'evaluation':evaluation['summary']},indent=2))
+    return 0
+if __name__=='__main__': raise SystemExit(main())

training-config.json

@@ -0,0 +1,61 @@
+{
+  "release_version": "3.1.0-multisource-balanced",
+  "random_seed": 42,
+  "test_size": 0.2,
+  "splitter": "GroupShuffleSplit",
+  "group_key_priority": [
+    "derived_from",
+    "normalized_hash",
+    "id"
+  ],
+  "classifier": {
+    "type": "sklearn.linear_model.LogisticRegression",
+    "solver": "lbfgs",
+    "C": 4.0,
+    "max_iter": 3000,
+    "class_weight": "balanced"
+  },
+  "preparation": {
+    "confidence_threshold": 0.65,
+    "target_per_task": 800,
+    "max_per_task": 2000,
+    "accepted_label_methods": [
+      "source_fixed",
+      "human_override"
+    ],
+    "augmentation": "deterministic lexical variants"
+  },
+  "features": {
+    "input_size": 1544,
+    "word_bigram_bins": 1024,
+    "character_trigram_bins": 512,
+    "numeric_features": 8,
+    "hash": "FNV-1a 32-bit over JavaScript UTF-16 code units"
+  },
+  "labels": {
+    "task": [
+      "general_chat",
+      "writing",
+      "translation",
+      "summarization",
+      "research",
+      "coding",
+      "mathematics",
+      "document_analysis",
+      "high_stakes"
+    ],
+    "complexity": [
+      "low",
+      "medium",
+      "high"
+    ]
+  },
+  "reference_environment": {
+    "python": "3.13.5",
+    "numpy": "2.3.5",
+    "scikit-learn": "1.8.0",
+    "regex": "2026.5.9",
+    "onnx_opset": 13,
+    "onnx_ir_version": 8
+  }
+}

upload_to_hub.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+import argparse
+from pathlib import Path
+from huggingface_hub import HfApi
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Upload the Veritiana classifier repository to Hugging Face Hub.")
+    parser.add_argument("repo_id", help="Target repository, for example Veritiana-AI/prompt-task-complexity-classifier")
+    parser.add_argument("--private", action="store_true", help="Create the repository as private")
+    args = parser.parse_args()
+
+    root = Path(__file__).resolve().parent
+    api = HfApi()
+    api.create_repo(repo_id=args.repo_id, repo_type="model", private=args.private, exist_ok=True)
+    api.upload_folder(
+        repo_id=args.repo_id,
+        repo_type="model",
+        folder_path=str(root),
+        ignore_patterns=["*.zip", "__pycache__/*", ".venv/*", "node_modules/*", "dist/*"],
+        commit_message="Publish Veritiana Prompt Task & Complexity Classifier v3.1.0",
+    )
+    print(f"Uploaded to https://huggingface.co/{args.repo_id}")
+
+
+if __name__ == "__main__":
+    main()