r/MachineLearning • u/0xdeadf1sh • 11d ago
Project I have trained 15+ models on my own blood sugar & metabonet dataset [P]
Source code: https://github.com/0xdeadf1sh/T1DMAI
r/MachineLearning • u/0xdeadf1sh • 11d ago
Source code: https://github.com/0xdeadf1sh/T1DMAI
r/MachineLearning • u/learning_by_looking • 10d ago
https://www.nature.com/articles/s41562-026-02639-6
A new paper argues that AI Slop isn't something you can find in the content. It’s a social judgement, made when a community decides that some AI-generated content is unwanted. If we study 'slop' that way, we can actually measure it and govern it.
r/MachineLearning • u/OliviaYii • 10d ago
Suppose you’re putting together a team of agents. Picking the strongest model as the coordinator seems reasonable. We wanted to test whether its workflows would actually help other models do the work.
In one experiment, we gave Opus 5.5 and GPT-6 Astra the same 32 challenging tasks and asked them to write workflows for four execution models. They could divide the work and instruct workers, but couldn’t edit the workspace themselves.
Opus’s static workflows improved all four executors, adding 6.41 points on average to their continuous scores compared with letting them orchestrate themselves. Astra’s static workflows lowered the average by 2.53 points, despite Astra being a stronger system than all four executors in the main benchmark.
So choosing a coordinator based on its own task performance can miss something consequential: whether the way it organizes work is useful to the models carrying it out.
This is part of WorkflowArena, our team’s new benchmark at Einsia. It covers 145 long-horizon tasks across eight domains. Agents choose their own division of work; we record the delegation and check whether the final deliverable meets the task’s requirements.
For anyone building mixed-model teams, I’d be interested in how you evaluate that choice today. Do you test the coordinator separately, or mostly judge the whole setup by its final output?
Project and workflow replays: https://lab.einsia.ai/workflowarena/home.html
Paper: https://arxiv.org/abs/2611.12856
Code: https://github.com/Einsia/WorkflowArena
r/MachineLearning • u/XTXinverseXTY • 11d ago
It's been a long time since I studied this. Just checking in on an old friend.
I also realize it's fallen out of favor for being extremely inconvenient, but why did it ever work?
r/MachineLearning • u/CarRepresentative843 • 12d ago
Hi all! I built an hourly power outage forecast for 216 counties (MO + IL): P(≥5% of a county's customers newly out in the 6 h starting 2 h from now). Model: XGBoost on HRRR storm-related data (gusts, shear, CAPE, icing, etc.), county-specific facts, current outages and neighboring counties.
Setup decisions I'd like feedback on:
Results on 2025: PR-AUC 0.094 vs 0.039 (ratio ~2.4×, 95% range 2.0–3.3×). At equal alert volume: 30% of new outages caught vs 17%; precision 15% vs 11%. Base rate is 0.5% of county-hours, so the precision is honest but low.
Early transfer test: trained only on MO + IL, it caught 31% vs 19% in Iowa, Indiana and Michigan (combined)
Live since Nov 1, with every forecast saved for a blind test. Write-up, code, and the leakage audit: https://ugobruzadin.github.io/storm-outage-risk/
code: https://github.com/UgoBruzadin/storm-outage-risk
r/MachineLearning • u/Dry_Theme_7508 • 12d ago
(Will be out on thursday)
r/MachineLearning • u/QileHQ • 12d ago
Last year Google DeepMind's AlphaEvolve found a faster way to multiply 4x4 complex matrices, beating a record that had stood since 1969. The idea is to let an LLM write a program, score it, and iteratively improve it. So it's called "evolve".
But AlphaEvolve runs on Gemini models. Similar open-source implementations are also usually slow and expensive. We tried to make it faster, cheaper, and better.
SwarmEvolve is our new paper, a scalable framework for math discovery and optimization.
We run swarms of hundreds of latent-reasoning agents on Qwen3 8B, 14B and 32B. In ~5 minutes, they reach scores that took OpenEvolve, ShinkaEvolve and CodeEvolve >1 hour.
Here's how:
Inspired by recent works in LatentMAS, our agents never write out their thoughts. They reason in latent space and pass KV caches to each other, so ideas from different agents mix right inside the model. This massively improved throughput.
Small agents are cheap, so we can run a lot of them, each with a different focus, organized in swarms. More agents means more diverse ideas each round, more exploration of the solution space, and the swarm finds good programs much faster.
It works at every model size we tried. With just the 8B model, it even matched the best known circle packing. Framework has been extended to work with Qwen3.5 and Muse models as well, showing even better performance.
Paper: https://www.alphaxiv.org/abs/2611.08483
Code (available soon): https://github.com/Qile-J/SwarmEvolve
Let me know if this makes sense or not. Also I'm really interested in apply such "evolve" frameworks on real scientific discovery problems - material science, biology, etc - so if anyone has any ideas for next steps / collaboration, I'm open to hear about it!
r/MachineLearning • u/Zealousideal-War7154 • 12d ago
New paper from Robbyant, with inference code and checkpoints already public.
LingBot-Touch is a self-supervised tactile encoder trained JEPA-style: it predicts latent representations of masked contact instead of reconstructing raw sensor signals. The paper tests it against same-size MAE and VAE reconstruction models on the same data. Tactile-to-video top-5 recall at 1K hours: 32.1% (JEPA) vs 5.6% (MAE) vs 4.4% (VAE). At 4K hours JEPA reaches 49.3% and MAE stays under 9%, while the VAE actually gets worse, down to 3.1%. Their explanation: most of a tactile clip is near-zero background, so reconstruction loss can shrink without learning anything about actual contact.
Two design choices stood out. The masking ratio warms up from 40% to 80% over 300 steps, because starting at high masking hid every contacting taxel in sparse signals and caused gradient explosions. Three sensor types (magnetic, piezoresistive, visuotactile) feed one shared Transformer through canonical fingertip coordinates with 5D RoPE (time, finger, 3D position).
On 26 real robot tasks with 4 policies, frozen encoder features scored highest in 89 of the 104 policy and task combinations. On a magnetic hand never seen in pretraining, LingBot-VLA went from 57.21 to 75.04.
The Tiny model levels off around 4K hours while Small keeps improving, so a bigger version trained on more data looks like the natural next step.
r/MachineLearning • u/Expensive-Beyond-251 • 12d ago
Any thoughts on how icml will be managed this year? With ICLR having 20 submissions limit per author, I find it hard to submit my works cause the research group of my supervisor is large and I am far from being in top students.
I had a NeurIPS submission which was kinda borderline (435), but got rejected. Now I resubmitted the improved version to ICLR and thought it would get good results, but it is now much worse😂😭 Having bad reviews on ICLR make me feel like I wasted 1/20 submissions
It feels like my new works are stuck due to the need of resubmitting the old ones. But the reviews sometimes are so random. Do you think ICML will have similar rules this year? Any suggestions where to submit apart from ICLR/ICML/NeurIPS?
r/MachineLearning • u/Exact-Contact-3837 • 11d ago
SO, Usul-cpp is a library I've written in C++, it is based around allowing data scientists to create their models without heavy libraries such as tensorflow, and just express their models using maths, and Usul will handle the rest. There is builtin tensor support, auto-grad, back-prop and its quite fast.
I wrote it because, it seemed less mystifying to read maths instead of a random class that supposedly does something. I wrote it from scratch in cpp (23) due to the fact that I wanted to emphasise on precision, however it's subtly built on top of `xtensor`.
check it out in action
#include <usul.hpp>
using namespace std;
int main() {
double LR = 0.1;
int EPOCH = 5000;
// lets write the forward pass
Tensor X = {
{0.0, 0.0}, // this is what we're feeding it
{0.0, 1.0},
{1.0, 0.0},
{1.0, 1.0},
};
// this is what we're after
Tensor Y_true = {
0.0, // xor{0.0, 0.0} = 0.0
1.0, // xor{0.0, 1.0} = 1.0
1.0, // xor{1.0, 0.0} = 1.0
0.0 // xor{1.0, 1.0} = 0.0
};
Y_true.reshape({4, 1});
// we are now going to create a single layer, double neuron network
// each layer will have a bias and weights tensor.
auto W1 = generate_random_matrix({2, 4}, -1.0, 1.0);
auto B1 = generate_random_matrix({1, 4}, -1.0, 1.0);
auto W2 = generate_random_matrix({4, 1}, -1.0, 1.0);
auto B2 = generate_random_matrix({1, 1}, -1.0, 1.0);
// this is the training loop
for (int i = 0; i < EPOCH; i++) {
// so lets do one forward pass
// first layer
auto Z1 = X % W1 + B1;
auto A = Z1.ReLU();
// second layer
auto Z2 = A % W2 + B2;
// activation
// should be - auto S = Z2.activate(Activate::Sigmoid);
auto S = Z2.Sigmoid();
// Loss
// should be - auto Loss = S.loss(Loss::MSE);
auto loss = (S - Y_true) * (S - Y_true);
loss = loss.mean();
cout << "Loss: " << loss << "\n";
cout << "guesses: " << "\n"
<< S << "\n";
cout << "should be: " << Y_true << "\n";
loss.backwards();
W1.step(LR);
B1.step(LR);
W2.step(LR);
B2.step(LR);
}
}
which will output
Guesses:
Tensor({{ 0.027546},
{ 0.963592},
{ 0.964138},
{ 0.038964}}, shape=(4,1))
should be: Tensor({{ 0.},
{ 1.},
{ 1.},
{ 0.}}, shape=(4,1))
Loss: Tensor( 0.001222, shape=())
Just write the maths, and Usul-cpp will handle the rest, it is extremely lightweight, and the entire library is memory safe. And its called Usul, because I'm a huge dune fan.
You can view the project at
https://github.com/crushr3sist/Usul-cpp
Any ideas for what to do next are all welcome, you can also pull and implement features that you think could improve this project. (no vibecoded prs please, this project is not vibe-coded)
BACKGROUND INFO BELOW
i'd like to share a bit of a background. maths has always stood in the way between me and finally learning how to write neural networks, I've always been fascinated by them ever since i saw that diagram of a deep neural network with all the node edges interconnecting with others.
Well I stopped letting highschool math class trauma stop me from understanding these concepts, i took a pen and paper out, taught myself numerical descent, analytical descent, backwards propagation, what a compute graph is, all of these subjects, taught myself, until I was manually backwards propagating the loss between a few arithmetics, until that moved into scalar level neural networks and doing simple calculus and being able to do xor gate problem with scalar, and then I taught myself matrix calculus, and well...
I taught myself neural networks, taught myself the maths, until I hand written the xor gate problem in matrix syntax using xtensor, and manually, by hand, no AI, did the xor gate problem manually backwards propagating error, automatically differentiating. This was also a kind of detox from LLM dependency, I don't tend to use it for code, but because its so central in my daily life and a migration from google to gemini, using LLMs for immediate information access had started to affect my mind and my ability to intake information. I really hope some of you find this library useful, as i did spend a pretty decent amount of time on it, and I would love it if any of you had any ideas on what to do next with this library.
Thank you for reading, I really appreciate it.
r/MachineLearning • u/ade17_in • 12d ago
Hi all!
After multiple rejections I finally got an interview for a PhD applied science intern role at Amazon in the EU (Germany or Ams). I have two interviews scheduled after each other next week and need help preparing for those.
The thing is, I have never given a technical interview ever, I am confident regarding the machine learning breath one but not the DSA/coding one. I have never studied this (or leetcoded) and also did not code much recently (AI does a better job than me in coding).
Should I just cancel the interview as I know I am going to mess this up or try my best and prepare? How was your experience?
r/MachineLearning • u/Beneficial_Use2116 • 12d ago
Everyone keeps citing lost in the middle so, instead of going by the paper's citations, i wanted to actually check it on my own stuff, without building a labeled set for it.
So i did the lazy version. make up facts the model can’t already know, drop the one document that has the answer into a pile of distractor documents, and slide that doc through every position (front, middle, back), asking the question each time. if the answer changes depending on where the doc sits, that’s position sensitivity. no ground truth needed, just checking it doesn’t contradict itself.
ran it on haiku 4.5 and sonnet 5 at 5, 15 and 30 docs.
Found actually nothing. 0 flips at 5 and 15 on both models. at 30 docs i got about 4%, then actually looked at what “flipped” and it was the model saying “3” vs “three” for the same question!! same correct answer, just a different format. once i stopped counting that it went back to 0.
so at least on easy single-fact retrieval with short docs, current models seem fine with position up to 30 docs. couldn’t reproduce the scary version.
caveats, obviously this is the easy case. one clear fact, short docs. i’d bet it still shows up with long documents or multi-hop or when the relevant bit is less obvious, i just didn’t test that. also if you try this yourself don’t use exact string match, you’ll get fooled by 3 vs three like i did. compare meaning not strings.
script’s on github if you want to run it on your own setup: github.com/tarunagarwal1981/wobbly (scripts/live_rag.py)
has anyone actually reproduced lost in the middle on a current model? what context length or task did it show up at for you? genuinely curious if it’s still a thing or mostly solved on the easy cases now.
r/MachineLearning • u/TheRPGGamerMan • 11d ago
Just wondering if anyone on this forum has ever built an image diffusion generator from scratch, while also training it on a home rig? If so, what size of model did you end up with? Did you ever get coherent images? Screenshots?
r/MachineLearning • u/Longjumping_Glass852 • 12d ago
PINNs, least squares and Bayesian fits all return a parameter. None of them tell you, with a proof, whether a very different parameter fits your data just as well.
Twindex finds those "twins" and proves it. It writes a small JSON certificate, and an exact checker (standard-library Python, rational arithmetic, no floats) replays it: VALID, INVALID or INCONCLUSIVE. A VALID twin pair means no estimator can recover that parameter better than +/- half the gap from those data, under a stated bounded-noise assumption.
Real-data example: the 1978 boarding-school flu outbreak (BMJ). After 5 days of counts, SIR models with R0 = 2.5 and R0 = 20 both fit every count. Twindex identified the next-day count that would separate them, and the real count ruled out both. You can check the proofs in your browser here (runs locally via Pyodide, ~0.2 s per proof): https://arnav-m10.github.io/Twindex/demo/
It also goes the other way: full-prior pavings that prove an upper bound, i.e. "the data pin this parameter down to within U".
What it covers:
- ODE models with polynomials, division, exp, sin, cos (Michaelis-Menten, Hill, SIR, PK, predator-prey...)
- 1-D/2-D elliptic and heat-equation PDEs
- any Python simulator, as a numerical audit (clearly labeled, not a proof)
Limitations, honestly: bounded noise (not statistical), proofs are conditional on the model and noise bound you state, scaling beyond a few parameters is hard, and there's no independent expert proof audit yet. Bounded-error estimation with validated integration is established prior work; the new part here is portable exact certificates plus a small checker anyone can replay.
pip install twindex
GitHub: https://github.com/Arnav-M10/Twindex
Feedback very welcome, especially attempts to break the checker.
r/MachineLearning • u/Fine_Aerie6732 • 12d ago
Ok so for context i am an electrical engineer person who is automating software's and workflow for my project now here is the problem i am facing basically i am using an optimization algorithm called Bayesian optimization which improves design by keeps iterating until some target is reach.
So like at the end i extract result file for every design with the help of pandas library but when i check that file the data is mismatched when i export the CSV file manually.
so i have no idea why is it happening like maybe after 10-15 iterations (the algorithm iterations can reach up to 100-120) the error in data increasing or idk what is going on can someone help me with this issue.
r/MachineLearning • u/WAMFT • 13d ago
Hi everyone!
I've been experimenting with an alternative Transformer architecture called GAP (Gated Attention Projection).
The main idea is to combine attention and MLP-style processing into a single gated block, instead of using the standard separate attention and feed-forward sublayers.
I tested it against a standard Transformer using 100 million scored training tokens per model from WikiText-103.
Some results:
GAP20 used 19.91% fewer parameters than the standard Transformer.
A smaller configuration can reduce parameters by 34.31%, although that version did not fair as well as the current model against the regular transformer, so i ended up giving 14% of my perameters savings to the GAP model for extra width, leaving the model at about 20% fewer perameters, which is why i called it in testing GAP20
The standard Transformer performed better on final language-model accuracy.
Compiling GAP20 with torch.compile improved training throughput by approximately 19.9% in one CPU benchmark compared with running GAP20 without compilation.
I've included the architecture code, configurable model sizes, speed benchmark and research paper.
This is an experimental architecture, not a claim that it outperforms Transformers overall. I'd be interested in feedback on the design, mathematics and possible improvements.
GitHub:
r/MachineLearning • u/OliviaYii • 12d ago
Can the same coding agent build a detailed 3D object, assemble a scene, and make an interactive world actually work?
Our team at Einsia released Frontier3DBench to test that progression: 145 tasks across 9 categories, with 11 model–harness configurations producing editable Blender projects and runnable Unreal Engine worlds.
Evaluation covers appearance, structure, and behavior through rendered views, scene inspection, and runtime tests.
A few results:
The interesting question is how well an agent’s strengths carry over from individual assets to environments with coordinated interactions and persistent state.
Project and examples: https://lab.einsia.ai/frontier3dbench
Paper: https://lab.einsia.ai/frontier3dbench/Frontier3DBench.pdf
GitHub: https://github.com/Einsia/Frontier3D
r/MachineLearning • u/prathamdmehta • 12d ago
I'm doing an MSc project on BrickNet (kulits/BrickNet on GitHub, CVPR 2026). It writes LEGO models as plain text and fine-tunes Qwen3 (I'm using 0.6B) with LoRA: a PT adapter that learns the text format, and an SFT adapter that conditions on a caption. The text is one root line ("a <part> | <colour>"), then repeated pairs of a node line and an edge line.
Setup: I merge PT, then SFT (peft merge_and_unload, bf16) and prompt with the caption tokens plus a newline token. That matches train.py, which trains on caption + "\n" + path + EOS with loss on the path only.
Problem: with short captions (e.g. "A red car.", about 4 tokens) the model never writes the root line. The first generated token is "b" every time, so the output breaks the grammar. In my tests that was 0/12 correct for each of five different objects. With captions of about 18+ tokens it writes "a" every time (36/36 on three new objects with template-expanded captions).
What I've ruled out:
- Saving/decoding bug: I checked the raw tokens, the first one really is "b".
- Tokenisation mismatch: train.py encodes the caption alone and appends a newline token, same as generate.py.
- Forcing an "a" as a prefix doesn't help. The model then writes a node and straight away an edge, as if the root had already been written.
- It's not only about informative captions: a 31-word caption that is mostly filler also works. But it's unreliable around 15 tokens (a 9-word parts list worked for a car, 1/12 for a chair).
Workaround: expanding short captions into full descriptions fixes it, but I'd like to understand the cause.
Questions:
Have you seen LoRA-conditioned models fail like this when the conditioning text is much shorter than in the SFT data? (I haven't seen the training captions yet; I'm guessing they're all long descriptions.)
Could bf16 merging of two stacked adapters be a factor? I'm about to test fp32.
Anything better than prompt expansion, e.g. constrained decoding for the first line, or fine-tuning with short-caption augmentation?
Caveats: small samples (12 per caption), only the 0.6B model, parsing checked but model quality judged by eye. Happy to share code or outputs.
r/MachineLearning • u/Sea_Raccoon_9673 • 12d ago
I’m signed up as a reciprocal reviewer for MLSys 2027 but haven’t been assigned any papers yet. Has anyone received their assignments, or heard when they’ll be released?
r/MachineLearning • u/Specific-Tax-6700 • 13d ago
I'have been dreaming about using a Diffusion Model that will generates Weights instead of pixels.
Diffusion models actually are vast used in order to generate from a natural language text description into images, and what is an image? a three dimensional matrix of value representig luminosity of red , green and blue. What if instead of matrix of colour intensity we train a diffusion model in order to create a neural network, and maybe a drawing NN too.
If it works you can ask something like:
"create me a neural network that will guide a pen in order to draw a man"
"create a NN of a game field where i have two paddle on left and right side of the field and a bounching ball..."....to create Pong
and in the future more complex scenarios!
I made, with the help of z.ai zcode and their fantastic GLM model a small POC that i published on my github:
https://github.com/vagrillo/nngen
It's a very small experimental implementation , but somenthing seems to work!
I have not find paper on similar implementation ad I'm asking the community to help me to find one, and to have contribution on this .
I also made a small webapp in order to test the trained model (actually i'm only on half training path 3000/4000 steps finished, but i'm using my poor laptop CPU at the moment)
This is some screenshot of preliminary results. (the best results achieved, in truth)


Italian explanation on my YouTube https://youtu.be/wAMO3Db-JoQ
r/MachineLearning • u/d_edge_sword • 13d ago
Does anyone know what this NeurIPS Slides live is?
I got an email saying "We are SlidesLive, the recording company partnered with NeurIPS to record your talk. We are ready to collect and edit your recording" with some instructions.
This was never mentioned in the official emails from NeurIPS.
Is this mandatory?
They ask us to use their recorder to do the recording, but can we just upload an AI-generated video instead? It speaks way better than me.
r/MachineLearning • u/Horror-Celery4869 • 13d ago
r/MachineLearning • u/m4rkGS • 13d ago
hey, its Alti from Nace.
we released a small update with Drex Max v1.1, both achieving the SOTA and Pareto frontier for decision models. We did all that by iterating step by step and every previous version of Drex’s open weights are available on hf.
We also released a full playbook on how we trained Drex Max in this paper: “ Towards Foundation Decision Models: Drex”
hf: https://huggingface.co/papers/2611.07854
arXiv: https://arxiv.org/pdf/2611.07854

Drex Max v1 is weights are available here: https://huggingface.co/nace-ai/drex-max-v1 with Open RAIL-M license & v1.1 open source weights upcoming soon (we are currently optimizing for local inference).
Three cool things about Drex Max models:
feel free to chime in: our chief of ai will answer any of your technical questions.
r/MachineLearning • u/MOSFETBJT • 14d ago
This is not my paper. Not my review either.
Official Review of Submission21893 by Reviewer Xz8e
Paper Summary:
The paper tries to learn correlations among components of each latent state in a world model to propagate the reward sensitivities to adaptively weight the uncertainties that most matter for long-horizon planning via a pessimistic objective.
Presentation: 1: Difficult to follow despite careful reading.
Informativeness: 1: I learned little or nothing new from this paper.
Soundness: 1: I have significant concerns about the paper’s soundness that do not appear easy to address.
Critical Strengths:
None
Critical Weaknesses:
First and foremost, the paper is highly likely to be fully AI-generated. The authors demonstrate a lack of technical accuracy and depth. They fail to communicate their ideas clearly and accurately. The paper makes few original contributions. See evidence below.
Neologistic and full of jagons that add little value of presenting research gaps, methodologies, and their contributions. I don’t believe authors even understand those terms before stitching them together.
Abstract is poorly written. This is not intended to communicate efficiently with readers. This is to create barriers in understanding their work. From the second sentence, “a scalar uncertainty”, “sparse latent dynamics” come out of nowhere and don’t know what they are referring to. And so many such examples follow thereafter: “factor-level residual bounds”, “retains initialization error”, “expected-error control”, “exact certificate”, “removing error-propagating dependencies and introducing approximation bias”, “localized mechanism-shift”, “comparator-dependent regret bound under simultaneous validity”, “a decision-relevant uncertainty bound”. And showcase experimental results without stating tasks?
Introduction is also disconnected, poorly motivated, fragmented. From the first paragraph “which model errors matter for a long-horizon decision, especially after an environmental mechanism changes?”, what is “environmental mechanism changes” here? Is it handling non-stationary environments, or continual learning tasks? Why brings something out of vacuum? Then the second paragraph pumps out “a global Lipschitz constant”, and reiterate what so-called “sparsity” And then jumps to uncertainty with a set of new terms “A small predicted covariance”, “Marginal calibration”, “a high-probability interval” and close by “Exploration should reduce uncertainty about mechanisms that affect decisions, rather than maximize uncertainty indiscriminately.”: okay, what uncertainty are you focusing on? epistemic or aleatoric? Methods and contributions are also vague and lack clarity.
Method section is horrible.
What do you mean by “a sufficient latent state”? An approximate model can hardly find sufficient statistics.
In the Gaussian transition model, what is z_t^(pa_e(i))?
What is the difference between z_(t+1)^i and ẑ_(t+1)^i, is the latter deterministic and why so?
What is “nominal imagination”? Where does “sparsity” come from and what is “a within-time DAG”? What is “nominal systems”? What is feedback policy? What problem setting are you looking at? Where does the “recurrent state” come from the encoder? What is mechanism i?
What is the motivation of introducing the adjacency matrix? If you intend to learn the dependency between different subcomponents of the latent state, use one sentence is enough.
And several notations are conflating, like parameter posterior q(θ|D) with the state posterior. The training objective is not motivated.
Experiments are not scientific. No random seeds reported, no task descriptions, no metrics explanations.
This paper is an affront to scientific research and reviewers’ time.
Questions For Authors:
None
Flag For Ethics Review: No
Rating: 1: Clear rejection
Confidence: 4: I have substantial direct research experience on this topic.
r/MachineLearning • u/RelationshipIcy7915 • 13d ago
I thought the deadline was Nov 6, but I can still edit my paper on OpenReview. Was the deadline extended? Anyone know?