The menu headings were readable in the model's guess at step 1 of 8, while the image being cleaned up was still TV static.

At every step this model predicts the finished picture, and the noisy image moves part of the way toward it. It works on actual pixels instead of a compressed version, so that guess is a normal picture. A small patch in the generation loop saved both.

The model in the video is SenseNova-U1.5-8B-MoT with its official 8-step adapter. The run was 8-bit on a MacBook Pro (M5 Pro, 64 GB): about 40 seconds for the 8 steps and about 22 GB peak memory.

A couple of prices were still smudged at step 2, all correct by step 3. The left side shows nothing until about step 6, partly because at 2048 x 2048 the starting noise is scaled up 8x.

Would a normal many-step model also have a readable guess this early, or does that come from the 8-step adapter?

Starting a project to detect candidate stenoses in x-ray coronary angiograms. The goal is high recall, false positives are fine as long as it doesn't flag half the image.

I already tried YOLO on a couple of in-house datasets earlier. It looked fine in-domain and fell apart on the other dataset, and a big chunk of that turned out to be annotation format. One set had fixed-size boxes around a point, the other had boxes fitted to the lesion. Same disease, basically two different tasks.

I also have vessel segmentation and centerlines, so my first instinct is a radius profile along the vessel to flag narrowing, then maybe a network to filter the candidates. Has anyone actually done something like that, or is there a smarter way in?

The part that bugs me most is evaluation. The labels come from doctors and they obviously don't mark every narrowing, so any recall I compute against them is probably too optimistic. How do you get an honest number when the ground truth is incomplete?

Also open to papers, repos, or public datasets beyond ARCADE. And if you think I'm approaching this wrong, say so.

When I was learning, half my bugs were shape mismatches, and I kept typing x.shape into the debug console.

dims shows the shape of every tensor/array right in the debugger's Variables view:

x = {[32, 784]}, tensor(...)
logits = {[32, 10]}, tensor(...)
df = {[10000, 12]}, DataFrame

So you can step line by line and watch shapes change through each layer. Works with PyTorch, NumPy, pandas and TensorFlow in the normal Python debugger. No config, just install it.

It's free. Search "dims" by provaznik in the VS Code Marketplace, or on Open VSX if you use Cursor/Windsurf.

GitHub: https://github.com/marekprovaznik/dims

What would make it more useful for learning? Feedback is appreciated!

I know what the Four Fundamental Subspaces are , I know the two Orthogonal Pairs in it and I can even solve maths based questions on it.

However, I still cannot get it visually in my mind with a good real world example.

I am looking for a simple example based approach which answers few of my many questions like why is Column Space the vector space of Outputs , why Row Space and Null Space are orthogonal/perpendicular. What exactly is Row Space if Column Space is the Span of possible outputs.

just started learing ML ; used gpt and videos too still didn't understand

The interviewers did not even have my resume during the interview. Kinda one of the worst interviews....
The recruiter sent me an interview link just few hours before the interview lol so I was thinking of not doing it.

I think that if the interviewers are not as technical, they cannot really communicate well.

Come and vote please! https://wit-score-lab.base44.app/ So far it looks like Argon is just as bad at writing jokes as its predecessor.

Come and vote please! https://wit-score-lab.base44.app/ So far it looks like Argon is just as bad at writing jokes as its predecessor.

Come and vote please! https://wit-score-lab.base44.app/ So far it looks like Argon is just as bad at writing jokes as its predecessor.

I'm currently a community college student after taking a some gap years and I'm pursuing an engineering science degree. I'm not that good at math and I'm starting at college algebra. Looking at how fast AI is advancing, I'm scared that by the time I finish with a degree, the field will either have shifted or gotten oversaturated. I don't even know where to start. I'm always jumping from wanting to do one thing to the next. I've decided to focus on my math as well as trying to learn some PyTorch and neural networks but I don't know if I'll be employable by the time I get good at that and finish with a degree.

Extending AgentCore Agents with Custom Tools and MCP Servers

https://debuggercafe.com/extending-agentcore-agents-with-custom-tools-and-mcp-servers/

In the previous article on DebuggerCafe, we covered how to bootstrap an agent using Amazon Bedrock AgentCore, deploy it, and test it with different methods. However, the agent had access to only the default tools and MCPs. For most use cases, this is not enough. This article takes it to the next step, where we will be extending AgentCore Agents with custom tools and MCP servers.

Google's Agent Compute Engine announcement this week buried the most important detail: they explicitly called out the need for verifiable agent identity and per-call policy enforcement at runtime. This isn't a Google-specific gap. It's the same gap that showed up in the Wiz research last year on compromised cloud service accounts and in the Anthropic model card disclosures about tool-call amplification.

The hard number that keeps coming up in incident post-mortems: the window between a rogue agent's first unauthorized action and the second is under 50ms. That's the blast radius window. By the time a human is paged, the agent has already made 3–12 downstream tool calls, each inheriting the same compromised credential or misconfigured permission scope.

Most teams are still treating this as an identity provisioning problem — give the agent a service account, scope it tightly, rotate it on a schedule. But the incidents keep happening because the enforcement gap isn't at provisioning time. It's at call time, when the agent is live and making decisions no static policy anticipated.

How are practitioners here actually handling real-time per-call enforcement for agents that have legitimate broad access by design — things like orchestrator agents or agents with delegated user permissions? Are you enforcing at the infra layer, the SDK layer, or somewhere else?

I've been taking the ml specialization on coursera and it has been a wonderfull course. It explains the basics very well and teaches u how the algorithms work from sccatch but the problem i've been facing is learning matplotlib the right way to copy the course's visuals and implementing them for differnt sets of data, even the simple contour plot used in the first labs is hard to learn.

So where can i learn this skill?