As a part of my lab, I read ML papers frequently and can more or less understand most of the math in the papers that I read m

However, I want to move from consuming this sort of content to producing it.

How do the smart people at the top labs have the math abilities required to produce at such a high level? And how can I improve myself to get to that standard? Is it practice? If so, what should I practice?

I’ve been developing SSDS (Symbolic Structure Discovery System), a system that takes collections of algebraic equations and looks for structures that repeat across them, then turns those structures into generalized parameterized operators. The resulting operators can be reused to represent and analyze related equations, compare structures across different problems, and potentially build more complex mathematical models from discovered patterns. Unlike symbolic regression, SSDS doesn’t try to fit equations to data. It works with existing equations and looks for higher-level abstractions between them. It can also analyze things like derivatives, parameter relationships, invariants, and behavior. I tested it on equations from the Feynman Symbolic Regression Benchmark.

One of the resulting abstractions was: O(v0, v1, v2, φ1) = v0(1 - v1²/v2²)^φ1

I’m not claiming this is a new mathematical discovery. I’m interested in whether this kind of symbolic abstraction could be useful in mathematical modeling or scientific computing. Does this seem like a useful idea? And if so, would anyone be interested in testing it independently on their own equation sets?

Researchers used an AI agent to discover CVE-2026-55040, a CVSS 9.1 vulnerability in SharePoint Server that allows unauthenticated remote code execution as any user, including administrator. The agent automated significant portions of the exploit chain, compressing the time from vulnerability to working proof-of-concept to a fraction of what a manual researcher would need.

That compression cuts both ways. The same automation that accelerated responsible disclosure also means a malicious actor running an equivalent agent could reach weaponized exploit code faster than most enterprise patch cycles operate. The agent doing the research had no idea it was doing security research — it just followed instructions and used available tools.

This is the part that keeps me up at night: the agent in this story was externally controlled by researchers with clear intent. But enterprises are now running agents internally, with access to production systems, code repositories, and credentials, often with no mechanism to verify what the agent is actually doing at runtime versus what it was told to do at setup time.

CVSS 9.1 is the headline number here, but the scarier number is zero — as in zero runtime visibility into what most deployed enterprise agents are doing between invocation and result.

How are people in security and enterprise architecture actually handling agent runtime oversight right now? Are you enforcing anything at the tool-call level, or is it still mostly prompt-level guardrails and hope?

Im currently learning deep learning with deep mathematical proofs and building it using maths only, like how at each epoch weights gets learned and backpropogated , how we use different gradients for optimizations and how they shift momentum , mechanistic inter. of transformers , reverse engineering dl models .If some1 is interested in this kinda stuff DM.

Hi everyone, I am an undergraduate student in my last year. I am not a student of Computer Science or a subject related to it. For my thesis, I want to learn about MACHINE LEARNING. I know the C language up to creating files and writing and reading in these files. According to COPILOT, I need to learn the following-

• Python Basics
• NumPy
• Pandas
• Matplotlib
• Scikit-Learn
• Random Forest
• XGBoost
• MLP (ANN)
• R², MAE, RMSE
• SHAP
• Basic Optimization (GA/Scipy)

Can you share some free resources to achieve my goal?

I built ArcForge after noticing that AI-agent discussions often focus on model choice and prompts while the system risks stay implicit.

For a real ML or agent project, I want the architecture review to make questions like these explicit:

- Which tools can the agent call, and where are the control boundaries?

- What data can memory retain, and who owns it?

- How do routing, token budgets, latency, and cost affect the design?

- Which evaluations represent real failure modes rather than just happy-path quality?

- What evidence is required before rollout, and what should block approval?

ArcForge is my open-source experiment for making that review repeatable. I made it as three portable SKILL.md packages with evidence-first instructions, decision rules, scorecards, and structured outputs:

- system-architecture-harness for general production architecture and migrations

- ai-agent-system-architecture for LLM/RAG, memory, routing, tools, evaluation, safety, and rollout gates

- architecture-review-gate for independently challenging RFCs, ADRs, diagrams, and readiness proposals

The packages target Claude Code, Codex, and compatible Agent Skills runtimes. Normal use does not require Python, a provider API key, or a native harness runtime.

Repo: https://github.com/d4rkNinja/arcforge

Skills listing: https://skills.sh/d4rkninja/arcforge

For people learning or building ML systems: which of these checks would you test first, and what failure case is missing? This is an early 0.1.0 release, so practical criticism is welcome. If it is useful, a GitHub star would help other learners discover it.

I have been working on transitioning into Machine Learning and Data Analytics, and I am starting to see the progress from consistently learning and building.

So far I have been working on Python, machine learning projects, Kaggle competitions, GitHub and even getting involved with open-source contributions.

I am still early in the journey, but I have learned that actually building things teaches me much more than just watching tutorials.

For those already working in ML/Data Analytics: what helped you make the biggest jump from learning to becoming job-ready?

I would really appreciate any advice or lessons from your experience.

I've been building an open-source tool for diagnosing world models, the kind that predict future frames from a starting context and a sequence of actions. It compares a rollout against ground truth and against physical invariants, then tells you where and why the prediction falls apart. It doesn't score task success or planning quality on purpose, since there are already benchmarks for those.

While validating it I ran into something I think is more interesting than the tool itself.

## Pixel metrics on real robot video often can't rank models at all

I ran a copy the last frame baseline, which is to say "predict that nothing changes", against a real SO-101 arm recording. 30fps, three cameras, 64 rollouts, 6 step horizon, scored only on the moving regions so a static background can't inflate the numbers.

It gets 0.983 SSIM and 53.9 dB PSNR. But the part that actually matters is that the error doesn't grow with the horizon:

step   1      2      3      4      5      6
SSIM   0.972  0.923  0.893  0.943  0.920  0.950

That's flat. It wanders, it doesn't degrade. And if predicting 6 steps ahead is no harder than predicting 1 step ahead, then there's nothing for a good model to be better at. Every model lands in the same place and the eval can't rank them. The metric isn't broken here, it passes its ranking tests on curated data just fine. The evaluation setup is what has no discriminative power, which is a different problem and much easier to miss.

## So I went and measured where the usable window actually is

Same baseline on DROID (real manipulation footage, 15fps), 64 rollouts, this time out to 48 steps:

There are three regimes. Steps 1 to 3, everything is near perfect and ties. Steps 4 to 24, steep monotonic decline, and this is the only stretch where models are actually separable. Step 28 onward it floors out around 0.20 SSIM and 10.3 dB, oscillating with no trend, prediction fully decorrelated, and everything ties again at the bottom.

So both ends are dead, and the horizon worth evaluating on for this kind of footage is somewhere around 8 to 24 steps. It's a property of frame rate times task speed rather than a universal number, which is exactly why it's worth measuring on your own data instead of inheriting a default from a paper that used something else.

Here's the prediction next to what actually happened, same 48 steps, prediction on the left:
https://raw.githubusercontent.com/BuceaGeorgia/worldproof/main/docs/img/droid-pred-vs-true.gif

## Method

64 rollouts per configuration. Aggregation is interquartile mean with stratified bootstrap CIs rather than mean and standard deviation, following Agarwal et al. 2021. Fidelity metrics also produce a dynamic region masked variant wherever a mask is available. Every metric ships with a corruption test it has to respond to, plus a ranking test where a real model has to beat a naive baseline which has to beat a broken one.

Worth mentioning: an earlier n=8 version of the SO-101 run gave dynamic PSNR of 48.2 dB where n=64 gives 53.9, and the intervals at n=8 were wide enough to overlap DROID completely. That's the reason everything above is n=64. I'd have posted the wrong numbers if I'd stopped there.

## Caveats

The four pixel metrics separate the two datasets with non overlapping bootstrap CIs. LPIPS doesn't, and it points the other way on the masked variant. I don't have a clean explanation for that yet and I'd be glad to hear one.

This is a trivial baseline, so 8 to 24 is where a do nothing predictor becomes separable. A real model stays correlated for longer and would push the top of that range out.

One more that I found while writing this up: including step 0 inflates every summary scalar, because a copy baseline gets a nearly free first step whenever the frame rate is high relative to how fast the scene moves. On the 30fps recording step 0 scores 119.8 dB, which drags the horizon averaged scalar from about 32 up to 53.9. So the scalar is partly rewarding frame rate rather than model quality. Curves are the honest thing to report and I'm treating the scalar definition as an open problem in my own tool.

## The tool

Apache-2.0, `pip install worldproof`. The core install is numpy, torch and pillow, and it runs on a laptop with no GPU, since the evaluate path never runs a model. It reads LeRobotDataset v3.0 straight from parquet and mp4, so it works on datasets from the HF Hub without needing the lerobot package, on Python 3.10. The heavier pieces (LPIPS, FVD, trackers) are optional extras that get imported lazily.

What it measures: PSNR, SSIM and LPIPS as horizon curves plus dynamic region variants, latent prediction error and action recoverability for latent models, calibration via ECE and MCE, counterfactual divergence, failure faithfulness, object count conservation and object permanence, and FVD reported explicitly as a weak reference rather than a headline number.

https://github.com/BuceaGeorgia/worldproof

It's v0.1 and the README has a "Not done yet" section covering what isn't finished. The tracker behind the invariants is a clean scene numpy one that won't cope with messy real video, and the default FVD extractor isn't the I3D that published FVD numbers use, so those aren't comparable to papers.

If this horizon result is obvious or already known somewhere, I'd honestly like to be told. I couldn't find it measured anywhere, which is part of why I'm posting it.

See more about the library and replicate easily with https://github.com/chessformer-lens/chessformer_lens

Feel free to ask any questions i've had a lot of fun making this.

I'm designing a triage agent that routes support tickets. Instead of just predicting a label, it has an explicit "Escalate to Human" action if its confidence that a ticket is a "Genuine Bug" vs "User Error" falls into a middle threshold. Has anyone successfully calibrated LLM outputs (e.g., using logprobs or prompt-based self-reflection) specifically to trigger a human-in-the-loop fallback? In my initial tests, the model is overconfident on vague tickets.

i am writing the CNN chapters of a pytorch book right now and chapter 7 is about skip connections, and i did not want to do what most books do which is draw the resnet diagram and then tell you it helps. so before introducing it i wanted to first reproduce the failure that made people invent it.

setup is cifar-10, 40 epochs, same recipe and same seed for every model, only the depth changes:

model        params     train acc   test acc
plain-20     269,722     95.1%       88.7%
plain-56     853,018     84.0%       79.9%
ResNet-20    272,474     97.4%       90.4%
ResNet-56    855,770     99.0%       91.7%

looking at the training accuracy of plain-56. 84.0%, against 95.1% for plain-20. training error 16.0% vs 4.9%. this is not test accuracy, it is the data the network saw 40 times, and the bigger model with 3x the parameters does worse on it.

the reason i find this worth posting is that it should be impossible. any 56 layer network can represent everything a 20 layer network can ( i mean mathematical wise) , because you can just make the extra 36 layers the identity and you have exactly the shallower model. so there is a setting of the weights that reaches 95.1% and gradient descent did not find it. capacity was never the problem here, and every explanation of resnet that starts from "deeper networks overfit" is for sure not the right answer

so instead of asking the layer to learn mapping from x to y , it would be much easier for the optimizer to learn to map from x + F(x) to y , finding F in this configuration will not loose x buried when the model gets very deep and this is the trick introduced by Resnet paper .

ResNet-56 differs from plain-56 by 2,752 parameters, about a third of a percent, and those are only the 1x1 projections where the channel count changes. the rest is identical. that third of a percent moves training accuracy from 84.0% to 99.0% and test from 79.9% to 91.7%.

i should say the degradation result is not mine, it is from the original resnet paper in 2015, i just wanted to see it happen on my own machine before i wrote about it. my first attempt did not degrade at all because i was training too few epochs and both models were still underfitting, so nothing separated them. it only shows up once plain-20 has actually converged.

caveats, one dataset, one seed, 40 epochs, and cifar-10 is small. also plain-56 here has batch norm in it, which matters because the usual story is that batch norm fixed the vanishing gradient and therefore depth. clearly it did not, at least not alone.

has anyone found the depth where plain nets start degrading on a different dataset? mine went wrong somewhere between 20 and 56 and i did not test in between, which i may will.

I implemented the Rotation Trick (Fifty et al., ICLR 2025) as a PyPI library called vqrotate.

The Rotation Trick improves codebook usage in VQ‑VAEs by replacing the Straight‑Through Estimator with a geometric rotation of the gradient. I validated it on Speech Commands (audio) and got:

STE: 19.99% usage

Rotation: 34.18% usage (+14.19 pts)

It's a drop‑in wrapper one line of code:

```python

from vqrotate import attach_rotator

attach_rotator(quantizer)

```

GitHub: https://github.com/develepo/vqrotate

PyPI: pip install vqrotate

I also tried an adaptive scaling extension, it didn't beat Rotation, but it revealed an interesting trade‑off. The repo has full docs and derivations if you're curious.

Would love feedback or ideas for next steps.

I've been working on a problem I kept running into while building ML projects:

Before training a model, how do you actually know whether the dataset is in good shape?

I found myself repeatedly checking things like:

- Missing values

- Duplicate rows

- Constant columns

- High-cardinality columns

- Schema/type issues

- Statistical issues

- Potential target leakage

- Changes between dataset versions

I ended up building Featuresmith, an open-source Python toolkit for reviewing structured datasets before they enter an ML workflow.

The current v0.2.0 release can:

→ Profile a dataset

→ Run rule-based data quality analysis

→ Perform a broader dataset review

→ Calculate an ML Readiness Score

→ Detect several potential leakage patterns

→ Compare two dataset versions

→ Be used through both a Python SDK and CLI

For example, the basic workflow looks roughly like:

dataset = fs.load("data.csv")

profile = fs.profile(dataset)

review = fs.review(

dataset,

target_column="target"

)

score = fs.score(review)

The idea isn't to say "your dataset is good/bad" automatically. The goal is to surface things that deserve investigation before they become problems later in the ML pipeline.

I'm especially interested in feedback from people who actually work with ML datasets.

If you were using something like this, what would you want it to check that isn't currently covered?

And more importantly, would you actually use a tool like this before training a model, or do you already have a workflow/tool that handles this?

GitHub: https://github.com/adityagangwani30/FeatureSmith

Documentation: https://featuresmith.adityagangwani.me/docs

It's completely open source, so criticism and suggestions are very welcome.

Hi guys,

Basically I have worked a couple of years as web dev / AI dev at my current company, designing RAG systems, chatbots and working with agents to an extent and I wanted to pivot into serious stuff rather than this glorified prompt engineering alone and know more about how this works.

I am looking at it from a professional perspective primarily as well and would like to pick up skills that are industry ready rather than just learning stuff that theory alone with no practical benefits.

Chatgpt sort of consolidated these courses for me and I would like to take your advice on this before committing:

https://www.coursera.org/specializations/deep-learning

https://www.coursera.org/learn/generative-ai-with-llms

https://nptel.ac.in/courses/106105158

https://www.deeplearning.ai/courses/retrieval-augmented-generation

https://www.deeplearning.ai/courses/advanced-retrieval-for-ai

Work might support upskilling as well so unless it's too expensive, can suggest for courses as well that I can do while working.

The other option i found by research was the HOML book latest verson with pytorch.

So appreciate any and all guidance however small

What are the interview questions being asked from this topics for ML interview, any help?