I've been curious about a particular learning gap.

Sometimes it's relatively easy to understand what an ML algorithm is trying to achieve, like finding similar items, making predictions, or reducing errors.

But then vectors, matrices, dot products, projections, or equations enter the picture, and suddenly maths we last encountered in school reappears in a completely different setting.

We might understand the purpose of the algorithm without quite understanding why those particular mathematical operations are needed in the first place.

I'm curious:

\-Have you experienced this disconnect, even after learning to code or use ML libraries?

\- Was the harder part understanding the maths itself, or connecting it to what the algorithm was doing?

\- What eventually helped things click, if anything?

I'd love to hear different experiences, including from people who didn't encounter this difficulty.

For People who can ignore my mis understanding or lack of knowledge and help here, please let me know if one would plan to use distillation to train a smaller model for solve agentic coding task and tool use, how can one go about it, like a loose plan or detailed arch anything would help, the 2 student models are 32b and 4b in size , and I don't understand how to select a teacher model for these or how to go about to even plan it,

sorry if my question lacks some information but I can try to furbish more info as it is needed, tbh as of now I am totally second guessing and figuring out things as I go forward

I am a published AI/ML researcher and engineer looking to collaborate on representation learning or agent research with a team that can support GPU compute and LLM API benchmarking.

My experience spans neural networks, privacy-focused machine learning, model fine-tuning and reproducible experiments. I have also built tool-using agents and evaluation workflows. I can contribute research design, implementation, baselines, experimental analysis and writing.

A question I would enjoy exploring is how different learned or structured representations influence generalization under distribution shift, with matched baselines and careful ablations. I am also interested in agent planning and tool-use reliability, and open to an existing research direction.

If you are part of a lab or team with the resources to benchmark, please comment or message me with your topic and available resources. I can share relevant work privately.

LingBot-Touch targets a representation-learning problem that is specific to tactile robotics: piezoresistive, magnetic, and visuotactile sensors encode contact through different physical signals, making it difficult to reuse tactile understanding across hardware. The paper presents a shared tactile representation, emitted as tokens that can be supplied to downstream manipulation policies.

The authors report integrating these tokens with both diffusion policies and vision-language-action models, including π0.5 and LingBot-VLA. They describe evaluations in simulation and on real robots across multiple hardware platforms, with improvements in dexterity and computational efficiency. That breadth makes cross-sensor transfer more central here than simply adding another tactile input to one controller.

The abstract does not give task-level scores, baselines, or details of how a new sensor type is incorporated, so it is hard to judge the magnitude and generality of the gains from the available information. Still, the idea of treating touch as a reusable learned modality across sensor physics and policy families is a useful representation-learning direction for embodied systems.

Full summary on AIModels.fyi

Original paper

Disclosure: AIModels.fyi is my site.

ShadeNet v5 is out!!!

ShadeNet v5 is a 35M-parameter feed-forward network built on a frozen DINOv2 ViT-S/14 backbone. In a single forward pass, it takes one RGB image and predicts three maps: albedo, relative depth, and surface normals.

• Live Demo (no install):https://huggingface.co/spaces/singam96/ShadeNet-5

• Weights, Model Card & ONNX:https://huggingface.co/singam96/ShadeNet-5-35M

What’s new and notable:

• Distilled single-pass refiner (0.91M UNet): Test-time augmentation (averaging 6 passes across flips and ±4° rotations) noticeably improves quality, but at 6x the compute. To bypass this, I trained a tiny UNet to predict the 6-pass ensemble output from a single pass. Because the model's own 6-pass output acts as the ground truth, training required zero labels—just ~8,000 CC BY 2.0 photos from Open Images. On a 23-image held-out set, it drops mean L1 error from 0.1757 to 0.1673 (full 6-pass is 0.1628), capturing ~65% of the ensemble gain at ~20% of the compute cost. Most of the improvement shows up in the surface normals, while depth sees minimal change.

• Lightweight CPU inference (ONNX): The base model exports to a 31 MB 4/8-bit quantized ONNX file, or a single 35 MB bundle with the refiner baked in. CPU inference takes ~1.0s for a single pass and ~1.3s with the refiner (scoring 0.1676 L1 vs. 0.1755 without the refiner).

Current limitations:

• No shading channel: Unlike v3.2, v5 does not output a separate shading map.

• Relative depth: Depth predictions have per-image scale and shift.

• Fixed ONNX resolution: The exported ONNX graphs currently require a fixed 448×448 input.

J'ai développé une IA neuro-symbolique appliquée à ARC AGI 2, basée sur le DSL de Hodel en Python : https://github.com/Julien-Livet/arc-dsl. . La méthode est expliquée ici : https://julien-livet.github.io/aicpp/. . Je ne suis pas expert en réseaux de neurones et je n'ai reçu aucun retour technique ou scientifique sur mon travail. Auriez-vous des observations ou des idées à me faire part ?

Title: Trying to make xLSTM's sLSTM run in parallel — my PPLSTM prototype

I've been spending today exploring different mathematical ideas to see if it's possible to make xLSTM's sLSTM run in parallel without losing what makes it useful.

One of my more interesting experiments is PPLSTM , a prototype that explores a different way of handling the sequential memory calculations.

It's still early days, and I'm not claiming to have solved anything yet. I'm mainly experimenting to see which ideas actually work.

Some early results:

GPU speed test (batch 2, sequence length 1,024):

mLSTM + standard sLSTM reference: 1,200.31 ms

mLSTM + PPLSTM: 43.59 ms

Transformer: 10.50 ms

That's around 27.5× faster than the unoptimized Python-loop sLSTM reference. It's not a comparison against the official optimized xLSTM kernels.

5M-token language-model experiment (small models, one seed):

sLSTM: 51.43 test perplexity

PPLSTM: 54.50 test perplexity

Transformer: 58.90 test perplexity

So PPLSTM is showing some promise, although standard sLSTM still performed better on the test set.

An important detail: PPLSTM currently uses ordinary PyTorch. There are no custom CUDA kernels, Triton kernels or CUDA Graphs in the implementation yet. PyTorch still uses GPU kernels internally when running on CUDA.

PPLSTM GitHub: https://github.com/rickey1990/PPLSTM

I've also made some of my other repositories private for now, as I'm working on new ideas that combine different areas of maths I've explored across my projects.

Currently waiting for my free Kaggle GPU allowance to reset so I can run some proper tests. Fingers crossed! 🤞

Footnote: I've also been experimenting with PHSMLP (Pooled Head MLP), which explores sharing MLP weights and pooling attention heads to reduce model parameters.

PHSMLP: https://github.com/rickey1990/PHSMLP---Pooled-Head-MLP

Other projects: https://github.com/rickey1990

A Denver city audit found employees at City Hall and Denver International Airport actively using AI tools the organization had never approved. There was no policy enforcement in place. There was no enterprise-level visibility into what was running. No one at the organization knew until the auditors showed up.

This is not a scrappy startup. This is a municipal government and a major international airport handling sensitive passenger data, infrastructure systems, and city records.

The audit found no formal process for evaluating or approving AI tools before deployment. The gap was structural, not a one-off lapse. The organization could not tell you which tools were active, who was using them, or what data they had touched.

For those working in regulated or high-stakes environments: how are you actually getting ahead of this before an external audit surfaces it? Not policy documents, but what has worked operationally at scale?

New research highlighted today describes a virtual model that assists Wi-Fi 7 in making decisions in crowded networks, learning how to allocate resources where traditional rules struggle. It is a small example of a bigger shift: machine learning moving from the application layer into the infrastructure underneath it.

Why it matters: wireless networks are getting denser and more complex, and hand-tuned rules do not scale with that complexity. If learned models can manage spectrum and congestion better than fixed heuristics, the same approach could spread to other infrastructure, from power grids to traffic systems.

What infrastructure problem do you think learned models will take over next, and where should the line be between a model that assists and one that decides?

For more AI news and rumors, check out r/AINewsRumors.

The Society for Neuroscience highlighted new work today on using AI to accelerate neuroscience research, from analyzing complex brain activity recordings to modeling neural circuits. It follows a run of related work, including AI turning patterns in visual brain activity into pictures, which suggests the field is moving from describing the brain to decoding it.

Why it matters: neuroscience has long been bottlenecked by the sheer complexity of its data. Deep learning can find structure in recordings that humans cannot see, and that could speed up everything from basic research to brain-computer interfaces. It also raises the stakes on interpretability, since a model that decodes the brain is only useful if researchers can trust what it found.

What application of AI to neuroscience excites you most, and what do you think is the biggest risk when the models start finding patterns researchers cannot explain?

You can follow more AI news and rumors over at r/AINewsRumors.

When an employee's badge gets deactivated on their last day, the AI agents they provisioned keep running.

TechTarget documented a systematic offboarding gap: HR tracks headcount, IT manages accounts it already knows about, and managers know which tools a person used. None of those systems talk to each other. AI credentials provisioned by a departing employee sit outside all three workflows. They stay active long after the person is gone — often weeks or months before anyone notices.

Those agents don't sit idle. They continue making API calls, accessing data, and triggering workflows under the authority of a principal who no longer works there. The organization has no way to know what they're doing or on whose behalf.

How are you actually closing this loop at your org? Manual offboarding checklist, automated credential sweep, something built into your IdP, or something else entirely?

This year I started focusing on developing my skills in deep learning. I've been taking online courses, studying the fundamentals, and working on small projects to put what I've learned into practice.

I'm also in my final year of Software Engineering, and I decided to challenge myself by choosing a graduation project that's heavily focused on deep learning.

The problem is that I don't really know anyone who specialises in this field. I even asked around among my classmates, but couldn't find anyone interested in working on a deep learning project. So I've ended up doing the whole project on my own. I don't really have a mentor either, since my supervisor's background is in computer science rather than AI.

Because of that, I've been relying quite a lot on ChatGPT to help me write code and figure out how to approach different parts of the project.

And this is where I'm struggling. Sometimes I reach a point where I genuinely don't know what to do next, and I feel like ChatGPT is doing most of the work instead of me. I try not to blindly copy the code. I constantly ask why it chose a particular approach, what each function does, and what concepts I should review before moving forward.

I've even started watching Stanford's deep learning lectures to strengthen my understanding, but a lot of the material is theoretical, and I still struggle to connect what I'm learning to actually building something.

Then I open LinkedIn and see people constantly saying that you need to learn how to code from scratch, that AI is making people dependent on tools, and that the developers who will survive in the future are the ones who truly understand how to write code themselves.

I genuinely enjoy deep learning and I want to understand what I'm building.

So, for those of you who work in deep learning or have been through something similar, how did you learn to build projects independently?

How do you balance using AI tools to help you learn without becoming too dependent on them? And how do you bridge the gap between understanding the theory and actually knowing what to implement next?

I'd really appreciate some advice, especially from people who had to learn without much guidance or mentorship.

Paper: https://www.alphaxiv.org/abs/2611.17334

X threads (with videos):

• https://x.com/choang333/status/2121335484236386574

• https://x.com/_ellisbrown/status/2121335477244428419

Blog and FAQ: https://unbundling.github.io

New paper from Meta FAIR and NYU! Labs disagree on vision encoders right now: Gemma 4 12B scrapped the encoder, Kimi K3 dropped encoder pretraining, and Inkling 2 Small brought the encoder back. Published models differ in data, compute and whether encoder pretraining is counted at all, so they can't settle it.

This paper runs a large controlled study to help shed light on the debate, with 200+ models trained from scratch, LLM included, on the same data, with encoder pretraining charged to the same lifetime compute budget, changing one design choice at a time. Findings (VQA after instruction tuning, 1B to 6.4B models):

1. Encoder pretraining is optional. Four pretrained encoders (contrastive, self-supervised, captioning) at best tie an encoder trained from scratch with the LLM at matched compute. Even with pretraining compute not counted, longer MetaCLIP pretraining raised ImageNet linear-probe accuracy from 80.4% to 84.4% and didn't improve VQA.

2. Vision-only parameters are not optional. Encoder-free models trail at every size and need about 3x the compute to match the encoder. Giving the encoder's parameters to the LLM instead improves text benchmarks but not VQA.

3. Those parameters don't have to be an encoder. Vision-only weights added to the LLM's early layers ("in-fusion") are on par with a separate encoder from 1.7B to 6.4B, with about 13% lower time to first token.

4. The conclusions hold when adding vision to a pretrained 1.7B LLM.

Disclosure: I'm one of the authors. Happy to answer questions!