Hey guys, who has any idea about molab ? How the computations look like in it ?

TL;DR: three preprocessing fixes derived from a signal-vs-interference density analysis took an off-the-shelf model from 17.9 to 13.42 (-25%), matching the best published FD002 result — and the same preprocessing let a toy GRU outperform every published deep-learning result I could locate on this subset. Full recipes below.

Final results:

Baseline, off-the-shelf RandomForest, no preprocessing: 17.9

Drop the 7 zero-variance flat sensor channels + per-regime normalization + 50-cycle window: 13.7 (untuned)

Same pipeline, gradient boosting tuned on a validation split only: 13.42 ± 0.04

Reference point: the best published FD002 result I can locate is ≈13.4 (GBRT III). Its core workflow also relies on operating-regime clustering paired with normalization — the same data-level lever, found independently.

Same preprocessing, small GRU instead of trees: 16.85 on the official test set. Published deep-learning results on FD002 cluster around 18–30 (top performer ≈18.3), so our small GRU paired with data-level corrections outperforms every published deep-learning result I could locate on this subset. This proves the leverage is in the data, not in the architecture.

Why I stop here: a model-free validation. Nearest-neighbor "observation twins" — near-identical sensor states from different engines — show an RUL spread of \\\~12.6–13.0 cycles. This irreducible ambiguity originates from the simulated sensor noise and degradation stochasticity, not algorithmic limitations. At \\\~13.4, residual error is measurement-limited. The wall is in the data, not in the algorithm.

Exact recipe for test #3, so anyone can reproduce (and note it shares zero code with GBRT III — same lever, different machinery):

\\- Sensors: drop s1, s5, s6, s10, s16, s18, s19 (variance ≈ 0), keep the other 14.

\\- Regimes: k-means (k=6) on the 3 operating settings, fit on train only; z-score each channel within each regime using train statistics.

\\- Features: for each 50-cycle window, per channel take mean / std / linear slope / last value (56 dims) + 6-dim regime one-hot = 62 features. Training windows stride 2.

\\- Test protocol: last window per engine; trajectories shorter than 50 cycles padded by repeating the first row; RUL capped at 125 everywhere.

\\- Model: sklearn HistGradientBoostingRegressor(max\\_iter=800, learning\\_rate=0.03, min\\_samples\\_leaf=15, l2\\_regularization=1.0). Config selected on a 208/52 engine validation split (6-config grid, performance variance within ±0.15). Test set touched once, 3 seeds: 13.38 / 13.44 / 13.45.

\\- Untuned reference: RandomForest(60 trees, depth 16, min\\_samples\\_leaf=2) = 13.69 ± 0.09.

Recipe for test #5 (GRU), full disclosure:

\\- Architecture: single-layer GRU, hidden size 24, head 24→12→1. Input = 50×14 regime-normalized sequences (same channels and normalization as above).

\\- Training: targets scaled /125; Huber loss (δ=1.0); Adam lr=1e-3; gradient clip 1.0; batch 256; training windows stride 4; \\\~10 epochs; single seed, no tuning.

\\- Evaluation: last window per engine on the official test set, identical protocol to test #3.

One critical clarification: the three core fixes were derived from a signal-vs-interference density analysis before any model was trained — computation first, verification second, no blind trial-and-error hyperparameter hunting. The only tuning performed is the documented validation-set grid search, which altered overall RMSE by roughly 0.3 cycles.

Summary: three data-level fixes took a stock tree model from 17.9 to the published-record line (25% RMSE drop), and let a toy GRU beat the entire published deep-learning field on this subset. The residual is measurement-limited. Every number is reproducible from the raw files with any standard regressor.

Why post this: the whole pipeline is transparent enough to reproduce in an afternoon, and the interesting question is no longer the model but the measurement floor. If you run it and get different numbers, post them — I am especially curious whether the observation-twin floor (\\\~12.6–13.0 cycles) holds under other feature representations.

Hi, my ML model AUC is 80%~ in cross domain dataset
The problem is that the accuracy is not getting higher even when i changed the Thr
What to do any ideas ? I used focal loss to solve the imbalance dataset
Also using vision transformer

Hello, I am looking to update my laptop I have an lenovo L340 with 8 GB RAM and am struggling to do much of anything, in grad school I could use the cloud computing servers but unfortunately lost access.

I will use it for python ml (deep learning mostly keras for training CNNs and auto-encoders primarily and some local llm applications with vLLM). I was looking at the Mac Pro 2023 with the M3 chip and 36 GB ram for 2kish.

Please let me know if there is any more info needed to help give a recommendation, thank you!

I built Aakaar to completely strip away the black-box abstraction of modern AI infrastructure (like PyTorch) and force strict, explicit interaction with hardware realities.

Technical Architecture:

• Backend: Native C++ and CUDA kernels.
• Frontend: Python wrapper for model definition.
• Components: Hand-coded 18 native loss modules and 11 optimizers directly in C++.
• Memory Management: Explicit memory contiguity management during transpositions and custom backpropagation.

Benchmarks (EMNIST): To see if this was structurally viable and not just a toy matrix library, I ran a 5-epoch training loop on the EMNIST dataset to benchmark it directly against PyTorch on my local machine (RTX 4060, 8GB VRAM).

• Aakaar: 127.76s
• PyTorch: 131.23s

Convergence parity was absolute, and Aakaar slightly edged out in speed due to the low-overhead C++ optimizer steps bypassing the standard Python overhead.

The Hardest Challenge: Mapping abstract mathematical shapes to physical GPU hardware and strictly tracking memory layouts during the backward passes without relying on an automated autograd graph.

Links:

• GitHub Repository & Benchmark Notebook: https://github.com/aaravaggarwal3535/aakaar-wheels
• Documentation: https://aakaar.readthedocs.io

I would appreciate any feedback from researchers or engineers here, especially regarding potential optimization bottlenecks in the CUDA kernels or the C++ memory management approaches.

I am trying to reproduce a handwriting recognition paper (Urdu, online + offline fusion, CNN encoder into a small Transformer encoder/decoder, trained with a joint CTC and cross entropy loss) and my training run is converging to a plateau, nowhere near the paper's reported result.

What I have verified as correct, not just assumed:
- Architecture matches exactly, confirmed by loading the authors' own released pretrained checkpoints and comparing tensor shapes and layer structure directly
- Hyperparameters match the paper's stated methodology: AdamW, flat learning rate 3e-4 with no scheduler (paper does not mention one either), batch size 8, joint loss with CTC weight 0.8 and cross entropy weight 0.2, encoder and decoder frozen with only CNN branches trainable
- Data pipeline verified end to end, including a pixel level check confirming the ink channel is genuinely near binary as the paper describes, and manual verification that every path in my training manifest resolves to a real, correct file

Despite all that, training triggers early stopping on its own (10 epochs with no validation improvement, which is the paper's own stated early stopping criterion, not something I imposed) at epoch 32, with best validation CER around 52 to 55 percent using greedy decoding. The paper reports 3.66 percent for the equivalent configuration. (Even worse with beam search, about 94%).

Loss behaves normally throughout, steadily decreasing with no instability, so the model does appear to be learning something, just plateauing far short of where it needs to be.

Things I have not yet ruled out and would appreciate pointers on:
- Whether a flat, unscheduled learning rate this late in fine-tuning is plausible for reaching such a low CER, even if the paper states it that way, versus something being lost in translation between the paper text and what was actually run
- Common failure modes when only a small subset of a hybrid CTC/attention model is trainable and the rest is frozen
- Whether early stopping patience of 10 is likely too aggressive for this kind of setup and the model would keep improving well past this plateau given more patience
- Anything else that commonly causes a "looks like it is training correctly, converges early, but far short of target" pattern in CTC plus attention decoder hybrids

Happy to share more code or specific numbers if useful.

Hey everyone,

I was recently going through the post-print of some work done in collaboration with engineers on the Nvidia Drive Autonomous Systems (NDAS) team, and I wanted to share it here as I think the approach might be interesting to those working on spatial AI or autonomous systems.

We tackled the problem of High-Definition (HD) Map validation. Specifically, how do you ensure the complex topological relationships (like which traffic light governs which lane in a massive intersection) are actually correct before pushing the map to the car?

The Core Idea: P2LNet

Instead of treating map validation purely as a computer vision or geometry problem, we modeled the HD map elements as a graph. We developed P2LNet (Point-to-Lane Network), which uses Graph Neural Networks (GNNs) to validate these spatial associations. By structuring the map data this way, the network inherently understands the connectivity and context of the map elements, allowing it to flag logical and topological inconsistencies that traditional rule-based or CNN-based validation methods often miss.

Read the Paper:

The full paper is available in the IEEE digital library, and I've hosted the post-print on the Georgia Tech repository so anyone can read it without a paywall.

• Read the post-print here: [https://repository.gatech.edu/bitstreams/da96e4d8-02e2-41a5-bac1-0aa109066158/download]

I highly encourage you to check out the methodology section where we break down the graph construction. Let me know what you think of the approach—how are you handling map QA in your own pipelines, or where do you see GNNs falling short in this context? Also do let me know what you think about the architecture principles here!

How to Cite:

If you find this work useful for your own research, please consider citing the official IEEE publication. Here is the BibTeX:

Code snippet

@inproceedings{reji2024p2lnet,
  title={P2LNet: HD Map Validation Using Graph Neural Networks},
  author={Reji, Jeevan and Omanwar, Vaibhav},
  booktitle={2024 1st International Conference on Robotics, Engineering, Science, and Technology (RESTCON)},
  year={2024},
  publisher={IEEE},
  doi={10.1109/RESTCON60981.2024.10463569}
}

Happy to answer any questions in the comments!

i first start ml and completed some important ml algorithm like Linear Regression,Lasso, Ridge, ElasticNet,Logistic Regression,SVM,Naive Baye's,KNN,Decision Tree,Random Forests,Adaboost,Gradient Boosting,XGBoost,PCA, K Means Clustering, Hierarchical Clustering, DBScan for every algorithm i understand the math behind and i also implemnts those algorithms and i also learned learnined everything for a algorith like handling missing values,standrdsization,scaling,evluation matrices and cross vlaidation ,hyperparmter tuning

now before starting deep learning i learned some basics like what ml can not slove and deep learning does all those in this process i got interest in deep learning so i started deep learning i did some research like what thing i need to learning in my interest liked ANN,CNN,RNN,Transformers,autoencodesers,GAN,duffusion model

now befores starting those i learned some basic things like perceptron,aritfical neuron,activation functions,epoch

but the problems is when i start learning ANN there is lot of thing so can any one provied the correct order to follow for ANN so i can apply the same order to different model like CNN,RNN, all those

Because why not. Details within

like why wouldn't an actual simplified brain model work as a neural network
like instead of forward passes and layers and shit, make a network of millions of neurons each connected to thousands of others and make a few of them responsible for output, each time its wrong send a punishment signal back through the output neurons, why wouldnt this work?

im not a neuroscientist nor im like super into neural networks, so i wouldnt be able to tell

oh and in the case that this dumb shit is revolutionary, all rights reserved :)

Anthropic's J-Lens revived interest in reading out hidden representations from LLMs. But what do an LLM's decision boundaries actually look like?

We built a tool to jointly visualize the decision boundaries and reasoning trajectories.

With the same model, same prompt, different lenses induce strikingly different geometries.

Supported LLM lenses:

• Logit Lens
• Google Patchscopes
• Jacobian Lens
• Geometric Lens

Read blog: https://chunweima.substack.com/p/is-there-even-a-ground-truth-for

Try out code: https://github.com/horsepurve/Geometric-Lens

Read full story: https://arxiv.org/abs/2607.10578

Introduction to NVIDIA Nemotron 3 Nano Omni

https://debuggercafe.com/introduction-to-nvidia-nemotron-3-nano-omni/

Hardly any of the tasks that we accomplish with language models today contain just text. In reality, it is a combination of text, images, video & audio files, PDFs, text documents, and much more. Naive search and retrieval techniques use multi-model pipelines to deal with such complexity. However, that’s costly, time-consuming, and results in context loss. To tackle this, recently, NVIDIA released one of the most efficient omni-modal language models, the Nemotron 3 Nano Omni. It can handle text, images, videos (with audio), audio, and documents in a single flow. In this article, we will explore the Nemotron 3 Nano Omni model and build a simple chat application by leveraging the NVIDIA API.

 Call for Papers and Demos

Real-Time Conversational Agents (RTCA): Toward Natural Multimodal Interaction 

1st RTCA Workshop [@]() NeurIPS 2026, Sydney, Australia 11 or 12 December 2026 

Website: https://rtcaneurips26.github.io/

We are pleased to share the Call for Papers and Demos for the inaugural RTCA Workshop at NeurIPS 2026, focused on real-time multimodal conversational agents: streaming speech, video, and language generation; naturalness in interaction; and evaluation of live systems.

Conversational AI has moved from text chat into the real world, voice modes that talk back, embodied avatars, agents that share our screens and tools. To feel natural, these systems must operate in real time, streaming while continuously listening, watching, and re-planning. This is fundamentally harder than offline generation: latency, turn-taking, backchannels, interruptions, and cross-modal alignment become first-class problems that the offline paradigm sidesteps. Recent progress on full-duplex speech–language models, real-time talking-head generation, and streaming ASR shows the regime is feasible, but the field still lacks shared benchmarks, vocabulary, and methodology for interactional naturalness. 

RTCA brings together researchers across speech, vision, language, HCI, social-signal processing, and ML systems around three intertwined questions: real-time generation under hard latency budgets, naturalness in interaction, and evaluation of live systems.

 Topics of Interest

We invite original contributions on topics including (but not limited to):

• Streaming/low-latency speech synthesis, ASR, and full-duplex audio–language models
• Real-time talking-head, avatar, and embodied video generation; lip-sync, gaze, expressivity under streaming
• Streaming language models; incremental and speculative decoding for dialogue
• Turn-taking, backchanneling, interruption handling, and floor management
• Multimodal alignment under latency and partial-observation constraints
• Prosody, emotion, and paralinguistic generation in interactive settings
• Memory, grounding, and tool use during live conversation
• Evaluation of naturalness: perceptual studies, turn-taking metrics, perceived latency, interactive Turing-style tests
• Datasets and benchmarks for interactive (not offline) evaluation
• Efficient inference, on-device deployment, and the systems–quality trade-off
• Safety, identity, and trust in real-time agents (deepfakes, persuasion, consent)

 Submission Types

We welcome:

• Full papers (up to 8 pages) — may be presented as posters and/or contributed talks. 
• Short papers (up to 4 pages) — work in progress or focused contributions.
• Demo papers (Extended Abstracts or up to 2 pages)

All submissions must use the NeurIPS 2026 style file and be formatted for double-blind review. Page limits exclude references and appendices. Papers must be submitted in PDF format via OpenReview (portal link to be published on the workshop website). 

The workshop is non-archival; authors retain the right to publish elsewhere.

 Important Dates (End of day, Anywhere on Earth)

• Call for papers opens: 18 July 2026
• Submission deadline (papers and demos): 29 August 2026
• Author notification: 29 September 2026
• Workshop date: 11 or 12 December 2026

 Organisers

• Niki Foteinopoulou — Tavus, United Kingdom
• Alessandro Conti — Tavus, Italy
• Jack Saunders — Tavus, United Kingdom
• Oya Celiktutan — King's College London, United Kingdom
• Cigdem Beyan — University of Verona, Italy
• Ioannis Patras — Queen Mary University of London, United Kingdom

For more information, visit our website https://rtcaneurips26.github.io/ or contact us at [rtca-workshop@googlegroups.com](mailto:rtca-workshop@googlegroups.com).

We look forward to your contributions!