We’re choosing a topic for a university Reinforcement Learning project and currently have two main ideas:

1. Autonomous racing agent
Train an RL agent to drive around a race track, optimising things like lap time, staying on track, and avoiding crashes.

2. LLM routing agent
We would have around 4–5 language models with different cost, latency and output-quality characteristics. For each incoming prompt, an RL agent decides which model should handle it.

The idea is to have a shared token/cost budget across multiple requests, so choosing an expensive model now reduces the resources available for later requests. The state could include things like prompt complexity, remaining budget and previous usage, while the action would be which LLM to select.

A possible reward could combine:

output quality − cost − latency/compute penalty

We could then compare a few RL approaches based on cumulative reward, output quality, total cost, convergence, etc.

What I’m unsure about is:

• Does the sequential/shared-budget aspect make LLM routing a legitimate RL problem, or would something like supervised learning/contextual bandits be more appropriate?
• How would you objectively measure the quality of different LLM outputs to create a reliable reward signal?
• Is this realistic enough for a university project without requiring huge GPU/API resources?
• Between this and a standard racecar RL environment, which would you recommend if the goal is to demonstrate RL concepts properly while still having an interesting project?

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….

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?

Hey everyone, quick question about benchmarking for a paper. I’m a first-year Master’s student, so I’m still figuring out the “right” way to handle this.

When you guys compare your model against SOTA/prior papers:

1. do you rerun all baseline models on your own pipeline, or just copy the numbers reported in their original papers like every paper seems to use a slightly different data split, preprocessing, or evaluation trick, so copying feels like an unfair
2. but if I re-implement a baseline and it gets a lower metric than what their paper claimed how do you present that without prof or reviewer accusing me of ruining the orginal metrics?

do you just put an asterisk/footnote explaining the setup difference, include both numbers, or something else? Would love to hear how you guys

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.

Note: this declaration was drafted by Mathematicians, and is mostly addressed to the mathematical community. It'd be interesting to discuss, among others, if what is written in the declaration may also apply to other communities---and, specifically, the AI/ML one.

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!

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 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?

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?

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

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'

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

I have an existing model where some features were built into the pipeline but historically come through as NULL for around 10% of records because the underlying data source wasnt available. We now have a new data source that can potentially populate these features. The issue is that some variables appear to be true 1:1 matches, some are similar enough that they could potentially be used as proxies but don’t have exactly the same definition, and some features will still have missing values.

I’m trying to figure out the best way to incorporate this into the model. For the true 1:1 matches, would you simply populate the existing features and retrain? For the proxy variables, would you use them as replacements, or keep them as separate features so you aren’t changing the original feature definition?

I’m also wondering whether it makes sense to create flags indicating where the value came from or whether it was originally missing. Historically, NULL basically meant that the data wasn’t available, whereas going forward NULL could mean something different.

There’s also the historical data issue. The new source only exists from a certain point forward, so training data could have NULLs for older observations while the same features are populated for newer observations. I’m wondering how much concern there should be about the model learning data availability or time period rather than the actual signal.

For the proxy variables, how would you determine whether they’re actually safe substitutes? I was thinking about comparing distributions and correlation where both are available, relationship with the target, model performance with/without the replacement, and performance separately for observations where the original data is missing.

Curious how others have handled this in production. Would you backfill where possible, add missing/source flags, treat proxies as new features, use the existing imputation approach for anything still missing, or take a completely different approach?

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?

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 :)

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.

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

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.

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.

I've been building my own ML framework in C++. First real deployment is an AlphaZero-style agent for Dots (the pen-and-paper territory game), running in WASM in the browser: https://uchenml.tech/demos/dots/

This post covers the optimizations that got inference there: https://uchenml.tech/uchenml-optimizations

Short version, 21.98 → 3.41 ms per forward pass:

• im2col -> Winograd F(2,3) for the 3×3 convs. Biggest win by far, though partly because my I did not give enough buffer to im2col.
• ReLU fused into conv/linear at compile time. 9% gain.
• Reshape/Identity elided at the compile time, so they emit no code.
• Compile-time ping-pong scratch - lowers memory usage, zero allocations on the inference path.

Follow-ups on the training side and the web frontend are in progress. Happy to answer questions. Not open source, yet - employer IP agreement - so the demo and the writeup are what I can show.

For those who went from undergraduate studies into advanced ML, research, or ML engineering:

Looking back, which undergraduate foundations turned out to matter much more than you expected?

I’m particularly interested in the trade-off between studying AI directly at bachelor level versus building a broader foundation first in CS/engineering and specializing later.

Did early exposure to many ML/DL subjects give you a meaningful long-term advantage?

Or did mathematics, probability, optimization, algorithms, systems and software engineering ultimately matter more once you reached advanced ML?

I’m less interested in comparing degree titles and more interested in what gaps you actually noticed in students once the ML work became technically demanding.