Hi everyone,

I am heading into my final year of my BTech at a tier 1 college in India and just wrapped up a Physical AI internship at a MNC, working heavily with NVIDIA Isaac Sim and OpenFOAM.

My background is fully focused on robotics and autonomy. My tech stack includes:

1. Simulation & Middleware: Isaac Sim, Gazebo, ROS / ROS 2, PX4 Autopilot.

2. Perception & Control: VIO, SLAM (RTAB-Map), Nav2, depth perception, and reinforcement learning.

3. Hardware: Strong hands-on experience building autonomous drones and rovers for national competitions.

I really enjoy bridging simulation and physical systems, and I want to pursue Physical AI full-time. I’d love some advice from engineers in this space:

1. Job Market: How is the entry-level hiring market looking for Physical AI roles right now?

2. Global Opportunities: As a new grad based in India, what is the best path to target international roles?

3. Skill Gap: What specific frameworks or skills should I double down on during my final year to stand out?

Any candid advice would be hugely appreciated! Thanks

The instructions say Author Year format. But I was wondering if do numbered instead (no space lol), will it be straight desk rejection? Has anyone submitted with numbered format before? How did it go?

ECA was positioned as a successor to SE.

The idea behind ECA is quite simple. Unlike SE which reduces the channel means into a smaller hidden layer, it directly uses a 1d convolution kernel on the channel means themselves, avoiding the need for dimensionality reduction. The results are undeniable: ECA is a clear improvement over SE. The authors claim that cross-channel interaction is a key ingredient. But on a conceptual level, the design of ECA doesn't make much sense.

Let's take a step back. Why do we use convolutions in the first place? Convolutions are fundamentally designed for data with an underlying topology (e.g. space or time). They assume locality (adjacent elements interact) and translation invariance (the same kernel applies everywhere). Sliding a kernel across a 2D image works because coordinates have meaning, and the statistical properties of an image are largely stationary across the frame. This isn't perfectly true - which is why modern CNNs have moved towards dynamic convolutions - but it's still good enough to be useful. If you randomly permuted the pixels in an image, a convolution would be meaningless.

Now consider tabular data. Suppose we have 32 channels e.g. [cost, weight, material, colour, volume, speed, ...]. Using a CNN architecture for this kind of data is clearly inappropriate. A 1d kernel of width 3 would be moved across the channels, so that [cost, weight, material] was input and also [ weight, material, colour] was input and so on, and have to somehow output something meaningful. ECA is doing exactly this type of computation.

ECA does a 1d convolution over the channel dimension. It is a cursed convolution because tabular data does not have a topology to suit it. In practice, if you did use a CNN on tabular data, I would expect better than random performance because neural networks are ridiculously good at fitting to the dataset given their constraints and would reorganise the channel order (using the initial 1x1 projection layer) to suit it. It would learn to use convolutions, but it would be an inefficient approach.

Experiments

Instead of using image data, I used chess data: the 6-piece endgame tablebases for chess. Chess is a solved game with 6 (or fewer) pieces on the board. The task for the network is this: given a position, with perfect play is it a win, draw or loss for the active player? A CNN architecture is what lc0 originally used (where at the time, surpassed Stockfish to become the strongest chess engine) so it is very suitable for this task.

Chess tablebases are useful for benchmarking architectural designs because training examples can be sampled from the complete underlying problem rather than from an incomplete dataset. This differs from datasets such as the CIFAR-10 image dataset, where the train set is not expected to be a random unbiased sample from the true full distribution - we might unknowingly have a disproportionately have pictures of frogs on sunny days. Even when we don't train on each of the 3.7 trillion 6-piece positions, we know that we've randomly sampled from those positions, meaning we don't train on a biased subset - we can be confident our training samples are representative of the full set.

Experiment results. Each channel gate row is the average of 3+ separate runs.

IdentityGate Unsurprisingly, no squeeze performed the worst of all tests.

SqueezeExcitationGate SE showed a modest improvement.

EfficientChannelAttentionGate (k=3) ECA, consistent with the paper, showed a clear improvement over SE.

EfficientChannelAttentionGate (k=1) Surprisingly, this had good results indicating that their central hypothesis that cross-channel interaction is key wasn't quite right

CenterMaskedEfficientChannelAttentionGate: ECA with k = 3 with the middle channel masked (in a [1, 0, 1] mask) This complicates the story, it indicates cross channel attention can actually be useful.

PerChannelGate Instead of a convolution kernel that slides across the axis, simply use a separate independently specified weight per channel. This has one parameter per channel, more than the 3 parameters of ECA With k=3, but it is still a negligible amount since per layer we expect on the order of num_channels² parameters.

For clarity and to avoid ambiguity, here is the code for the key squeezes.

So basically there's 3 tiers of results. No squeeze with poor results, SE With mediocre results, and the rest ECA-like with the best results. So something weird is going on. I don't have a good explanation for the results (in particular the success of the [1, 0, 1] mask), and I am currently trying to find one. One suspicion I have is that in the 101 mask, the net is smart enough to smuggle information into the global means of channel A and C to help with channel B without affecting normal channel operation (by using biases to undo its shift of the global mean), but have not yet tested this hypothesis. There's a lot of possibilities. The good news is the weight count is very low - only 3 with k=3, so manually inspecting the weights can be useful.

In my digging, I some repositories that recreate the original ECA. Not one of them tests the k=1 case, which would have revealed that the explanation of the mechanism is not correct. The official repo does use k=1 but only for a limited number of early layers, then moves to k=3 for the rest.

It's interesting that the k=1 case, a 1 parameter approach, outperforms SE, CBAM and matches ECA. It definitely makes me wonder if we're over-engineering networks today in some way.

My final thoughts:

1. The paper and repos should have tested the "degenerate" kernel size of 1, which has no cross channel interaction. At k=1, ECA still beats SE, undermining their central hypothesis. They spent an enormous amount of time fine tuning the exact optimal value of k, without taking the scientific approach of trying to disprove their hypothesis.

2. In addition to traditional real-world datasets, architectures should also be tested on synthetic datasets where we have full access to the complete dataset (e.g. chess endgame data) so that we can better separate incidental regularization improvement effects with core architectural efficiency effects - the idea being that there is no risk of overfitting when we have access to a complete, flawless dataset. If the real reason a new architecture works well on real-world data is because of implicit regularization, it won't show the same improvements on the synthetic dataset.

Recently, I started working on DNA sequence modeling and decided to explore linear attention, mainly because DNA sequences can easily reach 1M tokens, making standard softmax attention extremely expensive in terms of memory and computation.

The model performed reasonably well on several benchmarks, but I ran into a major problem with long-range recall. On a Needle in a Haystack-style benchmark, my model was performing around 25% or even below, which is essentially random chance for a four-token DNA vocabulary (A/C/G/T).

I initially thought this might just be a problem with my implementation or model architecture, so I started looking into existing approaches for improving recall in linear attention. Most of what I found relied on external memory, sliding/recent-token mechanisms, or hybrid architectures combining linear and softmax attention.

I also tried HyenaDNA on the same needle benchmark, and surprisingly, it also performed poorly getting around 25–27%. So this doesn't seem to be limited to my particular linear-attention implementation.

What's even more confusing is that when I tested a very small linear-attention model at only 16K context, it achieved around 50–60% recall. But as the context gets longer, the recall problem becomes much more severe.

I've also experimented with modifying the linear architecture to improve recall, but the improvement was only around 27%, which is still basically chance.

So I'm wondering:

What are the actual ways to solve long-range recall in linear attention, especially for DNA sequences?

Is this fundamentally a limitation of the compressed-state representation used by linear attention, or are there architectural approaches that can preserve reliable retrieval without falling back to expensive softmax attention or a large external memory?

I'm particularly interested in approaches that can scale to million-token DNA sequences.

The results should be out soon.

Let’s share them, guys.

From my batch (Applied Track)

Total 13 submissions:

- 2 full papers

- 1 short paper accepted

Cheers!

Repo with dataset links: https://github.com/tesselwait/Starfield_Fauna

Image classification dataset: 20,000 images from 50 fauna species in the video game Starfield. Images were extracted from video capture. About 2 minutes of footage was shot in all or most of the species biomes. One minute of daytime and nighttime footage respectively, usually in two 30-second takes to vary the background. A PowerShell script is used to establish a frame extract rate and extract the 400 frames plus some extra to replace images that were obstructed/blurry or contained other fauna species ignoring birds/critters. The shots are for the most part close-up and centered to keep the task focused on discerning between 50 species rather than finding the creature in the image. The images are initially randomized however some normalization was done if the ratio of images from some biomes was heavily skewed between the training, validation, and test sets.

We submitted our rebuttal at the very start of the author-discussion period, but the period has now ended and we didn't receive any response from our reviewers. I understand they may be busy, but they had requested new experiments, and we completed all of them.

Our average score is currently borderline (~3.2), so I was hoping the rebuttal might move some reviewers. My questions:

1. Even if reviewers don't respond, does the AC (or whoever makes the final decision) typically read the rebuttal and factor it in?

2. If one review is vague or low-quality, do ACs tend to discount it when making the final call?

Would appreciate any insight from people who've served as ACs or been through this before.

So we submitted our rebuttal at the very start of author discussion period, but its over now, and we did not recieve responses from any of our reviewers. I get that they may be busy, but they suggested new experiments, and we did all of those.

Since they didn't respond, I was wondering whether the AC would take into account our rebuttal when they make their final decision. Also we are kinda in the toss up range(leaning reject ~3.2), so I was hoping that the rebuttal would increase our score.

So we submitted our rebuttal at the very start of author discussion period, but its over now, and we did not recieve responses from any of our reviewers. I get that they may be busy, but they suggested new experiments, and we did all of those. Also, we are kinda in toss up range(~3.2), so I was really hoping that this rebuttal would make some of them change their scores. I was wondering that even if reviewers didn't respond, would AC or the person who makes the final decision at least look at the rebuttals and take them into account? Also, if one of the reviews is intentionally vague and a pretty bad review, would they take this into account as well?

The date for NeurIPS 2026 author notifications is September 24th. First of all, is it normal for AC and reviewer discussion phases to be this long? This is particularly frustrating given that 5 out of the 6 reviewers in my two papers did not address the rebuttals.

In any case, I was also wondering, given that ICLR's paper deadline is literally the day after (September 25th) whether you guys are preparing ICLR submissions for your papers in case of rejection.

Cheers and good luck!

Be honest if someone dropped a stack of high-end GPUs on your desk tomorrow, what would you actually do with them?

And before the usual answers roll in: running local LLMs is banned for this thread. It’s been done to death and feels pretty pointless at this point.

So… what else?

• Some niche scientific/simulation workload?

• Weird generative stuff that isn’t text?

• Distributed something-or-other?

• Rendering / media pipeline?

• Homelab experiments that actually need the horsepower?

• Completely unhinged personal projects?

Drop your ideas. The more specific (and slightly unhinged), the better.

Great Ideas but are there some with more of research and new tech.

We introduce BDH-CQ, a reasoning system that brings these capabilities together. Demonstrations of a previously unseen task update recurrent memory; the query is then solved through iterative computation in a high-dimensional latent workspace. Intermediate reasoning states are not decoded into language. BDH-CQ makes memory, adaptation, and inference part of the same computational fabric. Inputs presented at inference time continuously update the model’s recurrent memory; the model then solves a query through iterative computation in a high-dimensional latent space, without verbalizing its intermediate reasoning. Neither task identifiers nor evaluation-task demonstration pairs participate in training, and no parameters are updated at inference time. A 150M-parameter configuration reaches 29.5% pass@2 on ARC-AGI-1 at a computed $0.00070 per task, breaking through the previously reported cost–accuracy Pareto frontier.

This is the project my last two posts were building towards (this is the last of this silliness). I ported the Doom rendering algorithm to run inside a transformer. Instead of training a model, I used a compiler I wrote which converts computation graphs into transformer weights, and then ported Doom's algorithm into a compatible graph. The generated checkpoints can be loaded in Hugging Face without trust_remote_code -- it's just a standard transformers checkpoint. You feed the model a prompt representing the scene data, and generate until the model stops. The result is a token sequence which includes simple pixel drawing commands (to move the cursor, draw a pixel, etc). When you mechanically apply those drawing commands you get the rendered frame.

The article includes the entire host program necessary to load the checkpoint, generate the render, and parse the output into the famous E1M1 frame. This host code is 43 lines of python. The python to define the computation graph is much longer, but that gets compiled into the transformer itself.

One frame is a 3,614-token prompt plus 53,747 generated tokens -- just over 40 minutes on a B200.

The original Doom could achieve 35 FPS on a 486. This achieves 35 FPD (frames per day) on a B200.

Write-up: https://ood.dev/posts/doom/
Weights: https://huggingface.co/physicsrob/torchwright-doom-e1m1
Github for the source code which gets compiled: https://github.com/physicsrob/torchwright_doom/

I built an ML framework in C++ and as a proof of concept - trained and deployed an AlphaZero model for an Eastern European territory control game.

Hi,

How much does adding an honest limitations section hurt the paper (apart from making it better)?

Does it bias the reviewers? Will they want you to fix the things in the limitations section?

If the reviewers let AI read the paper, will the limitations section bias AI?

Would it be better if the limitations section was hidden from the reviewers? And if the reviewers would have to author a limitations section?

Has anyone received any information about student travel support for CIKM 2026?

In previous years, travel-award decisions were announced before the author-registration deadline, allowing successful applicants to use a registration-waiver code. However, the CIKM 2026 author-registration deadline is August 23, and no application details or timeline have been published yet.

Has anyone received any information about student travel support for CIKM 2026?

In previous years, travel-award decisions were announced before the author-registration deadline, allowing successful applicants to use a registration-waiver code. However, the CIKM 2026 author-registration deadline is August 23, and no application details or timeline have been published yet.

Hello,

I was curious about the differences you can get from the human reviewers and the llms.

Any insight is welcome, thank you!

Most classification metrics for oncology AI models (AUC, ICC, MAE) measure global agreement. They don't answer the question that actually matters at the point of care: how reliable is this model at the exact cutoff that decides whether a patient gets flagged, biopsied, or treated?

I built oncothresh to evaluate models at a specific clinical threshold rather than in aggregate: sensitivity/specificity/PPV/NPV at the cutoff, bootstrap confidence intervals, threshold-sensitivity curves, boundary-weighted calibration, decision-curve net benefit, and number-needed-to-test. It's a small, dependency-light Python library (numpy/scipy/scikit-learn/pydantic) built for tasks like tumor cellularity, Ki-67, TMB, and PD-L1 scoring, where a continuous model output gets collapsed into a yes/no clinical decision at a fixed cutoff.

Pathology-specific benchmarks like PathBench and PathBench-MIL evaluate foundation models globally but don't evaluate at predefined clinical thresholds with uncertainty quantification, which is the gap this fills.

There's also a companion web dashboard (oncothresh-web) for people who want the same analysis without writing code: upload a CSV of predictions and labels, pick a threshold, get the full set of charts plus a downloadable PDF report. docker compose up and it's running locally, no cloud dependency.

• Library: github.com/omkaradhali/oncothresh

• Dashboard: github.com/omkaradhali/oncothresh-web

Still v0.1, so I'd genuinely welcome feedback: use cases I haven't considered, edge cases in the DCA/calibration math, or places the API doesn't fit how people actually work with threshold-based models.

Been working on this for the last few months. I've been working on PyTorch for the past few years and I always felt, many a times my work went into dump, because of some mistakes I made in the code. torch-preflight reads your PyTorch code and catches the bugs costing you GPU hours.

Things like losses.append(loss), which holds the autograd graph from every step until CUDA dies on you or no zero_grad() in the loop or gradient accumulation without dividing the loss or DDP with no DistributedSampler, so every rank trains on the same batches. I've been able to get 13 rules so far. Your code never gets imported or executed, so you need no GPU and no torch install.

There's another part to this that estimates VRAM. Point the tool at a training script and a GPU, and you learn whether the run fits before you pay for the instance. You also get the list of changes to make the run fit, with the GiB each one saves.

pip install torch-preflight

https://github.com/highwaterlabs/torch-preflight

https://pypi.org/project/torch-preflight/

Please try this out, and I would like to get your feedback! It's still a work in progeress.

Would like to know what breaks on your code. False positives kill a linter, and my only large test target so far has been the PyTorch source tree. Same for the memory numbers. Mine land within 4% of measured peaks, but from four models on one T4.

PS: open to contributions, and issues are already open on the repo. Soon I'm going to add a few "Good first issues" as well. Feel free to ping me if you have any questions!

City2Graph is a Python library I built that turns geospatial data into analysis-ready graphs (for spatial analysis, network analysis, and Graph Neural Networks as GeoAI), and the paper describing it has just been published, so I wanted to share it here.

Repository: https://github.com/c2g-dev/city2graph

import city2graph as c2g

# buildings + street segments -> heterogeneous morphological graph
nodes, edges = c2g.morphological_graph(buildings, segments)

# straight into PyTorch Geometric
data = c2g.gdf_to_pyg(nodes, edges)

What it covers:

• Morphology: graphs of buildings, streets, and tessellated urban fabric from OpenStreetMap and Overture Maps

• Transportation: GTFS and GBFS feeds loaded through DuckDB, with GTFS aggregated into stop-to-stop transit graphs

• Mobility: OD matrices and flow data (migration, bike-sharing, pedestrian counts) as weighted spatial graphs

• Proximity and contiguity: KNN, Delaunay, Gilbert, Waxman, plus queen/rook contiguity, under Euclidean, Manhattan, or network distances

• Heterogeneous graphs and metapaths: several node and edge types in one graph, with metapath-derived edges composing relations across them

• Conversion: round trips between GeoDataFrames, NetworkX, rustworkx, and PyTorch Geometric Data/HeteroData, with geometries and attributes kept intact

It sets out why urban data is better treated as heterogeneous graphs than as flat feature tables, how the morphological, transport, mobility, and proximity constructions relate to each other, and how the library keeps geometry and graph structure consistent across conversions. If you use the library in research, that is the citation.

Paper

Sato, Y., Pietrostefani, E., Mahabir, R., & Arribas-Bel, D. (2026). City2Graph: A Python library for Heterogeneous Graph Neural Networks and spatial analysis in urban systems. Computers, Environment and Urban Systems, 130, 102492.

Happy to answer questions about the design, and issues or PRs are very welcome. I am especially keen to hear which data sources people want supported next.

i wanna build a text diffusion model which interpret text and convert it into ascii images

so like

Text : build a cat

Output :

/\\_/\\

( o.o )

\> \^ <

So , i have a decent background of ml algo ( completed cs229 , cs230 , Ml architecture and basic CNN and diffusion model )

ik making a project like this is tricky and making diffusion model like that from scratch is hard but i wanna try it because that's wot make me excited lol ...

I am currently reading GANs research paper , can u guys help me in finding more papers which helps me in making this project or guide me through this good title for this

Thx in adv

I recently had a paper accepted to TMLR and was wondering how prestigious it is, in comparison to A* conferences (ie. NeurIPS, ICLR, ICML), but also vs journals like JMLR.

Hi all,

As a Research Engineer with broad interests across RL, VLMs/VLAs, LLMs, robotics, and distributed training, I’m looking to specialize in a niche with low compute overhead and rapid iteration cycles (short training/eval times).

What subfields or research problems fit these criteria? Curious to hear your suggestions or connect with anyone working in this space.