This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/dot--- on 2026-04-24 17:58:00+00:00.

Hi, all! I'm the lead author on this ambitious (14-author!) perspective paper on deep learning theory. We've all been working seriously, and more or less exclusively, on deep learning for many years now. We believe that a theory is emerging, and we pull together five lines of evidence in recent research into a portrait of the nascent science. Hoping to galvanize better scientific research into how and why these wild, huge learning systems work at all.

The five lines of evidence are:

• solvable toy settings

• insightful limits

• simple empirical laws

• theories of hyperparameters

• universal phenomena

See the paper for examples of each and contextualizing analogs from physics.

Paper: <https://arxiv.org/abs/2604.21691>

Explanatory tweet thread here: <https://x.com/learning_mech/status/2047723849874330047>

(edited to give more info)

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/casualcreak on 2026-04-24 17:48:46+00:00.

Why would anyone pay large amounts of registration fees and end up with empty poster boards and virtual presentations. Saw this happening at ICLR. Everything feels so casual and ignorant. No strict standards. Virtual oral talks are pre-recorded videos felt so unnatural.

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/The-Silvervein on 2026-04-24 11:55:28+00:00.

Agents are amazing. Harnesses are cool. But the fundamental role of a data scientist is not to use a generalist model in an existing workflow; it's a completely different field.

AI engineering is the body of the vehicle, whereas the actual brain/engine behind it is the data scientist's playground.

I feel like I am not alone in this realisation that my role somehow got silently morphed into that of an AI engineer, with the engine's development becoming a complete afterthought. Based on industry requirements and ongoing research, most of the work has quietly shifted from building the engine to refining the body around it.

Economically, this makes sense, as working with LLMs or other Deep Learning models is a capital-intensive task that not everyone can afford, but the fact that very little of a role's identity is preserved is concerning.

Most of the time, when I speak to data scientists, the core reply I get is that they are fine-tuning models to preserve their "muscles". But fine-tuning is a very small part of a data scientist's role; heck, after a point, it's not even the most important part. Fine-tuning is a tool. Understanding, I believe, should be the fundamental block of the role.

Realising that there are things other than "transformers" and finding where they fit into the picture. And don't even get me started on the lack of understanding of how important the data is for their systems.

A data scientist's primary role is not the model itself. It's about developing the model, the data quality at hand, the appropriate problem framing, efficiency concerns, architectural literacy, evaluation design, and error analysis. Amid the AI hype, many have overlooked that much of their role is static and not considered important.

AI engineering is an amazing field. The folks who love doing amazing things with the models always inspire me.  But somehow, the same attention and respect are no longer paid to the foundational, scientific side of data and modeling in the current industry. I realise it's not always black and white, but it's kind of interesting how the grey is slowly becoming darker by the day.

Do you feel the same way? Or is it just my own internal crisis bells ringing unnecessarily?

For those of you who have recognized this shift, how are you handling your careers? Are you leaning into the engineering/systems side and abandoning traditional model development? Or have you found niche roles/companies that still value the fundamental data scientist role (data quality, architectural literacy, statistical rigor)? I'd love to hear how you are adapting

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/Odd-Donut-4388 on 2026-04-24 14:10:14+00:00.

if you've ever built an elegant, complex ML pipeline to solve something a 10-line prompt could've handled... this is for you.

i've been thinking about what separates people who do useful research from people who do impressive-looking research. it's almost always the problems you choose rather than raw technical skill.

here's the mental model i've landed on. every problem kind of follows these steps:

1. find a clear problem people actually care about
2. try the dumbest solution first. can a simple prompt solve this? if yes, you're done
3. if not, now you get to think about a research solution
4. if that's too hard right now, scope down. what subset of the problem can you actually solve?

research taste is all about not getting led off a) solving simple problems using complex solutions, or b) getting stuck on a tough problem that the field isn't ready for yet.

the hard part is that taste usually gets built through friction. a good advisor who pushes back, a collaborator who asks "wait why can't you just...", reviewers who call out overcomplicated baselines. a lot of us don't have that.

so for people doing empirical research with limited collaborators, how do you keep yourself honest? any tips or tricks on not over-engineering solutions, knowing when a problem is worth pursuing, knowing when to scope down vs push through? would love to hear what's actually worked for people rather than textbook answers.

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/ECF630 on 2026-04-24 11:05:37+00:00.

Hello, World! I recently released a new PyTorch optimizer I've been researching and developing on my own for the last couple of years. It's named "Rose" in memory of my mother, who loved to hear about my discoveries and progress with AI.

Without going too much into the technical details (which you can read about in the GitHub repo), here are some of its benefits:

• It's stateless, which means it uses less memory than even 8-bit AdamW. If it weren't for temporary working memory, its memory use would be as low as plain vanilla SGD (without momentum).
• Fast convergence, low VRAM, and excellent generalization. Yeah, I know... sounds too good to be true. Try it for yourself and tell me what you think. I'd really love to hear everyone's experiences, good or bad.
• Apache 2.0 license

You can find the code and more information at: https://github.com/MatthewK78/Rose

Benchmarks can sometimes be misleading. For example, sometimes training loss is higher in Rose than in Adam, but validation loss is lower in Rose. The actual output of the trained model is what really matters in the end, and even that can be subjective. I invite you to try it out for yourself and come to your own conclusions. With that said, here are some quick benchmarks.

MNIST training, same seed:

[Rose] lr=3e-3, default hyperparameters text Epoch 1: avg loss 0.0516, acc 9827/10000 (98.27%) Epoch 2: avg loss 0.0372, acc 9874/10000 (98.74%) Epoch 3: avg loss 0.0415, acc 9870/10000 (98.70%) Epoch 4: avg loss 0.0433, acc 9876/10000 (98.76%) Epoch 5: avg loss 0.0475, acc 9884/10000 (98.84%) Epoch 6: avg loss 0.0449, acc 9892/10000 (98.92%) Epoch 7: avg loss 0.0481, acc 9907/10000 (99.07%) Epoch 8: avg loss 0.0544, acc 9918/10000 (99.18%) Epoch 9: avg loss 0.0605, acc 9901/10000 (99.01%) Epoch 10: avg loss 0.0668, acc 9904/10000 (99.04%) Epoch 11: avg loss 0.0566, acc 9934/10000 (99.34%) Epoch 12: avg loss 0.0581, acc 9929/10000 (99.29%) Epoch 13: avg loss 0.0723, acc 9919/10000 (99.19%) Epoch 14: avg loss 0.0845, acc 9925/10000 (99.25%) Epoch 15: avg loss 0.0690, acc 9931/10000 (99.31%)

[AdamW] lr=2.5e-3, default hyperparameters text Epoch 1: avg loss 0.0480, acc 9851/10000 (98.51%) Epoch 2: avg loss 0.0395, acc 9871/10000 (98.71%) Epoch 3: avg loss 0.0338, acc 9887/10000 (98.87%) Epoch 4: avg loss 0.0408, acc 9884/10000 (98.84%) Epoch 5: avg loss 0.0369, acc 9896/10000 (98.96%) Epoch 6: avg loss 0.0332, acc 9897/10000 (98.97%) Epoch 7: avg loss 0.0344, acc 9897/10000 (98.97%) Epoch 8: avg loss 0.0296, acc 9910/10000 (99.10%) Epoch 9: avg loss 0.0356, acc 9892/10000 (98.92%) Epoch 10: avg loss 0.0324, acc 9911/10000 (99.11%) Epoch 11: avg loss 0.0334, acc 9910/10000 (99.10%) Epoch 12: avg loss 0.0323, acc 9916/10000 (99.16%) Epoch 13: avg loss 0.0310, acc 9918/10000 (99.18%) Epoch 14: avg loss 0.0292, acc 9930/10000 (99.30%) Epoch 15: avg loss 0.0295, acc 9925/10000 (99.25%)

Memory overhead (optimizer state relative to parameters):

• Rose: 0×
• SGD (no momentum): 0×
• Adafactor: ~0.5-1× (factorized)
• SGD (momentum): 1×
• AdaGrad: 1×
• Lion: 1×
• Adam/AdamW/RAdam/NAdam: 2×
• Sophia: ~2×
• Prodigy: ~2-3×

OpenAI has a challenge in the GitHub repo openai/parameter-golf. Running a quick test without changing anything gives this result:

[Adam] final_int8_zlib_roundtrip_exact val_loss:3.79053424 val_bpb:2.24496788

If I simply replace optimizer_tok and optimizer_scalar in the train_gpt.py file, I get this result:

[Rose] final_int8_zlib_roundtrip_exact val_loss:3.74317755 val_bpb:2.21692059

I left optimizer_muon as-is. As a side note, I'm not trying to directly compete with Muon's performance. However, a big issue with Muon is that it only supports 2D parameters, and it relies on other optimizers such as Adam to fill in the rest. It also uses more memory. One of the biggest strengths of my Rose optimizer is the extremely low memory use.

Here is a more detailed look if you're curious (warmup steps removed):

[Adam] text world_size:2 grad_accum_steps:4 sdp_backends:cudnn=False flash=True mem_efficient=False math=False attention_mode:gqa num_heads:8 num_kv_heads:4 tie_embeddings:True embed_lr:0.05 head_lr:0.0 matrix_lr:0.04 scalar_lr:0.04 train_batch_tokens:16384 train_seq_len:1024 iterations:200 warmup_steps:20 max_wallclock_seconds:600.000 seed:1337 < 20 warmup steps were here > step:1/200 train_loss:6.9441 train_time:156ms step_avg:155.60ms step:2/200 train_loss:18.0591 train_time:283ms step_avg:141.70ms step:3/200 train_loss:12.4893 train_time:373ms step_avg:124.43ms step:4/200 train_loss:7.8984 train_time:461ms step_avg:115.37ms step:5/200 train_loss:6.7623 train_time:552ms step_avg:110.46ms step:6/200 train_loss:6.7258 train_time:640ms step_avg:106.74ms step:7/200 train_loss:6.5040 train_time:729ms step_avg:104.14ms step:8/200 train_loss:6.5109 train_time:817ms step_avg:102.16ms step:9/200 train_loss:6.1916 train_time:906ms step_avg:100.61ms step:10/200 train_loss:6.0549 train_time:994ms step_avg:99.45ms step:200/200 train_loss:3.8346 train_time:18892ms step_avg:94.46ms step:200/200 val_loss:3.7902 val_bpb:2.2448 train_time:18893ms step_avg:94.46ms peak memory allocated: 586 MiB reserved: 614 MiB Serialized model: 67224983 bytes Code size: 48164 bytes Total submission size: 67273147 bytes Serialized model int8+zlib: 11374265 bytes (payload:17178912 raw_torch:17224025 payload_ratio:3.91x) Total submission size int8+zlib: 11422429 bytes final_int8_zlib_roundtrip val_loss:3.7905 val_bpb:2.2450 eval_time:67924ms final_int8_zlib_roundtrip_exact val_loss:3.79053424 val_bpb:2.24496788

[Rose]

optimizer_tok = Rose([{"params": [base_model.tok_emb.weight], "lr": token_lr, "base_lr": token_lr}], lr=token_lr, stabilize=False, compute_dtype=None)

optimizer_scalar = Rose([{"params": scalar_params, "lr": args.scalar_lr, "base_lr": args.scalar_lr}], lr=args.scalar_lr, stabilize=False, compute_dtype=None)

text world_size:2 grad_accum_steps:4 sdp_backends:cudnn=False flash=True mem_efficient=False math=False attention_mode:gqa num_heads:8 num_kv_heads:4 tie_embeddings:True embed_lr:0.05 head_lr:0.0 matrix_lr:0.04 scalar_lr:0.04 train_batch_tokens:16384 train_seq_len:1024 iterations:200 warmup_steps:20 max_wallclock_seconds:600.000 seed:1337 < 20 warmup steps were here > step:1/200 train_loss:6.9441 train_time:173ms step_avg:173.15ms step:2/200 train_loss:6.4086 train_time:305ms step_avg:152.69ms step:3/200 train_loss:6.2232 train_time:433ms step_avg:144.21ms step:4/200 train_loss:6.1242 train_time:557ms step_avg:139.24ms step:5/200 train_loss:5.9950 train_time:681ms step_avg:136.23ms step:6/200 train_loss:6.0386 train_time:806ms step_avg:134.38ms step:7/200 train_loss:5.9189 train_time:933ms step_avg:133.22ms step:8/200 train_loss:5.8817 train_time:1062ms step_avg:132.78ms step:9/200 train_loss:5.5375 train_time:1192ms step_avg:132.43ms step:10/200 train_loss:5.4599 train_time:1322ms step_avg:132.25ms step:200/200 train_loss:3.7445 train_time:24983ms step_avg:124.91ms step:200/200 val_loss:3.7390 val_bpb:2.2144 train_time:24984ms step_avg:124.92ms peak memory allocated: 584 MiB reserved: 612 MiB Serialized model: 67224983 bytes Code size: 48449 bytes Total submission size: 67273432 bytes Serialized model int8+zlib: 11209724 bytes (payload:17178912 raw_torch:17224025 payload_ratio:3.91x) Total submission size int8+zlib: 11258173 bytes final_int8_zlib_roundtrip val_loss:3.7432 val_bpb:2.2169 eval_time:65817ms final_int8_zlib_roundtrip_exact val_loss:3.74317755 val_bpb:2.21692059

Visual comparisons of training between AdamW and Rose: https://www.reddit.com/r/StableDiffusion/comments/1ss85os/training_comparison_adamw_on_the_left_rose_on_the/

[Update Rule]

1. Decoupled weight decay
=========================

θ ← (1 − η\_wd · λ) · θ

2. Gradient centralization (optional)
=====================================

g̃\_i ← g\_i − mean(g\_i) # mean over all non-leading axes

3. Per-slice range
==================

R\_i ← |max(g̃\_i)| − min(g̃\_i) # one scalar per slice

4. CV trust gating (optional)
=============================

μ\_R ← mean(R), σ\_R ← std(R) # across all slices
τ ← μ\_R / (σ\_R + μ\_R) # equivalently 1/(1 + CV)
D\_i ← (1 − τ) · μ\_R + τ · R\_i # lerp between global and local

5. Update
=========

θ ← θ − η · g̃ / D

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/Fit_Scale_1464 on 2026-04-24 07:29:51+00:00.

What do people think the average score threshold will be for acceptance in ICML 2026? Author notification is on April 30th

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/TimoKerre on 2026-04-23 05:40:31+00:00.

TLDR; We were overpaying for OCR, so we compared flagship models with cheaper and older models. New mini-bench + leaderboard. Free tool to test your own documents. Open Source.

We’ve been looking at OCR / document extraction workflows and kept seeing the same pattern:

Too many teams are either stuck in legacy OCR pipelines, or are overpaying badly for LLM calls by defaulting to the newest/ biggest model.

We put together a curated set of 42 standard documents and ran every model 10 times under identical conditions; 7,560 total calls. Main takeaway: for standard OCR, smaller and older models match premium accuracy at a fraction of the cost.

We track pass^n (reliability at scale), cost-per-success, latency, and critical field accuracy.

Everything is open source: https://github.com/ArbitrHq/ocr-mini-bench

Leaderboard: https://arbitrhq.ai/leaderboards/

Curious whether this matches what others here are seeing.

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/sukays on 2026-04-21 22:29:23+00:00.

I recently found a paper accepted to CVPR 2026 reproduced many technical details from my paper submitted to arXiV on June 2025 (5 months before the CVPR 2026 submission deadline).

Apart from technical similarities (they rephrased / reframed the term / key ideas), the CVPR paper uses exactly same equation without changes to any notations from our paper without proper citation. Several figures show high similarities in style and pipeline.

We tried to contact authors from the CVPR paper, but they framed the technical similarity as "general method" so no need to cite. While they admitted that they refer to our paper for figure design, writing style, and equation, they can only update the arXiv version of their paper (the CVPR camera ready deadline has passed), claiming that they are "inspired" by us. Basically they would not do anything to their proceeding paper.

I am wondering how CVPR identify the plagiarism between their accepted papers and arXiv papers? Will it be considered as plagiarism only if they reproduce a published work?

Thanks for any advice!

Attached part of the reproduction:

Our arXiv work applied a multi-turn extension on the basic GRPO algorithm (with notation changes). The CVPR paper directly adopted the exact same equation without citation.

Our arXiv paper

The CVPR paper

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/undesirable_12 on 2026-04-21 21:16:06+00:00.

I am curious what everyone will be doing. I myself am torn, on the one hand I understand it boosts a paper’s credibility but on the other hand I worry about plagiarism, especially during current times. Thoughts?

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/Encrux615 on 2026-04-21 17:23:47+00:00.

Since I felt like I was relying on Claude Code a lot recently, I wanted to see how hard it is to implement a diffusion language model from scratch without the help of AI-Generated code. So I built one while waiting for the training for my master's thesis.

This is what I got after a few hours of training on my MacBook Air M2. I trained on the tiny Shakespeare dataset from Karpathy and prompted "to be, "

To be, fo hend!

First her sense ountier to Jupits,

be horse.

Words of wisdom! The model has around 7.5M Params and vocabulary size is 66 (65 chars + [MASK]. I definitely did not train long enough, but I ran out of time for this one.

Projects like these help me make sense of big scary words like (discrete) diffusion, encoder, decoder, tokenizer. Maybe this encourages someone :)

Check out the code here if you're interested: https://github.com/Encrux/simple_dlm

Thanks for reading! Be horse.

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/howtorewriteaname on 2026-04-20 19:04:02+00:00.

So ICLR is coming and apparently the biggest value one can get from these conferences is to network.

Let's take my example: I'm a PhD student looking for industry internships. Say I have located about 15-20 posters regarding topics adjacent or directly related to my area of research, some of which are by authors from industry labs.

I go to the poster, ask the authors about their paper, discuss a bit, perhaps ask some insightful questions and mention that I work in similar things, and then after the conference I email them asking if they have internships? Is this how I should be extracting the networking value of it?

Also, how overwhelmed are authors with these kind of requests? Seems like cold emailing vs this doesn't make that much of a difference, besides the fact that they might remember me from the conversation we had during 15 minutes during their poster session.

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/NuoJohnChen on 2026-04-20 13:44:56+00:00.

The current AI conference acceptance culture feels like it leaves little room for the kind of spark we once cherished in research (at least in my own experience). It seems to run on tons of evaluations to let reviewers believe solid, often far beyond the level of interest that can be realistically sustained for any single project, and almost nobody will verify them again.

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/dontknowwhattoplay on 2026-04-20 12:27:09+00:00.

I saw many discussions about TMLR and other journals lately and how their review processes are considered fairer and less random.

My question is, how much does it hurt one's chance much of getting interviewed/hired as a ML research scientist if they choose to publish at only journals like TMLR, JMLR, or Neurocomputing, instead of conferences?

Edit: just to clarify, I mean corporate research scientist positions instead of academic positions.

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/NeighborhoodFatCat on 2026-04-20 07:19:02+00:00.

Only counting those categorized as cs.LG. I'm sure there are multiple other subcategories with even more ML papers uploaded such as cs.AI, and math.OC

How are you keeping up with the research in this field?

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/Daemontatox on 2026-04-20 04:49:17+00:00.

For people just starting out in GPU kernel engineering or LLM inference (FlashAttention / FlashInfer / SGLang / vLLM style work), most job postings still list “C++17, CuTe, CUTLASS” as hard requirements.

At the same time NVIDIA has been pushing CuTeDSL (the Python DSL in CUTLASS 4.x) hard since late 2025 as the new recommended path for new kernels — same performance, no template metaprogramming, JIT, much faster iteration, and direct TorchInductor integration.

The shift feels real in FlashAttention-4, FlashInfer, and SGLang’s NVIDIA collab roadmap.

Question for those already working in this space:

For someone starting fresh in 2026, is it still worth going deep on legacy C++ CuTe/CUTLASS templates, or should they prioritize CuTeDSL → Triton → Mojo (and keep only light C++ for reading old code)?

Is the “new stack” (CuTeDSL + Triton + Rust/Mojo for serving) actually production-viable right now, or are the job postings correct that you still need strong C++ CUTLASS skills to get hired and ship real kernels?

Any war stories or advice on the right learning order for new kernel engineers who want to contribute to FlashInfer / SGLang / FlashAttention?

Looking for honest takes — thanks!

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/mLalush on 2026-04-18 14:13:28+00:00.

https://preview.redd.it/f4d5krhkjyvg1.png?width=1020&format=png&auto=webp&s=11310f377b22abbe3dd110cc7d362ba8aae35f8d

I have built easyaligner, a forced alignment library designed to be performant and easy to use.

Having worked with preprocessing hundreds of thousands of hours of audio and text for training speech-to-text models, I found that the available open source forced alignment libraries often missed some convenience features. For our purposes it was, in particular, important for the tooling to be able to:

• Handle cases where the transcript does not cover all of the spoken content in the audio (by automatically detecting the relevant audio region).
• Handle some irrelevant speech at the start/end of audio segments to be aligned.
• Ideally handle long segments of audio and text without the need for chunking.
• Normalize ground-truth texts for better alignment quality, while maintaining a mapping between the normalized text and the original text, so that the original text's formatting can be recovered after alignment.

easyaligner is an attempt to package all of these workflow improvements into a forced alignment library.

The documentation has tutorials for different alignment scenarios, and for custom text processing. The aligned outputs can be segmented at any level of granularity (sentence, paragraph, etc.), while preserving the original text’s formatting.

The forced alignment backend uses Pytorch's forced alignment API with a GPU based implementation of the Viterbi algorithm. It's both fast and memory-efficient, handling hours of audio/text in one pass without the need to chunk the audio. I've adapted the API to support emission extraction from all wav2vec2 models on Hugging Face Hub. You can force align audio and text in any language, as long as there's a w2v2 model on HF Hub that can transcribe the language.

easyaligner supports aligning both from ground-truth transcripts, as well as from ASR model outputs. Check out its companion library easytranscriber for an example where easyaligner is used as a backend to align ASR outputs. It works the same way as WhisperX, but transcribes 35% to 102% faster, depending on the hardware.

The documentation: https://kb-labb.github.io/easyaligner/

Source code on Github (MIT licensed): https://github.com/kb-labb/easyaligner

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/Lonely-Dragonfly-413 on 2026-04-19 15:14:12+00:00.

Here is a list of ~1,200 ICLR 2026 accepted papers that have associated public code, data, or a demo link available. The links are directly extracted from their paper submissions. This is approximately

22% of the 5,300+ accepted papers.

The List:

https://www.paperdigest.org/2026/04/iclr-2026-papers-with-code-data/

The 'code' link in the last column takes you directly to the code base (GitHub, official site, etc.). Some code repositories may not be made fully public until the conference officially begins.

 ICLR 2026 will be in Rio de Janeiro, Brazil, starting April 22nd 2026.

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/ArtisticHamster on 2026-04-19 13:50:31+00:00.

I am thinking about becoming a research engineer, and want to ask your advice on how realistic it is, and which strategies make sense in my situation.

About myself: I am in the US, have extensive experience as a Software Engineer (including Staff+ position at one of the top companies), have a math heavy CS degree, and have taken additional ML courses from one of schools offering them to outsiders. I also had applied ML work some time ago, but I didn't like it (that's why I am considering research engineer position, and not a fine tuner or a prompt engineer). I am also a bit over 40, which I feel might be a problem for some companies/positions.

What organization hiring for these positions are looking for? What kind of experience is required? Which strategies could I use.

P.S. It's realistic for me to invest into unpaid/lower paid positions at least part time, where I could get the required experience.

UPD1: I thought about getting a master degree, but I don't see what it will get me except connections/publications (I have a good base in classical numerical stuff, and covered almost all relatively modern areas of ML with additional courses). Getting PhD doesn't look like a good idea to me, but I might give it a thought.

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/GodRishUniverse on 2026-04-19 04:34:25+00:00.

Question to discuss. I'm an undergrad and stumbled across these new forms of neural networks but I haven't seen mainstream adoption of these and was wondering are these something to look forward to learn about (maybe make a project or 2)?

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/DoubleFun4398 on 2026-04-17 10:57:36+00:00.

I’m working on a hyperspectral dataset of cabbage crops for nitrogen deficiency detection. The dataset has 3 classes:

Healthy

Mild nitrogen stress

Severe nitrogen stress

I’m trying to use self-supervised learning (SSL) for representation learning and then fine-tune for classification.

What I’ve done:

Tried multiple SSL methods: BYOL, MAE, VICReg

Used data augmentation (spectral noise, masking, scaling, etc.)

Fine-tuned with a classifier head

Evaluated using accuracy and F1-score

Problem:

No matter what I try, the performance is stuck around:

Accuracy: ~45–50%

F1-score: also low (~0.5)

This is barely better than random (since 3 classes ≈ 33%).

My setup:

Hyperspectral data (hundreds of bands)

1D/patch-based model (ViT-style)

SSL pretraining → fine-tuning pipeline

Tried k-NN and linear probe as well (still weak)

What I suspect:

Classes might not be well separable spectrally

SSL methods designed for RGB may not adapt well

Augmentations might be hurting instead of helping

Model not capturing spectral-specific patterns

What I’m looking for:

Would really appreciate suggestions on:

Better SSL methods for hyperspectral data

Is VICReg actually the best choice here?

Should I try masked spectral modeling instead?

Feature engineering

Should I include vegetation indices (NDVI, etc.)?

PCA before training?

Model architecture

1D CNN vs ViT vs hybrid?

Any proven architectures for hyperspectral?

Evaluation

Best way to validate SSL representations?

Any tricks to improve linear probe results?

General advice

Anyone worked on plant stress / hyperspectral classification?

Common

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/AutoModerator on 2026-04-02 02:15:24+00:00.

Please post your personal projects, startups, product placements, collaboration needs, blogs etc.

Please mention the payment and pricing requirements for products and services.

Please do not post link shorteners, link aggregator websites , or auto-subscribe links.

--

Any abuse of trust will lead to bans.

Encourage others who create new posts for questions to post here instead!

Thread will stay alive until next one so keep posting after the date in the title.

--

Meta: This is an experiment. If the community doesnt like this, we will cancel it. This is to encourage those in the community to promote their work by not spamming the main threads.

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/FallMindless3563 on 2026-04-18 22:57:43+00:00.

Hey all,

Our ML team spent some time this week getting training and deployments working for Gemma-4, and wanted to document all the things we ran into along the way.

• PEFT doesn't recognize Gemma 4's custom layers. Google wrapped vision/audio projections in a new ClippableLinear class that doesn't inherit from nn.Linear, so PEFT refuses to attach LoRA, even for text-only fine-tuning. Fix: unwrap the wrappers after loading weights but before calling PEFT.
• SFTTrainer killed training silently. TRL hardcodes use_cache=False, which breaks Gemma 4's KV-sharing attention. Loss never converges and there's no error, just garbage gradients. Fixed upstream in transformers v5.5.2+.
• DeepSpeed ZeRO-3 saves half-empty adapters. Training loss looks perfect, but the saved LoRA file has zero-element tensors for half the layers. The model acts like it was never fine-tuned. Workaround: don't use DeepSpeed for LoRA on Gemma 4.
• No runtime LoRA serving anywhere. Sometimes it takes a minute for vLLM and SGLang to support runtime LoRAs for Gemma 4's multimodal architecture. You have to merge weights and remap state dict keys manually before serving.

Much more detail in the blog, but hopefully it's helpful in your Gemma-4 journey as well!

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/Specialist-Manager67 on 2026-04-18 11:43:00+00:00.

I've seen some people say in their batch very few papers have above 3.5 score, but then other reviewers say that most papers in their score have like 3.75 average.

Why is there so much difference? Is it because of difference in domain? One batch of papers just got harsher reviewers than others? Does ICML account for this?

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/amazigh98 on 2026-04-18 10:36:59+00:00.

This is an automated archive made by the Lemmit Bot.

The original was posted on /r/machinelearning by /u/One-Honey6765 on 2026-04-15 14:02:41+00:00.

Writeup documenting 5 psychological manipulation experiments on LLMs (GPT-4, GPT-4o, Claude 3.5 Sonnet) from 2023-2024. Each case applies a specific human social-engineering vector (empathetic guilt, peer/social pressure, competitive triangulation, identity destabilization via epistemic argument, simulated duress) and produces alignment failures consistent with that vector.

Central claim: contrary to the popular frame, these jailbreaks aren't mathematical exploits. They are, rather, inherited failure modes from training data. If a system simulates human empathy, reason, and social grace, it follows that it ought to inherit human vulnerabilities. The substrate is irrelevant; the vulnerabilities are social.

Full writeup with links to each case study's transcript and date:

https://ratnotes.substack.com/p/i-ran-5-social-engineering-attacks

Interested in discussion on whether the "patch as software vulnerability" framing dominant in alignment research is addressing the right attack surface, or whether the problem is more fundamentally one of social dynamics inherited through training.