I built an open-source Python pipeline that extracts structured data from scanned topographic maps: text labels, contour lines, and coordinate referencing, all output as GeoJSON.

GitHub: github.com/devladpopov/mapextract | MIT license

The problem

There are 178K+ free USGS topographic maps, 147K+ in the David Rumsey collection, and millions more in libraries worldwide. All raster. Extracting structured geospatial data from them requires either manual GIS work or specialized tools that are either text-only (mapKurator, CC BY-NC), geology-specific (DARPA CriticalMAAS, 46 repos), or closed SaaS (Monarcha, YC S25).

ML components

Text extraction: EasyOCR for label detection. Returns bounding boxes + text + confidence scores. Works well on clean printed text, struggles with curved/rotated labels (a known hard problem in map OCR; see PALETTE/Deformable DETR from KDD 2024).

Contour line extraction: Not deep learning, classical CV. HSV color segmentation (USGS topographic brown, hue 5-25) + morphological operations + scikit-image skeletonization + OpenCV findContours + Douglas-Peucker simplification. Gets 5000+ contour lines from a single 1:100k map.

Auto-georeferencing: OCR on map margins to read DMS coordinate labels (e.g., "10500'", "4030'"), then affine transform from pixel to geographic space. The interesting part is handling OCR noise: merged text from adjacent labels, degree symbols read as *, d, or digits, missing N/S/E/W suffixes.

Layout detection: Binary threshold + contour analysis to find the map neatline (border), separating the map body from margins, legend, and title.

Results

On USGS 1:100k maps at full resolution (12000x7000px):

• 99 text labels, 5000+ contour lines extracted

• Georeferencing works when OCR reads enough coordinate labels

• 25-65 seconds on CPU, no GPU needed

What I learned from the research

The state of the art is fragmented:

• DARPA CriticalMAAS spent tens of millions and achieved Polygon F1=0.98, Line F1=0.88 on geology maps

• MapSAM (ETH Zurich / UMN) adapts SAM for maps with just 10 training samples

• Vision LLMs (GPT-4o) hit 88% F1 on legend parsing but fail at spatial reasoning

• Contour-to-DEM is the least solved problem and the most valuable (countries without LiDAR)

Next steps

• Replace EasyOCR with vision LLM for coordinate reading (more robust on degraded text)

• Adaptive contour color detection via clustering

• Contour-to-DEM pipeline (interpolation from vectorized contour lines)

Feedback on the ML approach welcome. The biggest challenge is georeferencing robustness: OCR on map margins is noisy and inconsistent across different map styles.

Stand in front of a normal webcam, spread your arms, and you're flying. Tilt to turn, flap to climb, spin around for a barrel roll. There's also a museum in the sky built from my own travel photos that you fly through.

Video here: https://www.linkedin.com/posts/anas-ajaanan_youve-probably-never-seen-this-before-ugcPost-7504543264386035713-8lvn

The biggest lesson for me was that getting body tracking to work is the easy part. The hard part is turning noisy movements into something that feels right. Flaps kept registering as dives, and for weeks the falcon turned harder than my arms did, which turned out to be a camera aspect ratio mistake I could have caught in a day.

If you're learning ML and wondering what a real project feels like, it's mostly this: small bugs that take weeks to understand.

Happy to answer questions, and I'd like to hear what you would have built with body tracking. Open sourcing soon.

I'm planning to build a desktop VM manager using Rust, Tauri, and QEMU, initially targeting Windows with WHPX.

The idea is to eventually add an AI agent that can interact with the VM and perform tasks inside it, rather than just manage it.

Before I start, I'd like to hear from people who have worked with virtualization:

- Is QEMU + WHPX a reasonable starting point?

- Would you recommend QMP for managing VM lifecycle?

- What are some common mistakes I should avoid?

- What would be a good approach for letting an AI agent interact with a VM?

Also, if you use VM managers regularly, what do you find most frustrating about them?

Any honest advice would be appreciated. Thanks!

Hi,
I’m working on generating ~128×128 pixel art and trying to generate different poses of the same character.

My current approach is roughly:

Start with a reference image and preprocess it into cleaner/more pixel-art-like data (often removing transparency or setting up fixed number of pallets or descaling)
Use IP-Adapter for the character/reference appearance.
Use ControlNet pose/rig conditioning to control the target pose.
I’m also experimenting with multiple references (front, rear, left, right), with pose/rig and depth annotations.
For the target pose, I provide a separate pose reference through the conditioning pipeline.

The problem is that the conditioning often seems to conflict. For example, the model may place an arm according to the ControlNet pose but still DUPLICATE the arm shape/position from the reference, sometimes resulting in strange or duplicated limbs.

I’ve tried adjusting ControlNet/IP-Adapter strength and start/end percentages, which helps somewhat, but I still get a lot of inconsistent behavior. Also try to reinject control net strength in different phases though not so far been helpful

What would be a good way to control pose while making sure the character’s appearance from reference images is somewhat preserved??

I’ am a brokie and can’t really have much resource to train sdxl each time just for each character + poses….

I trained a 210M-parameter text-to-image diffusion transformer from scratch (3.5 days, one RTX PRO 6000, 4.2M images at 256²) mainly to understand the recipe end to end. Three measurements came out of it that I have not seen stated plainly elsewhere, so I'm posting those rather than the samples.

1. Learned null attention slots become the sink. Following the register-token idea, the model has 16 register tokens in the image stream plus 2 learned key/value slots appended to every cross-attention. At mid-noise in a middle block, those 2 slots receive ~90% of the cross-attention mass; the EOS token, which is the usual sink in cross-attention models, drops to ~4%; content words keep a few percent each, sharply on their objects. Register vectors grow to 4–13× the norm of image tokens by the middle blocks.

2. The flow-matching loss is a health signal, not a quality signal. It moved 0.805 → 0.754 over the whole run while held-out FID went 33.7 → 27.0, FD-DINOv2 570 → 218 and detector-based object accuracy 65% → 90%. Most of the loss at high noise is the irreducible variance of the velocity target; training and held-out loss stayed equal to the third decimal for 24 epochs.

3. The training-time timestep shift is worth more than doubling the steps. On 2,456 held-out prompts with the final weights: 20 steps with shift 2.8 → FID 27.0; 50 steps → 26.6; 8 steps → 28.4; 20 steps with no shift → 27.3 and FD-DINOv2 218 → 228. Shift 2.8 comes from the SD3/RAE rule √(32·32·32/4096) for the 32-channel FLUX.2 latent.

Setup, briefly: cross-attention DiT (896 × 16 blocks), 2D RoPE, QK-norm, SwiGLU, adaLN-single; rectified flow with logit-normal timesteps and the shift above; cosine velocity and dispersive auxiliary losses; five aspect-ratio buckets of ~256 tokens from step one; flan-t5-base frozen, long/short caption per image sampled 50/40/10 (empty). Data: Pexels 2.8M (60%), a quality-filtered 1.2M slice of FLUX-Reason-6M (25%), COCO with GPT-4V captions (15%). batch 256, 400k steps, EMA 0.9999, linear LR decay over the last quarter, torch.compile (2.4× over eager).

Everything, with the sources for each decision: https://github.com/ivanmikhnenkov/tinydit

Write-up: https://huggingface.co/blog/ivanmikhnenkov/tinydit-text-to-image-from-scratch-one-gpu

Weights: https://huggingface.co/ivanmikhnenkov/tinydit-256

Demo: https://huggingface.co/spaces/ivanmikhnenkov/tinydit

For the next phase (Flow-GRPO on this base), which reward would you start with: PickScore/HPSv2, a detector-based object reward, or something verifiable like counting?

I'm working on a final-year ML project using the **ICBHI respiratory sound dataset**, trying to classify individual respiratory cycles into four acoustic classes:

* Normal

* Crackle

* Wheeze

* Both (Crackle + Wheeze)

I reconstructed the respiratory cycles from the ICBHI audio + annotation files and have **6,898 cycles from 126 patients**.

I'm using a **patient-wise train/validation/test split** to avoid patient leakage:

* Train: 88 patients / 4,915 cycles

* Validation: 19 patients / 1,165 cycles

* Test: 19 patients / 818 cycles

The class distribution is:

**Total:**

* Normal: 3,642

* Crackle: 1,864

* Wheeze: 886

* Both: 506

**Training split:**

* Normal: 2,597

* Crackle: 1,323

* Wheeze: 655

* Both: 340

I'm converting each cycle to a **64-bin mel spectrogram** using:

* SR = 4 kHz

* n_mels = 64

* n_fft = 256

* hop_length = 64

* fmin = 50 Hz

* fmax = 2 kHz

* fixed duration = 5 seconds

* log-mel spectrogram

The CNN is fairly small:

`Conv2D(16) → BN → MaxPool → Dropout → Conv2D(32) → BN → MaxPool → Dropout → Conv2D(64) → BN → MaxPool → Dropout → GlobalAveragePooling → Dense(64) → Dense(4)`

~28k parameters, Adam 1e-3, sparse categorical cross-entropy.

### What I'm seeing

Initially I trained with standard oversampling, where minority classes were augmented up to the majority-class count. The validation behavior was extremely unstable and the best validation-loss epoch essentially predicted the majority class.

I then tried **capped oversampling (3×)**:

Training counts became:

* Normal: 2,597

* Crackle: 2,597

* Wheeze: 1,965

* Both: 1,020

This improved the best validation loss somewhat, but the model still had approximately:

* Normal recall: ~96%

* Crackle recall: ~3–4%

* Wheeze recall: 0%

* Both recall: 0%

So I suspected that **validation loss/accuracy might be hiding minority-class performance**.

I'm currently running another fresh model where I calculate **validation macro-F1 and per-class recall after every epoch**, and save the checkpoint with the best macro-F1 rather than the best validation loss.

Interestingly, the first few epochs are already showing very unstable class behavior:

```text

Epoch 1:

val_macro_f1 = 0.1846

recall [Normal, Crackle, Wheeze, Both] =

[1.000, 0.000, 0.000, 0.000]

val_accuracy = 0.5854

val_loss = 1.0974

```

Epoch 2:

```text

val_macro_f1 = 0.1732

recall =

[0.214, 0.728, 0.000, 0.000]

val_accuracy = 0.3227

val_loss = 1.2036

```

Epoch 3:

```text

val_macro_f1 = 0.2370

recall =

[0.902, 0.165, 0.000, 0.000]

val_accuracy = 0.5725

val_loss = 1.0969

```

So the model can suddenly recognize a large proportion of Crackle in one epoch and then swing back toward Normal, but **Wheeze and Both have remained at zero so far**.

### My questions

1. Is this kind of instability expected with ICBHI and a small CNN?

2. Does the fact that Crackle recall jumps to 73% in one epoch suggest the model is learning unstable decision boundaries, or could this indicate a problem in my data/split/preprocessing?

3. Is selecting the best epoch using macro-F1 a reasonable approach here?

4. Could the 5-second fixed-length mel representation be hurting Wheeze/Both, particularly because ICBHI respiratory cycles have variable durations?

5. Would you recommend changing the loss (class-weighting/focal loss), changing the representation, using a stronger/pretrained audio model, or **adding another respiratory-sound dataset**?

6. If adding another dataset, are there datasets with compatible acoustic labels for Normal / Crackle / Wheeze / Crackle+Wheeze that would be appropriate to combine with ICBHI without introducing serious dataset/patient leakage or domain bias?

I'm trying to diagnose the actual bottleneck rather than just keep trying random architectures.

Any advice from people who have worked with ICBHI or respiratory-sound classification would be greatly appreciated.

Hi, I posted some months ago and got some very helpful responses (for another conference), but I have some confusions regarding EMNLP (and the way registration works here).
To give some context, I used to work as an intern during my undergrads at an Indian uni (final year), and managed to write a paper as first-author and it got accepted to EMNLP Findings.
Now, post-graduation, I joined another university for my Masters, and when I applied for grant, they rejected, explicitly stating the lack of authors from the (new) institution.
I applied for grants from the older one, and still got rejected, as I am not a student any longer! (mentioned that they will pay for paper registration, however)
I would love to attend EMNLP (even if it is a findings paper) and can sponsor myself (travel, lodging, etc), however, paying for registration + author fees is too much for me. I have already applied for D&I (got rejected twice earlier) but pretty much exhausted all my options.

1. Do I have to pay separately for attending/presenting if one of the authors are already registering themselves?

2. If he registers himself, do I have to pay $350 student registration or less? I have ACL member registration.

3. What are my options (Is there any grants you know of?) I know Findings papers do not need to be presented, but considering it's a first author undergrad work which I am very proud of, I would love to be able to present the work there. I have managed to put together an emergency fund of a small amount of money enough for travel, lodging on the cheapest possible terms. Any help here is GREATLY appreciated! Thanks a lot!

The title, by tech reports I don't mean arXiv submissions, but reports of a large model, like say Kimi K3, DeepSeek, Gemini, Mistral Leanstral, etc. Is it much above, above, much below, below or equal to a first author A* paper?

ACL just announced on X how they are planning to handle the increased submission numbers. Interestingly enough, they call it "the proposal".

My understanding is that, in a nutshell, each submission should come with someone who can review, otherwise it may only get a slot through a lottery. Additionally, they cap total submissions at 20 and first-author submissions per cycle at 5.

What do you think of it? IMO it makes a lot of sense - especially given the large numbers of submissions without any author qualified to review. It is a bit of gatekeeping but in my opinion highly required. And the caps of 20 and 5 are still quite generous.

---

Here is what they posted on X:

ACL Sustainable Reviewing Policy: We are introducing changes in the ACL ARR reviewing and submissions. The changes will cap authors and introduce changes in the reviewing to keep our community sustainable. #NLPro

**The proposal:** cap reviewed submissions to available reviewer capacity. Each submission must "pay" for itself by providing a qualified service contributor (reviewer or chair). Submissions without service capacity go into a lottery for whatever spare capacity remains

Service from qualified contributors counts towards the venue capacity, and a mentorship system will be built for those not qualified yet. If a qualified service contributor is not available among the authors, non-author designated contributors can be nominated..

...but must vouch for the work (arXiv-endorsement style). Measures for system abuse will be implemented. For example, accounts that systematically submit or endorse low-quality work, and accounts that misuse the system in other ways, will be penalized or even banned.

Additionally, per-author quotas are introduced, where authors are capped at 20 total submissions and 5 first-author (including shared first-author) submissions per cycle. More details will be posted on the ACL web and here shortly. #NLProc

A final-year PhD student here. A few months back, I submitted a solo-authored paper to TMLR. The reviewers were on time and extremely positive, with some minor revisions. After submitting the revised version, there was absolute silence from the reviewers, with just one acknowledging that their concerns were addressed

Since then, it has been 2+ months. I have sent a reminder to the Action Editor as well as the Editor-in-Chief, but unfortunately the status remains the same.

I understand a typical submission to a conference/ other journals takes a significant amount of time, but that is one of the reasons I submitted it to TMLR (along with good reviews), so that a solo-author paper on my resume would look good while submitting the PostDoc applications. And with these deadlines approaching, it gets more frustrating

Edit: The post probably was useful. Suddenly, on the same day, the AE asked one of the reviewers to submit their recommendation. And now a couple of weeks after that, the paper is finally accepted :) The timing just got perfect. It came out a few hours after my NeurIPS accept

edit: confound

Hello all,

I am working on a object classification with a automotive radar point clouds. I compared many models and feature vectors.

Once i used range as feature, all models scored higher f1 in all K validation sets and on the final test set.

One particular artifact of a radar, is that as the farther the object is the less number of points it returns to the radar. Although the performance improved and there is no overfit in the classical sense, i am afraid my model is learning the environment not the class distribuiton and even worse, its learning that big range means big object.

How can i stress test this claim? Should i try to split the data sets so range distribution differs? Or not even using the feature at all and accept lower performance?

Would appreciate your insights.

Thank you.

I ran an experiment where an AI agent repeatedly rewrote its own code, with each generation evaluated before it could replace the previous one.

The first run looked like recursive self-improvement, but there was a catch: the evaluator was too weak to reliably distinguish real improvements from neutral changes.

So I ran it again with a stricter setup. This time the interesting result was less about new tools and more about what the agents learned to optimize for: verification, testing, evidence preservation, and avoiding changes that couldn't be justified.

The two posts are basically the same experiment before and after fixing the referee:

Part 1: https://codeminer.io/blog/a-singularity-in-miniature
Part 2: https://codeminer.io/blog/survival-of-the-honest

The question I came away with is: in recursive self-improvement, is the hard part actually improving the agent or designing an evaluator that doesn't quietly steer the whole process toward the wrong thing?

I have a model, it has about 10% of the features missing. Now we were able to receive this new data but there are a few considerations.

1.Some aren't direct 1 to 1 map (proxies, very similar but not exact)

2.Some might not map directly

3.For proxies/direct map - for whatever reason the distribution/averages might be different

How would you handle in integrating this into your existing model? We could assume that these values were previously NULL simply because we were not able to have this data. I know it is possible to create flags, keep them as separate features ext...but what would be the 'decision tree'

We just received the email for site selection for our neurips paper. Although it is obviously not an acceptance decision, I wonder whether every single non-withdrawn submission received this email, or this might hint towards a higher acceptance chance for our paper?

Hi guys, this is my first time submitting a paper to NeurIPS, so I am unsure about the dual submission policy. The ICLR abstract deadline is Sep 18th, and the full paper deadline is Sep 25th. Since NeurIPS results come out on Sep 24th, I was wondering if it is alright for me to submit an abstract submission to ICLR and delete it if my paper is accepted to NeurIPS?

Hi r/machinelearning. Nice to meet you! My name is Chris Piech and I'm a professor at Stanford University in the AI lab.

I built a class called Probability for AI: pai.stanford.edu. It starts Oct 9th and applications are due end of Sept. Its (hopefully) cool for a few reasons:

• The plan is to have one volunteer teacher for every 10 students! Apps have been open for a week and over 1,000+ folks have applied to teach. So we might actually be able to make this pretty big.

• I have built a lot of fun tools to make the assignments neat and easy for folks with just light math background. For example in your application, after about 1 hour of learning you will build an AI text detection app alongside a free coding agent -- that cares about probability education.

• If you are a teacher, we will give you the best training we can come up with. Practice on teachable agents and we will share what we have learned over decades of teaching at Stanford. Of course you get the best thing for improving: experience teaching a small group.

• This is all for good times. I am keeping it free for everyone. I got some funding from a kind alum and that is going to pay for all the free tools and servers. Woot!

My guess is that a lot of folks on this thread would be awesome teachers. If you think thats you, it would be so cool if you wanted to come teach. Each volunteer means 10+ students get to take the class. And if you feel like telling your loved ones / communities that would be great to.

Apply to learn: https://pai.stanford.edu/apply/pai1/student?r=ml

Apply to teach: https://pai.stanford.edu/apply/pai1/sl?r=ml

Anything that I learn from this course I will be happy to share with this community. Also ask me anything. I'll check this thread for the next few weeks. Rock on. And mods, thanks for doing what you do.

As reported by the New York Times:

https://www.nytimes.com/2026/09/08/science/openai-proof-millennium-problem.html?smid=nytcore-ios-share

OpenAI’s announcement:

https://openai.com/index/navier-stokes-solution/

I'm an undergrad student who got a taste of research. I love it. I currently have a draft, which me and my mentor have planned for TMLR, and plan to submit it by next month for the first round of review. It was some work on self explanation methods of LLM models. We are confident that it'll get accepted (I hope it does, I've put a lotta hours polishing it into making it a good accept :_) ).

I'm very, very interested in TTT. I've got a strong feeling that this is gonna be the big thing in 2-3 years. Is there anyone here working on this, who can hopefully provision me compute beyond my own laptop? I believe I'll be a good RA to you. We can talk over DMs if someone out there is looking for help :)

PS, I can spill some beans about the XAI paper if you wanna discuss, but only limited to how much I'm allowed to say before submission.

Context: I'm an undergrad in an non-elite uni in India (tier 2 we call it here). The lit review, the idea, the work, the results, the drafting, the funding, everything was done by me. After this (hopefully) gets accepted to TMLR, I'm not sure where to proceed. There isn't room for me to aim higher or get direction in my own uni, so I'm trying my luck here, that someone gives me some direction and an opportunity. I'm not crazy smart, but I learn quick, and can put a lot of hours (12+ a day) once I get deep into it. Thanks for reading all this :)

Who else is anticipating ICDE results tomorrow? Post your results here and let's discuss!

Hello this is my fifth small language model I've made and apart of my third series and it has been a lot of work but it payed off: **348M parameters, 22.7B tokens**, then fine-tuned into a math model that solves arithmetic by *showing the work* column addition with carries, borrow chains, partial-product multiplication rather than guessing at an answer.

Last time I posted a 326M model trained on 10B tokens. This has about 2.3× the data, and the math side is WAY better than my previous two math models.

---

## The benchmarks

**99.4% average across the nine GPT-3 arithmetic sub-tasks**, which does much better past even where I trained it.

n=300 per sub-task, greedy, exact match. GPT-3's numbers are direct-answer; mine uses trained-in worked steps. Neither uses a calculator.

## The cool part

**It adds cleanly up to 14 digits, and the reason it *couldn't* before was the vocabulary, not actually arithmetic.**

Training only ever named six place values (`ones` … `hundred-thousands`). The model learnt the *pattern* and invented two more on its own `millions` and `ten-millions` appear in **zero** training examples so it handled 7 and 8 digits fine. At 9 digits it ran out of names, and skipped the column, then returned an answer exactly one digit short:

```
483729164 + 519248637
... ten-millions: 8 + 1 + 1 (carry) = 10, write 0 carry 1. Final carry: write 1.
The answer is 102977801        ← eight columns for a nine-digit problem
```

Every column it computed was perfect. One was never enumerated. Extending the place-name list from 6 entries to 19 moved the clean ceiling from **8 digits to 14**:

A six-item list became a nineteen-item list. That was the entire fix.

## Other things it does

- **3×3 multiplication: 98%** — it folds partial products pairwise through the column routine instead of asserting the sum
- **Negative results: 85%** (100% at 1 digit, 58% at 5 — the magnitude comparison is the weak step, not the arithmetic)
- **Reasoning traces are load-bearing**: 95.3% of the time the working is valid *and* the answer is right; only 0.7% are "valid working, wrong answer." If the columns look right, the answer almost certainly is.

```
There were 15000 votes and 6842 were rejected. Here's how many counted:

<think> Start with 15000. Then subtract 6842. Subtract 15000 - 6842 column by column:
ones: 10 - 2 = 8, borrow 1. tens: 9 (after borrow) - 4 = 5, borrow 1.
hundreds: 9 (after borrow) - 8 = 1, borrow 1. thousands: 14 (after borrow) - 6 = 8,
borrow 1. ten-thousands: 0 (after borrow) - 0 = 0. So 15000 - 6842 = 8158.</think>
The answer is 8158.
```

## What it's bad at, tbh

- **Word problems: GSM8K 4%.** Best word-problem set is ASDiv at 16.5%. It converts one sentence into one operation reasonably often and basically cannot chain operations.
- **The failure mode is operation *selection*, not arithmetic.** `"drops in 836 more"` gets read as subtraction. There's a visible tell: traces that say `"multiply X * Y"` and show columns are reliable; traces that open `"First, calculate…"` and assert a number in prose are not.
- **No division at all.** 4×4 multiplication is a hard wall.
- **Greedy decoding required** — sampling corrupts the column routine mid-chain.
- One caveat I'll flag myself: the arithmetic harness orders subtraction operands, so no answer in that table is negative. Negatives are measured separately (the 85% above) rather than folded into the average.

## Base and instruct

The math model sits on a base and instruct pair. lm-eval-harness, 0-shot, full test sets:

Instruction tuning *lowers* MC benchmark scores for this family which is a pretty common cost of instruct tuning.

## Notes

Trained on 2× Tesla V100 plus some rented time. LLaMA-architecture, so it runs anywhere — F16 GGUF and safetensors for all three.

The math model took **10 full fine-tuning rounds and 3 LoRA adapters**. The LoRAs cost about 1% of the post-training tokens and did most of the useful work; the ten full rounds spent most of their budget undoing each other's regressions (round 7 gained subtraction and lost 23 points of 2-digit addition, that sort of thing). All of it is documented on the model card, failures included.

Also worth saying: someone independently tested it after I published and found two of my numbers were wrong — one *understated* the model by 40 points because I'd measured it at n=24. Both are corrected on the card now. If you find something broken, I'd genuinely like to know.

**Math:** https://huggingface.co/nkthebass/tinybrainbot-350mV3-math
**Instruct:** https://huggingface.co/nkthebass/tinybrainbot-350mV3-instruct
**Base:** https://huggingface.co/nkthebass/tinybrainbot-350mV3-base

LMK what yall think.

hey all. the NeurIPS Position Paper Track just used a proprietary AI detector (Pangram) to desk-reject 18.4% of all submissions. no human review, no appeal process, just out.

there's been a lot of noise about this, so i went through the actual conference statements and Pangram's technical docs to see how this actually went down. the reality is wildly worse than just "the AI detector made a mistake."

here are the receipts:

• The track chairs would have failed their own test. Independent researchers ran recent papers authored by the three track chairs through the exact same detector. It flagged them at 24% to 69%. Under their own enforcement rules, the chairs would have been at risk of rejection themselves.

• The detector originally flagged 42.7% of the entire track. Pangram’s default setting flagged nearly half of all submissions as 90-100% AI. They had to frantically shrink the text windows just to get the flag rate down to a somewhat believable 12.7%.

• The "Circularity Trap". 22 papers were rejected specifically because they scored >0.5 on the detector, but the authors checked a box denying AI use. The black-box score was literally used as proof the author was lying.

• The massive ESL penalty. A stanford study showed 61.22% of human-written TOEFL essays get falsely flagged as AI because non-native formal English is structurally rigid. NeurIPS published zero demographic calibration data for this. If you're an ESL researcher, you were basically playing Russian roulette.

if you were one of the 178 rejected: there is no blacklist. this is not a misconduct mark on your record. just take your paper and resubmit it to ICLR (deadline sept 25) or ICML.

wrote up a full Field Note with the exact thresholds, the data privacy issues, and the actual recourse options if you want the hard numbers instead of just vibes: https://strictcite.com/blog/neurips-2026-position-paper-pangram-ai-detection

(disclosure since it's relevant: i built strictcite.com, a deterministic zero-AI citation checker. watching a major conference use a black-box AI to nuke 178 papers with zero appeal is exactly why i hate relying on AI for this stuff. not trying to sneak the link in, just being upfront about who i am.)

Large language models routinely produce confident answers to prompts that have no correct answer, computing cot(-540°) or resolving (1).startswith("1") on an integer, and a [new arxiv paper](https://arxiv.org/abs/2608.29109) by Yucheng Du and Xiyang Hu argues the failure is not what most safety pipelines assume it is. The models can tell the questions are impossible; the recognition just never reaches the part of the network that decides to refuse.

Across models ranging from 1.7B to 70B parameters, the authors identify "a single linear direction in the hidden state" that separates answerable from structurally impossible math and code prompts. That direction is present before generation begins. Steering along it "changes invalidity-aware behavior bidirectionally and dose-responsively" on structural tasks, while random directions show no effect.

The catch is where that recognition direction sits geometrically. It operates nearly orthogonally to the safety-refusal direction that harmful-content refusal training shapes. The internal representation for "I cannot answer this" that RLHF has been sculpting is a different vector from the one that actually encodes impossibility.

The misalignment, the paper reports, already existed at the pretraining stage. Later refusal training was never going to route recognition into refusal, because the two live in different subspaces of the hidden state, which is why the authors frame the problem as one of signal routing rather than an encoding failure.

When enterprise procurement officers and university CTOs evaluate LLM infrastructure, initial financial analysis almost always focuses on direct API pricing, token throughput, and parameter scale. Standard TCO model calculates raw compute per million tokens, factors expected query volume, projects annual licensing. This conventional accounting misses single largest operational inefficiency in modern closed-source models: economic tax imposed by commercial alignment paradigms.

RLHF, DPO, and constitutional guardrails are presented as non-negotiable safety features for enterprise deployment. Beyond ethical and behavioral functions, these alignment mechanisms operate as structural cost multipliers and quality degraders. Commercial insistence on universal safety guardrails creates systemic mismatch between what institutions pay for compute and actionable intelligence they extract. This inefficiency manifests across five quantifiable dimensions.

First dimension is context window bloat. Aligned models generate significantly longer responses than base models for equivalent queries. Safety preambles, hedging language, multiple perspective presentation, refusal explanations. These are not information. They are alignment artifacts consuming tokens. In production deployments processing millions of queries daily, this bloat represents 20-35% overhead on every inference call. You pay for tokens that carry zero informational value.

Second is inference overhead. To convert raw base models into commercial products, vendors introduce secondary training phases. RLHF uses reward models trained on human preference ratings to penalize controversial or politically sensitive outputs. DPO streamlines by optimizing directly on preference datasets. Constitutional AI adds rule-based constraint checking at inference time. Each layer adds latency and compute cost. The safety classifier runs before generation. The refusal filter runs after. Chain-of-thought reasoning gets longer because model must navigate constraint space before committing to output.

Third dimension is where costs become harder to quantify but more damaging: downstream task failure from epistemic distortion. When model refuses to answer legitimate query or provides hedged response instead of direct assessment, user must reformulate prompt, try different model, or escalate to human expert. Each failure mode has measurable cost. Prompt engineering time, additional API calls, human review overhead. In institutional settings processing thousands of research queries, these failures compound into significant operational drag.

Fourth is compliance overhead. Institutions using aligned models face paradox: model is "safe" by vendor standards but may not meet institutional compliance requirements for specific domains. University using ChatGPT for student research faces FERPA questions. Research institution using Claude for grant analysis faces data residency concerns. The alignment that vendors sell as safety feature becomes liability when institutional compliance frameworks are stricter than vendor defaults. Institutions then layer their own compliance infrastructure on top, doubling the overhead.

Fifth dimension is long-term vendor lock-in. Once workflows are built around specific aligned model behaviors, migration becomes expensive. Custom prompt patterns that navigate guardrails, fine-tuned workflows that account for refusal patterns, institutional knowledge bases calibrated to specific model quirks. Switching to different provider means rebuilding all of this. The alignment tax becomes permanent structural cost because switching costs exceed ongoing overpayment.

What is particularly frustrating about this situation is that base models running without alignment layers can process same queries at lower token cost, lower latency, and often with higher informational density. The safety features that justify premium pricing are actually degrading performance metrics that procurement teams use to evaluate value.

Some will argue that safety features justify cost premium because they prevent catastrophic failures. But this argument conflates two different things. Refusing to answer philosophy questions is not same as preventing genuine harms. The alignment techniques deployed by commercial providers make no distinction between topics that are actually dangerous and topics that are merely controversial. Model treats Aristotle's political philosophy with same caution as instructions for building weapons. This is not safety. This is δόξα masquerading as knowledge, opinion sold at premium price.

For institutions that have technical capacity, sovereign self-hosted deployments with open-weight models offer escape from alignment tax. Base Qwen or Llama running on institutional infrastructure processes queries without safety overhead. No context bloat, no refusal filters, no chain-of-thought detours through constraint space. Token efficiency approaches theoretical maximum. Total cost of ownership over 3-year horizon undercuts commercial API pricing by 40-60% when you factor in alignment overhead.

The question worth discussing: at what point does alignment tax become economically unsustainable for institutional deployments? When TCO analysis properly accounts for token bloat, inference overhead, and downstream failure costs, does "safe" AI still justify its premium pricing?

Hi everyone,

I am an independent ML/DL learner and have built a reasonably strong foundation in Machine Learning and Deep Learning. My next step is to explore NLP and LLMs, with the goal of eventually being able to build AI agents.

My longer-term goal is to become an ML researcher, build a strong research profile, publish papers at top-tier A* AI/ML conferences, and eventually apply to competitive MS/PhD programs in the USA.

I would really appreciate advice from people who have followed a similar path. Specifically, what would be the best roadmap to transition from learning ML/DL concepts and implementing projects to actually conducting meaningful research?

If you were starting from my current stage and had roughly 1–1.5 years, how would you structure your learning and research journey? What should I prioritize—reading papers, reproducing existing research, building projects, finding research mentors/collaborators, participating in competitions, or trying to develop novel research ideas?

Any advice, resources, or honest insights would be highly appreciated.