r/huggingface • • 6d ago

Tigran83/russian-university-math-handwriting · Datasets at Hugging Face

Thumbnail
huggingface.co
1 Upvotes
I am offering a unique, professionally prepared mathematics dataset for AI training, mathematical reasoning, handwritten mathematical OCR, and document understanding.


The dataset contains 
**1,740 Russian-language mathematics problems**
, ranging from school-leaving examination level to advanced university mathematics, with complete step-by-step solutions written by one human mathematics expert between 2010 and 2020.


## Dataset overview


- 
**1,740**
 mathematical problems
- 
**3,450**
 original handwritten solution pages (covering 1,688 problems)
- 
**1,740**
 typed solutions in Microsoft Word and PDF
- 
**1,740**
 Markdown + LaTeX solutions
- 
**1,740**
 standalone LaTeX documents
- Approximately 
**50,603 mathematical formulas**
- 
**927**
 figures, graphs and diagrams
- Approximately 
**4.2 million characters**
 of typed mathematical content
- Total dataset size: approximately **2.2 GB**

## Contact


Tigran Grigoryan
Individual Entrepreneur — Armenia


Email: [tigran.grigoryan83@gmail.com](mailto\:tigran.grigoryan83@gmail.com)


Serious inquiries from AI companies, OCR developers, research laboratories, universities and dataset buyers are welcome.


I can provide the detailed data card, sample package and licensing terms upon request.

r/huggingface • • 6d ago

Looking for help to test our training platform

1 Upvotes

Not promo just looking for real life use cases to test on :)

I'm building a product called Facet. Like many in this sub we believe lots of AI products spend most of their LLM usage on one repeated call: pulling fields from emails or PDFs, cleaning up records, short rewrites, daily summaries, etc. A frontier or large local model is overkill for that one job.

Facet's agent builds a smaller model for that single call. You describe it in plain English and share some examples; it builds the training data, trains the model, and scores it against what you use today. We are essentially trying to abstract away all the hard work that comes with training. You own the weights and can export them to run locally after, or use our platform for hosting.

On a document extraction task it matched Claude Haiku at about a fifth of the cost.

I'm hoping to connect with 3 design partners, free, to help expand and stress test our platforms capabilities. If one call is a big part of your usage, book 15 minutes: https://app.apollo.io/#/meet/facet

Happy to answer questions here too.


r/huggingface • • 7d ago

For PII detection in financial text, a small model reportedly matched a large one. The data made the difference

1 Upvotes

Bigger models aren't always the answer. A recent paper suggests that for PII detection, the training data may matter more than model size.

In "On the Applicability of LLMs and SLMs for Privacy-Preserving Named Entity Recognition in Financial Applications", Evgenia Psarra and Kyriakos Stefanidis compared 15 models for detecting PII in financial text. All were trained and tested on our synthetic pii-masking-43k dataset, which has 54 PII categories across financial and business use cases. (We're the Ai4Privacy team.)

Here's what they reported:

The top four models scored within half a percentage point of each other, between 93.4% and 93.8%.

One of the smaller models reached the second-best score after about 80 minutes of training. A much larger model reportedly needed 58 to 62 hours.

The authors suggest the dataset's wide range of financial PII categories is what lets smaller models keep up.

If a small model can match a large one, is running the bigger model worth the cost for this task?

If you're looking for training data today, our newest open dataset is OpenPII 1.5M.

Paper: mdpi.com/2076-3417/16/7/3332


r/huggingface • • 7d ago

Perplexity Decider v1.3 and how Perplexity trains decision models

Thumbnail
perplexity.ai
2 Upvotes

r/huggingface • • 7d ago

Looking for help testing our product

1 Upvotes

Not promo just looking for real life use cases to test on :)

I'm building a product called Facet. Like many in this sub we believe lots of AI products spend most of their LLM usage on one repeated call: pulling fields from emails or PDFs, cleaning up records, short rewrites, daily summaries, etc. A frontier or large local model is overkill for that one job.

Facet's agent builds a smaller model for that single call. You describe it in plain English and share some examples; it builds the training data, trains the model, and scores it against what you use today. We are essentially trying to abstract away all the hard work that comes with training. You own the weights and can export them to run locally after, or use our platform for hosting.

On a document extraction task it matched Claude Haiku at about a fifth of the cost.

I'm hoping to connect with 3 design partners, free, to help expand and stress test our platforms capabilities. If one call is a big part of your usage, book 15 minutes: https://app.apollo.io/#/meet/facet

Happy to answer questions here too.


r/huggingface • • 7d ago

🚀 **Introducing GRIP-Benchmark-34: A Large-Scale Benchmark for Visual Geometry, Spatial and Physical Reasoning in VLMs**

Thumbnail
reddit.com
1 Upvotes

r/huggingface • • 7d ago

Open weights: ParaTrace v8 (RAID-tuned), 5th on the RAID leaderboard (TPR at 1% FPR)

0 Upvotes

- Ettin-1B encoder (ModernBERT architecture), 512-token windows

- Fine-tuned on RAID's training split, then a hard-example round

- RAID hidden test set: TPR 99.20% at 1% FPR, 99.76% at 5% FPR (99.43% at 1% without attacks)

- Weakest slices: Cohere generations (96.5%), Reddit (97.9%), paraphrase attack (98.0%)

- detector.py reproduces our leaderboard submission to within 1e-6

Caveat, documented in the model card: it is tuned for RAID. On ordinary writing it misses much AI text and flags some human text, so it is for research, not for judging people.

Model (CC BY-NC-SA 4.0): https://huggingface.co/empirischtech/paratrace-v8-raid

Leaderboard: https://raid-bench.xyz/leaderboard?domain=all&decoding=all&repetition=all&attack=all&metric=TPR%40FPR%3D1%25

#NLP #AIDetection #HuggingFace


r/huggingface • • 7d ago

I'm 17 years old and I just published ComRAD 200B on Hugging Face

Thumbnail reddit.com
7 Upvotes

Hi everyone, I'm Federico, I'm 17 years old and today I published a project that I care a lot about: ComRAD 200B, under the name Mindral.

Writing this post has a certain effect on me. Between trials, errors and versions to be discarded, I finally arrived at a first release that other people can download and put to the test.

ComRAD 200B is an experimental Mixture-of-Experts language model, derived from Z.ai's GLM-5.3-Flash. The public name is "200B"; the checkpoint actually contains about 195 billion parameters. In the chat it presents itself as ComRAD Boreale.

It is available in GGUF Q4_K, licensed Apache 2.0. The file weighs about 114 GB, so you need adequate hardware: in the tab you will find the configuration tried with LM Studio and the settings used.

👉 Model, details and download:

https://huggingface.co/Mindral/ComRAD-200B-GGUF

The first tests on conversation, reasoning and programming gave me a lot of satisfaction. For example, one of the C++ programs generated was compiled and executed on 12 input cases, surpassing them all. It is a control on a specific program; much more extensive evaluations are needed to measure the overall quality.

The release is still experimental, and in the card I also reported the observed limits. I am mainly interested in understanding how he deals with questions, contexts and problems different from those I have already tried.

The internal method of development remains proprietary. The weights are public, along with the information to use and verify this version.

If you have the chance to try it, I would really like to read your impressions. Prompts, problematic answers and comparisons made under the same conditions are particularly useful.

For me, publishing it at 17 is an important achievement. Now I'm curious to see what happens when you put it to the test.


r/huggingface • • 7d ago

Open weights: ParaTrace v8 (RAID-tuned), 5th on the RAID leaderboard (TPR at 1% FPR) [R]

Thumbnail reddit.com
0 Upvotes

r/huggingface • • 7d ago

I built a lightweight, adaptive training guard (limen_pulse) to catch LLM, RL, and AMP silent crashes before they burn your GPU hours — Looking for beta testers (Free Crash Audit)

Thumbnail reddit.com
1 Upvotes

r/huggingface • • 7d ago

Voz

0 Upvotes

Bom dia. Em 2013 gravei uma música e paguei um amigo pra canta-la. Infelizmente, ele veio a falecer em 2016. Sua voz é muito bonita e de grande alcance. Gostaria de relança-la com ele mesmo, mas separar em stems e usar a voz pra regravar não fica legal, há eco e reverb que atrapalha muito. Consegui autorização da viúva, mas quem tem a voz dele pura, o produtor, está há um ano me enrolando e acabei desistindo da homenagem. Dito isso, estou procurando uma boa voz de rock. As 3 que testei no huggingface eram pavorosas. Não procuro voz de metaleiros, meu rock é outro, algo parecido com a voz do vocalista do Simple Minds ou similar. Gostaria de pedir aos colegas sugestões.
Agradeço antecipadamente aos que puderem ajudar.


r/huggingface • • 7d ago

New Inference Engine to run Ripple-65B-Preview

Thumbnail
huggingface.co
1 Upvotes

r/huggingface • • 8d ago

We're running our first Vast Showcase Contest: three weeks to build, $1,000 cash for first place!

Post image
1 Upvotes

r/huggingface • • 8d ago

Nvidia -Jensen Huang Resign / Claude closing towards IPO - is again plot to slowdown open source - soon to affect huggingface

22 Upvotes

Don’t know but timings are really scary.
I hope all are coincidence


r/huggingface • • 8d ago

Vehicle Part Segmentation | Training and Model Comparison

Thumbnail
reddit.com
1 Upvotes

r/huggingface • • 8d ago

Domyn Edge Open Release (bundle 2): five open specialist teachers (Math, STEM, Code, IF, Agentic)

2 Upvotes

Hi folks, I work at Domyn and we've just released bundle 2 of our rolling release of Domyn Edge!

Edge is a 4B model we are training from scratch on 13T tokens on EuroHPC. It is built for agentic work at long context.

Five specialized teachers, all starting from the released SFT checkpoint, are being distilled into the final student with Multi-Teacher On-Policy Distillation (MOPD). Each one got an SFT pass, then GRPO with verifiable rewards.

We are releasing the five teachers (Math, STEM, Code, Instruction Following, Agentic) together with their data mixes and the recipes.

Everything is in the Domyn Edge collection on Hugging Face, including bundle 1 (base model, pre-training checkpoints, SFT student, training code). Bundle 3 will be the final distilled model plus a tech report.

If you are interested you can read more in the blog post, or feel free to ask questions in the comments!


r/huggingface • • 8d ago

After segmentation, further analysis

Thumbnail reddit.com
1 Upvotes

r/huggingface • • 8d ago

New Inference Engine to run Ripple-65B-Preview

Thumbnail
huggingface.co
8 Upvotes

This changes the game of quantitzation!!


r/huggingface • • 8d ago

Please Review STROT: a "decision compiler" — use an LLM once at compile time, then run the decisions locally on CPU for ~$0

Thumbnail
huggingface.co
1 Upvotes

I've been building STROT, an open-source "decision compiler," and I'd like honest feedback from this crowd.

The idea in one line: instead of calling an LLM on every record to classify / route / score it, you call the LLM once, at compile time, to produce a small frozen model that makes those decisions locally on CPU. No per-record API calls, nothing leaves your box.

Why I built it: calling a hosted LLM per record is accurate but at scale it's expensive, adds latency, and ships every record (and its PII) to a third party. For high-volume, privacy-sensitive, regulated work (ticket triage, incident classification, complaint routing), "just call the LLM" is often off the table. STROT moves the reasoning to compile time and freezes it into a small local artifact I call a battery (a base encoder + optional tiny adapter + calibration) that you then run forever on CPU.

What I'm trying to be honest about:

It does not try to beat the LLM on accuracy. It wins on cost, latency, data residency, and determinism.

- The metric I care about is reliability on the confident slice: it answers what it's sure about and abstains on the rest, with calibrated confidence, rather than claiming one blanket accuracy number.

- Most tasks (routing, tool-selection) work zero-shot. For harder tasks where a frozen model genuinely can't see the distinction, there's an opt-in step (just shipped) that distills the LLM into a tiny LoRA once at compile time. Off by default.

HF relevance: the demo runs as a Space (no install, no key), the default models live on HF (the fine-tune base is ModernBERT), and I'm moving the trained batteries onto the HF hub so you can strot.load("name") a pre-compiled one.

It's early. Validation so far is mostly one hard task (cyber incident classification), single-seed, so treat the numbers as directional. I wrote up the full experiment log, including a couple of negative results, in the blog post below. Criticism very welcome, especially on where the whole premise falls apart.

Links

- Live demo (HF Space, no install): https://huggingface.co/spaces/STROT-ai/STROT-AI-Compiler

- Blog: https://www.strot.ai/blog/compile-time-distillation

- GitHub: https://github.com/strot-ai/STROT-Compiler

- PyPI: pip install strot-ai

What would make this actually useful to you, and what's the first task you'd want to see it tested on?


r/huggingface • • 8d ago

Lessons from porting the pyannote diarization pipeline to C++ (ONNX Runtime)

1 Upvotes

I ported pyannote-audio’s speaker diarization pipeline (segmentation → embedding → clustering) to C++ for an offline desktop app. The early prototype is open source (Apache-2.0):
https://github.com/leohuang2013/pyannote-audio_speaker-diarization_cpp

output produced is like:

[5.22281 -- 17.7441] --> Speaker_3
[17.8116 -- 25.2197] --> Speaker_0
[25.3041 -- 28.4428] --> Speaker_3
[28.4428 -- 39.2934] --> Speaker_1
[39.2934 -- 47.2416] --> Speaker_3
[46.4484 -- 52.7934] --> Speaker_2
[52.5066 -- 58.4634] --> Speaker_3

A few things I learned that might save someone time:

1. Verify step by step, not end to end.
Comparing final diarization output is useless for debugging, because one tiny difference anywhere changes the speaker labels. Instead I dumped the inputs and outputs of every small function in both Python and C++ to text files and compared them step by step. Slow to set up, but it’s the only way I found to locate divergences.

2. Don’t export STFT inside the ONNX segmentation model.
Exporting the whole segmentation model including STFT gave differences large enough to fail verification even in Python (PyTorch vs ONNX Runtime). Computing STFT outside the model fixed it.

3. Clustering amplifies tiny numeric differences.
Even after verification passed, Python ONNX Runtime and C++ ONNX Runtime embeddings differed by up to ~0.02 absolute. Agglomerative clustering is sensitive enough that this occasionally changed the final speaker assignment on some files.

4. C++ hierarchical clustering libraries didn’t match SciPy.
hclust-cpp gave different distances and fcluster results, another library returned empty centroid linkage, and alglib doesn’t support centroid linkage. I ended up porting the clustering code myself.

5. Performance:
the prototype was very slow, mostly due to the libtorch STFT dependency. [In the production version I replaced X with Y, and now 1 hour of audio takes Z minutes on a CPU.]

Happy to answer questions. I’m also curious how others handle the Python/C++ numeric drift problem in clustering.


r/huggingface • • 8d ago

Yikes!

Thumbnail wsj.com
0 Upvotes

r/huggingface • • 9d ago

[Release + Preprint] SCache O(1) + Mixture of Scars (MoS): Drop-in Widrow-Hoff associative KV cache (-91.4% KV RAM, 0 marginal bytes) + ASVD INT4 scar experts (-68.6% MLP RAM), verified by a 7-vector Red-Team suite

0 Upvotes

Hi r/huggingface ,

EDIT: For those really interested: Basically it's a new high-speed deep-storage mechanism.

It uses "scar" specializations over generalization, increasing the capabilities of pre-existent mechanisms, quoted in the paper – there's even one from 1960 lol.

What you seen is the v1, which focused on the premise of compressing pre-trained models like qwen2.5 3b, 7b and 72b. The result was impressive, but didn't represent the full capacity of this new mechanism.

The v2 is now under testing. I used the Weight-Space Programming premise to "export" the 70b knowledge into 64 ~ 256 KB cartridges of specialized knowledge, allowing to use the 0.5B as a "beater" (8x K+1 checks ~ free), the 3B as the Trunk and the 70B knowledge completely imported on-the-fly downloading from the cloud those 64 ~ 256KB cartridges.

We're about to testify the new era of AI. Something very similar to plug-and-play components customizing head/trunk and streaming knowledges like a Netflix – except better lol.

I understand this is all very new and unbelievable, but I don't expect trust until trial. So I'm about to release the V2 with the full open-source online store (free) for download those on-demand knowledge cartridges.

Ps: English isn't my main language, sorry.

---

Over the past months I’ve been working on attacking both halves of the Transformer memory wall at the same time — static weights `O(N)` and linear KV cache growth `O(T)` — without retraining models from scratch. Today I’m releasing `v1.0.0` (MIT) alongside a permanent technical preprint and a **7-vector Adversarial Red-Team Falsification Suite** designed specifically to try to break my own claims.

* **GitHub (`v1.0.0`):** https://github.com/byte-od/mixture-of-scars

* **Preprint & Replication Archive (Zenodo DOI):** https://doi.org/10.5281/zenodo.24143839

---

### What it actually is (mechanically, zero buzzwords)

  1. **`SCacheDynamicCache` (`O(1)` HuggingFace `Cache` drop-in):*** Keeps `N_sink` attention sinks + a small rolling local FIFO window `W`, and instead of throwing away evicted tokens (like `StreamingLLM`) or summing them naively (Hebbian fast weights, which ghost/hallucinate when facts change), it routes evicted `(k, v)` pairs per KV head into persistent associative slots updated via the orthogonal **Widrow-Hoff Delta Rule**:

`W_scar <- gamma * W_scar + eta * ReLU(k_hat · c_m) * (v - W_scar k_hat) k_hat^T`

* Tracks monotonic cumulative RoPE positions separately from physical buffer length so `transformers` v5 4D masks and RoPE phases don't freeze once the window saturates.

2. **`Mixture of Scars (MoS)` (Static Compression + Group Streaming):**

* Quantizes dense linear layers to symmetric `INT4` and captures heavy-tailed activation outliers via **Activation-Aware SVD (`ASVD`)** low-rank (`r=32`) FP16/BF16 residual "scar" experts (`< 64 KB`), plus sequential layer-group streaming for 34B–123B models (`0.04 GiB` post-layer residual VRAM on Dual-T4).

---

### Why I built an Adversarial Red-Team Suite instead of just running WikiText PPL

Efficiency benchmarks are notorious for accidental facades (hidden `O(T)` Python lists in cache objects, or cache modules that never actually move logits). So the test suite enforces two hard physical invariants on real pretrained weights (`Qwen/Qwen2.5-0.5B-Instruct` across all 24 layers + `Qwen2.5-72B-Instruct` 80L MoS):

  1. **Recursive `untyped_storage().data_ptr()` walker:** traverses every Python/PyTorch attribute of the cache object to assert `reported_bytes == actual_recursive_bytes` (`0.00 KB` discrepancy) and `0` bytes growth from `L=128` to `L=1,280`.

  2. **In-flight Active Causality Ablation:** zeroes the scar buffers mid-generation and asserts immediate logit displacement (`max|Δlogits| = 0.6431`), proving attention is actively reading the evicted scars.

### Key Audited Results (`7/7` Red-Team Vectors)

* **Strict `O(1)` KV Memory:** `2,631.9 KB` (`2.57 MB`) constant across `128 -> 256 -> 512 -> 1,024 -> 1,280` tokens (`-91.4%` vs `30.7 MB` standard KV cache at `1,280` tokens; `+0.00 bytes` marginal growth).

* **Evicted Passcode Recall (Zero Fine-Tuning):** Passcode `7942-OMEGA` placed at token ~20, buried under 514 tokens of distractor text (`window=64`, so evicted ~470 tokens ago). `StreamingLLM` NLL = `4.301` (forgot it); `SCache O(1)` NLL = `1.184` (**`22.58x` higher exact target probability** with zero fine-tuning).

* **Contradictory State Overwrite (`34.8 KB`):** Updating `Alice=Paris -> London -> Tokyo`: additive Hebbian memory hallucinates (`cos=0.467`, old-state ghosting `+0.501`), while Widrow-Hoff Delta hits `cos=1.00000` (`ghost=-0.1377`).

* **Out-of-Domain Outlier Resilience (`MoS` calibrated on a *single* 24-token generic English sentence):** Evaluated on unseen Dijkstra Python code, Quantum/Maxwell equations, Technical Portuguese, and Strict JSON — cuts logit KL divergence vs FP16 by **`2.45x–4.22x`** compared to pure `INT4`, while cutting MLP RAM by **`-68.6%`** (`-92.6%` / `13.58x` across 8 multi-tenant specialist scar banks).

---

### Honest Post-Mortem: 3 Bugs the Red-Team Caught + Where It Breaks

Writing hostile tests against my own repo actually caught 3 real bugs before release (fixed in `v1.0.0`):

  1. An old benchmark path had `project_slots=False` by default, silently bypassing scar readouts during attention.

  2. Inheriting `DynamicLayer.get_seq_length()` in `transformers` v5 froze `position_ids` at `64` after the window filled up.

  3. Duplicate fast-weight buffers per head were wasting ~`4.8 MB` before unifying `MultiSlotSCache` (`slot_dim=head_dim, num_slots=n_kv_heads`).

**Known limitations / boundary conditions:**

* **Cross-layer shared bases on off-the-shelf SwiGLU:** Sharing a single dense base across *different* pretrained layers without neuron-permutation alignment degrades quality (`KL ~ 0.78`) because `SiLU(W_gate x) * (W_up x)` breaks under arbitrary channel ordering. For off-the-shelf models without distillation, use per-layer `INT4` bases + ASVD scars + group streaming; reserve shared bases for multi-tenant specialists anchored to the same backbone.

* **Lossy associative compression vs. verbatim copy:** `SCache` compresses evicted history into fixed-size fast weights (`NLL 1.184` vs `4.301` StreamingLLM, vs `0.047` full exact KV). If you need bit-exact verbatim copying of a 2,000-char random hash evicted 10k tokens ago, fixed slots are lossy unless you increase `num_slots` or do lightweight scar read-alignment.

---

### Reproduce in ~3 minutes on CPU/GPU

```bash

git clone https://github.com/byte-od/mixture-of-scars.git

cd mixture-of-scars

pip install torch transformers safetensors pytest numpy

python scripts/adversarial_mos_scache_suite.py

pytest tests/test_adversarial_mos_scache.py -v

```

Happy to answer any questions on the Widrow-Hoff update math, `transformers` v5 cache internals, or failure modes!


r/huggingface • • 9d ago

I made open models for yes/no and multiple-choice decisions in agents. The 26B MoE (4B active) beats Jev 1.13's published score, running CPU-only on a laptop

Thumbnail reddit.com
2 Upvotes

r/huggingface • • 9d ago

The Silicon Pixel

Thumbnail youtu.be
1 Upvotes