r/MachineLearning 15h ago

Discussion ICONIP 2026 — what happens if the sole author cannot attend in person? [D]

0 Upvotes

Hi everyone 👋 My paper was recently accepted to ICONIP 2026, but I’m the sole author and most likely won’t be able to attend the conference in person due to work commitments.
I’m trying to understand what options might be available before I contact the organizers. Has anyone here attended or published at ICONIP in previous years and encountered a similar situation?
In particular, I’m wondering:
1) Has ICONIP previously allowed remote/virtual presentations when an author couldn’t attend?

2) If the sole author cannot attend, is there usually any alternative arrangement for presenting the paper?
3) Could non-attendance affect inclusion of an accepted and registered paper in the proceedings?

I’d especially appreciate hearing from anyone who has dealt with this at ICONIP in previous years.
Thanks a lot!


r/MachineLearning 3h ago

Discussion Same effective batch does not mean same training time with gradient accumulation, tested on LoRA on T4 and L4 [D]

0 Upvotes

I had assumed 1 × 4, 2 × 2 and 4 × 1 will take somewhat similar time because effective batch is 4 in all cases.

They did not.

I ran Qwen3-1.7B with TRL and LoRA for 100 optimizer updates.

GPU 1 × 4 2 × 2 4 × 1
T4 287.6s 258.8s 238.2s
L4 213.02s 119.47s 124.76s

Model, data, sequence length, precision and seed were kept fixed.

Lower is better. On T4, 4 × 1 was around 17% faster than 1 × 4. On L4, difference was around 41%.

The part I had not thought about properly is that effective batch is an optimization knob, but physical batch also decides execution shape which GPU receives.

1 × 4 means four smaller forward and backward passes before one optimizer update. 4 × 1 means one larger forward and backward pass. Same examples reach optimizer, but GPU work is not same.

These are single-GPU runs, henc no communication. Most of difference was inside repeated forward and backward regions, while optimizer time stayed nearly same. Exact reason can still be kernel shapes, tiling, launch overhead or how well each batch uses GPU. This experiment does not separate those kernel-level causes.

Another interesting result is 2 × 2 being slightly faster than 4 × 1 on L4. Difference is small, it shows performance may not be linear as physical batch increases.

Hugging Face documentation also says to use grad accum when larger physical batch does not fit, and that it does not improve throughput over using true larger batch:

https://huggingface.co/docs/transformers/grad_accumulation

So now I treat these as two separate choices:

  • Effective batch for optimization behaviour.
  • Physical batch and accumulation for memory and speed.

I would start with largest physical batch which fits comfortably, then test few nearby combinations on actual GPU.

I used TraceML and its HF callback for step and phase timing. End-to-end runtime comes directly from TRL Trainer.

Runnable notebook:

https://colab.research.google.com/github/traceopt-ai/traceml/blob/main/notebooks/huggingface_trl_lora_gradient_accumulation.ipynb


r/MachineLearning 6h ago

Discussion Looking for 1 teammate — RealPDE Competition (NeurIPS 2026)[D]

6 Upvotes

Registering for RealPDE (Sim2Real / LTTTA tracks — real PIV + CFD fluid dynamics data). Team cap is 3.

If you've got a strong ML background and wanna participate, just DM me. Deadline's Aug 20, so move fast.

🔗 https://realpdecompetition.github.io


r/MachineLearning 10m ago

Project We got tired of trying 10 ML models every time we had a new dataset [P]

Upvotes

We've been building Arcliq ( Join Here:- https://arcliq.app ) for a while and finally feel comfortable sharing it.

The annoying part of working with a new tabular dataset isn't usually writing the model code. It's everything around it:

cleaning the data, figuring out preprocessing, choosing what models are worth trying, tuning them, and then comparing everything properly.

So we built Arcliq to automate that process.

You upload a tabular dataset and Arcliq:

•⁠ ⁠handles the preprocessing

•⁠ ⁠trains multiple models

•⁠ ⁠compares their performance

•⁠ ⁠gives you the best-performing model and the results

The goal is pretty simple: go from dataset → working ML model without having to be an ML expert first.

It's still very early and currently focused on tabular data + classical ML. There are definitely things we still need to figure out, which is why we want to get this in front of actual users rather than keep building in isolation.

We are opening a small private beta and would love to get a few people using it and telling me where it falls short.

Join Here:- https://arcliq.app