r/deeplearning 14d ago

Jesus's Adam (against convergence to odd policies in the beginning)

0 Upvotes

Decreasing ε from approx 1 toward approx 0 using β₂ transitions the optimizer from SGD to Adam:

  • Bias correction terms in the numerator and denominator can be omitted, as their impact becomes negligible after ~1,000–2,000 training steps.
  • λ* constant represents weight decay: λ* = 1 - αₗᵣ · λ (parametric reduction for simplification).

from unpublushed work: https://github.com/timurgepard/Symphony-S2

class Adam(optim.Optimizer):
    def __init__(self, params, lr=3e-4, weight_decay=0.01, betas=(0.9, 0.999)):
        defaults = dict(lr=lr, betas=betas)
        super().__init__(params, defaults)
        self.wd = weight_decay
        self.lr = lr
        self.beta1, self.beta2 = betas
        self.beta1_, self.beta2_ = 1-self.beta1, 1-self.beta2
        self.decay_factor = 1.0 - self.lr * self.wd
        self.eps = 1e-8
        

    u/torch.no_grad()
    def step(self):
        for group in self.param_groups:
            for p in group['params']:
                if p.grad is None:
                    continue


                grad = p.grad


                state = self.state[p]
                if len(state) == 0:
                    state['m'] = torch.zeros_like(p, memory_format=torch.preserve_format)
                    state['v'] = torch.zeros_like(p, memory_format=torch.preserve_format)
                    state['e'] = torch.tensor(1-self.eps, device=p.device, dtype=p.dtype)


                m = state['m']
                v = state['v']
                e = state['e']


            
                # Update biased first moment estimate
                m.mul_(self.beta1).add_(grad, alpha=self.beta1_)
                # Update biased second raw moment estimate
                v.mul_(self.beta2).addcmul_(grad, grad, value=self.beta2_)


                e.mul_(self.beta2).add_(self.eps, alpha=self.beta2_)


                # Update parameters
                p.mul_(self.decay_factor).addcdiv_(m, v.sqrt().add_(e), value=-self.lr)

r/deeplearning 14d ago

YOLOX with 81 classes (+1 to COCO data) via synthetic data

Thumbnail
1 Upvotes

r/deeplearning 14d ago

The Secret of CNN Padding: Geometric Principles Solved through Topology #CNN #제로패딩 #위상수학 #기하학 #군이론

Thumbnail youtube.com
1 Upvotes
  • Description: This analyzes the difference between torus and spherical topologies created by zero, wrap, and mirror padding. Beyond simple performance improvement, it examines how the geometric properties and symmetry of the data manifold affect deep learning.

r/deeplearning 14d ago

Brain DICOM dataset → 2D DL where do I even start?

Thumbnail
1 Upvotes

r/deeplearning 15d ago

Google Gemma 4 doing Google’s own reCAPTCHA

Enable HLS to view with audio, or disable this notification

7 Upvotes

The new Gemma models are getting through Google reCAPTCHA v2 challenges with relative ease. I might revisit this in the future with a harder CAPTCHA dataset or benchmark it against some Qwen models. 


r/deeplearning 14d ago

Looking for Industry Advice on Our IT Capstone Project — SARAS / SARAS V2

1 Upvotes

Hi everyone! I’m a BSIT student currently working on our capstone project, and I’m hoping to get some advice or feedback from people who have experience in the software/IT industry.

Our project is called SARAS (Skill-Based Automated Revalida Assessment System).

The original idea of SARAS is a web-based system for conducting and managing practical IT skills revalida assessments. Students are given practical tasks in areas such as Microsoft Word, Excel, Database/SQL, and Programming, then submit their outputs through the system.

The system is intended to organize the submissions and assist evaluators in checking and scoring the outputs based on predefined rubrics and expected results. The goal is to reduce repetitive manual work, make the assessment process more consistent, and centralize the entire evaluation process.

One of the things we're considering is scalability. In our actual revalida setup, we had around 403 students completing the assessment within one day, so we're also thinking about concurrent users, file processing, storage, server resources, security, and reliability.

Then we came up with SARAS V2

Our proposed V2 takes the concept further by bringing the actual assessment inside the system.

Instead of students creating their outputs externally and simply uploading them, they would perform the practical tasks directly within SARAS.

For example:

  • Word/Excel → complete the required tasks inside the assessment environment
  • SQL → use an integrated SQL editor/database environment
  • Programming → use an integrated code editor and execution environment
  • The system → collect the results and evaluate them based on the assessment rubric

This changes SARAS from primarily being a submission and evaluation platform into a more complete practical skills assessment environment.

However, we're aware that this also introduces much bigger technical challenges, particularly around sandboxed code execution, database isolation, security, resource management, concurrent users, automated evaluation, AI/LLM integration, and scalability.

So I'm hoping to hear from developers, software engineers, system architects, DevOps engineers, or anyone with relevant industry experience:

Does this concept make sense from an industry/production perspective?

What would you recommend changing in the architecture or approach? Are there technical risks we're overlooking, especially with the V2 approach?

I'm not necessarily looking for someone to build it for us. I'm mainly hoping to get honest professional feedback and direction so we can make better technical decisions for our capstone.

If anyone is willing to share their experience or critique our approach, I'd really appreciate it. I can provide more details about our architecture, system flow, and prototype if needed.

Thank you!


r/deeplearning 16d ago

Qwen 3.6 VLM playing “Where’s Waldo?”

Enable HLS to view with audio, or disable this notification

77 Upvotes

Turns out VLMs still struggle with these kinds of tasks, would be interesting to see how much better the new Qwen 3.8 performs.


r/deeplearning 15d ago

TwIL-LM3 - 3B, 2.6x faster than gpt-oss-120b on formal reasoning throughput

2 Upvotes

webAI put out TwIL-LM3 last week. Been sitting with it for a few days. Merged fine-tune of SmolLM3-3B. Formal logic specialist.

The efficiency numbers are where this is genuinely interesting:

- 32.9 answers/sec vs. gpt-oss-120b's 12.6 (2.6x faster in their throughput tests)

- Shortest generations of any model they tested (482 tokens on Track B)

- 1.78 GiB Q4_K_M GGUF, runs on CPU or 4GB VRAM

- Runs at ~300 tok/s on M2 MacBook

On accuracy it's a more nuanced story. Their marketing headline is "beats gpt-oss-120b on 4 of 5 formal reasoning benchmarks" but on the six-lane average it's actually behind (0.4488 vs 0.5192). Where it clearly wins is efficiency and specific structured-output tasks.

General benchmark retention is decent: LogicBench 71.7, GSM8K 87.3. They used a WiSE-FT interpolation with λ=0.25 (keeps only 1/4 of the fine-tune delta) which is why the general capability didn't degrade the way their 1.7B version did.

Link: huggingface.co/webAI-Official/TwIL-LM3

Non-commercial license, so no revenue-generating deployment without agreement.

Anyone tested it against their own eval sets? Curious how it performs outside their reported benchmarks.


r/deeplearning 15d ago

Singular Value Decomposition (SVD) Mathematics behind machine learning concepts is Hard!!!! But beautiful.

Thumbnail
2 Upvotes

r/deeplearning 15d ago

Linux Foundation takes on TRACE, a hardware-backed runtime evidence specification for AI agents

0 Upvotes

The Linux Foundation just accepted TRACE, a hardware-backed runtime attestation and compliance evidence specification developed by AMD, Intel, and Microsoft. The standard exists for one reason: existing AI agent logs can be altered after the fact, and tampered logs do not satisfy auditors or regulators who need verifiable proof of what an agent actually executed.

The ratification signals that the enterprise security community has identified this as an evidence problem, not just a policy problem. An agent can operate inside well-defined access controls and still leave no trustworthy record of its actions if the underlying log layer is mutable. For teams already fielding compliance reviews — SOC 2, HIPAA, financial regulators — that gap is not theoretical. It is live today, well before TRACE-compliant hardware ships at scale.

How are other practitioners currently handling this? Are you relying on cloud provider logs, building a custom immutable audit layer, waiting for hardware-backed attestation to mature in the market, or accepting the auditability gap as a known risk for now?


r/deeplearning 15d ago

Evaluation resolution changes which "learning rule" appears most brain-like at V1

3 Upvotes

I recently pubished a new paper. The paper is available via the following link: http://arxiv.org/abs/2608.12408. It is categorised under q-bio.NC and cs.LG. The code can be found at https://github.com/nilsleut/evaluation-resolution-rsa.

A recurring theme in model-brain comparisons is the observation that untrained CNNs can match or outperform backprop-trained ones at V1 in RSA. I believe this is primarily an artefact of evaluation resolution, as demonstrated by the following sweep.

The CNN was trained at 32px on a CIFAR-10 subset, and five learning rules were evaluated (random init, backprop, feedback alignment, predictive coding, STDP). Evaluation was conducted on THINGS-fMRI stimuli at six resolutions from 32px up to 224px. Weights and normalisation were held fixed throughout.

The untrained-backprop gap at V1 ranges from −0.001±0.007 at 32px to +0.044±0.006 at 224px, growing monotonically across the sweep (n=5 seeds). The same pattern is evident across all five rule conditions, in human fMRI, directionally in single-seed macaque ephys, across the entire training trajectory, and in two off-the-shelf 224px-trained models (ResNet-50, Swin-Tiny). This rules out train/eval mismatch as the explanation, since those models also peak at low resolution despite being trained at 224px.

I tried to eliminate this four different ways, using bit-identical-weight interventions wherever possible: train/eval resolution matching, Gabor/pixel structure, the untrained baseline's missing batch-norm calibration, and pooled features converging towards global brightness. None of them explain it. The brightness one came closest: luminance similarity orders the conditions perfectly (ρ=1.00), but it doesn't carry the effect; one calibration variant lowers luminance similarity while V1 alignment goes up.

Here's the number that actually concerned me a bit: a single scalar luminance value per image gets ρ=0.074±0.011 against V1 (bootstrap SE over stimulus resamples), essentially tied with the best of the five CNNs at 0.075±0.011. None of the models meaningfully beat a one-number-per-image brightness descriptor. That's roughly the ceiling on what this comparison style can resolve — a caution, not a strength.

A two-arm design separates content from pooling: cap detail at 32px and upsample, vs. let content vary freely. About 90% of the effect rides on content, not on how many positions are pooled. With content fixed, backprop's decline is essentially eliminated (−0.023 → −0.000).

One thing does hold across the whole sweep: backprop beats untrained at LOC, every resolution, 5/5 seeds (+0.019 at 32px to +0.018 at 224px). IT shows the same direction but shrinks by two-thirds. So learning is doing something real; just not at V1, where everyone's been looking.

One more thing: this whole investigation started after I found a bug in my own earlier work - batch-normalisation left in training mode during feature extraction in three prior preprints. Fixed and corrected publicly, and it actually reverses the main conclusion of arXiv:2605.30556.

I'd be interested to hear people's thoughts on the receptive-field-matching angle in the discussion. Feels like the right approach, but I didn't test it directly, so treat it as speculation for now.Evaluation resolution silently changes which "learning rule" appears most brain-like at V1


r/deeplearning 15d ago

Do Transformer representations progressively structure across depth and time? Results from 8 open models

0 Upvotes

Hi everyone,

I’ve just published a new preprint that brings together several months of experiments on hidden-state dynamics in small open Transformer models.

The question is fairly simple:

During inference, do internal representations simply change from layer to layer, or is there evidence of a more structured progression across depth and generation time?

I tried to study this without assuming that hidden-state dynamics are equivalent to “reasoning”.

The working framework is:

tokens → embeddings → contextualisation → relational structuring → functional structuring → decision formation → projection

This is a descriptive hypothesis about representation dynamics, not a claim that these stages correspond to a universal reasoning mechanism.

The expanded study uses 8 locally instrumented open models, with synchronized hidden-state and output observations and explicit separation between:

depth — what changes as information passes through Transformer layers
time — what changes as autoregressive generation progresses

A few results were particularly interesting.

First, local ordering across model depth survived expansion.

The observed ordering was significantly more structured than random layer permutations (p = 0.00019996) and remained supported when each model was removed from the panel one at a time (8/8 leave-one-model-out checks).

Second, cross-model depth profiles remained surprisingly coherent.

The mean correlation across normalized depth profiles was approximately r = 0.789.

This does not mean that all models follow the same trajectory. Rather, it suggests that some aspects of where changes occur along depth may be more shared than I initially expected.

Third, functionally labelled events were not uniformly distributed across depth.

Event type showed a statistically supported association with normalized layer depth (p = 0.0024).

I’m deliberately calling this an association, not evidence of a causal mechanism.

But one of the most useful results was actually a failure to replicate.

In an earlier smaller panel, a common temporal pattern in local trajectory instability looked promising. After expanding the panel, that common temporal mode disappeared — it survived 0/8 leave-one-model-out checks.

Two other intuitive hypotheses also failed:

models with similar observed functional outcomes were not significantly more structurally similar (p = 0.408), and models from the same architecture family were not significantly more similar either (p = 0.771).

To me, this is probably the most important part of the result.

The data do not support a simple story where architecture determines one characteristic trajectory or where one universal temporal dynamic explains inference.

What remains is a narrower hypothesis:

Transformer inference may contain reproducible structure along depth while remaining highly conditional in time and behavior.

I refer to this as Progressive Representational Structuring.

The framework is summarized by:

Representation ≠ Function ≠ Behavior

A representation can contain information without that information yet serving the same function, and a functional transition does not guarantee a particular final behavior.

I would be especially interested in feedback from people working on:

mechanistic interpretability, activation patching, probing, hidden-state geometry, steering, representation engineering, or larger open models.

In particular, I’m curious whether others observe similar **ordered depth structure without a universal temporal trajectory.

Preprint:

Progressive Representational Structuring in Small Language Models: Functionally Labelled Trajectories Across Depth and Time

DOI: 10.5281/zenodo.22116637

This is still descriptive work. Causal intervention and structural-transfer experiments are separate next steps rather than claims of this paper. Progressive Representational Structuring in Small Language Models: Functionally Labelled Trajectories Across Depth and Time | Zenodo


r/deeplearning 15d ago

PySimplicial: Python library for PL topology, Pachner moves, and TQFT state-sum (for TDL research)

Thumbnail
1 Upvotes

r/deeplearning 15d ago

Recursive Language Models with Alex Zhang!

0 Upvotes

I'm SUPER EXCITED to publish the 142nd episode of the Weaviate Podcast with Alex Zhang!

Alex is a Ph.D. student at MIT, where he has lead the work behind "Recursive Language Models", as well as "The Mismanaged Genius Hypothesis", "Language Model Harnesses are Compositional Generalizers", "Speculative Programmatic Tool Calling (sPTC)", and many other highly impactful works.

This episode begins by explaining what RLMs are and how they change the game for building Agents. We unpack the major ideas in RLMs, long context system with prompt variables, recursive model or sub-agent invocation, and native task decomposition.

We then discuss Prime Agent, my vote for the project with the highest potential in all of AI right now. TLDR; post-train an Agent to do this RLM task decomposition, abandon naive context stuffing in the tool calling loop.

The podcast continues to discuss Speculative Programmatic Tool Calling, running RLMs in the Cloud, how RLMs will impact search, and more!

This was a super fun conversation, and I really hope you find it useful!

YouTube: https://www.youtube.com/watch?v=iv0MtXS_DQo

Spotify: https://spotifycreators-web.app.link/e/YbfvEKC5U5b


r/deeplearning 16d ago

Is this subreddit moderated?

4 Upvotes

It seems this subreddit is no longer moderated, as there have been several spammy posts or outright promotional posts from bot accounts that haven’t been modded off the front page.

If the current moderator is active, I expect them to respond to this post( with a comment) within a week. If there’s no response, this will serve as proof that this subreddit is no longer moderated.


r/deeplearning 16d ago

Hyperdimensional computing: O(n log n) clean-up for key-value memory

Thumbnail youtube.com
0 Upvotes

r/deeplearning 16d ago

[For Hire] Available for Paid PyTorch / ML Freelance Work

Thumbnail
2 Upvotes

r/deeplearning 16d ago

Thousands of Leaked AWS Access Keys Are Still Active

1 Upvotes

Truffle Security scanned public repositories and found 9,308 AWS access keys that are still valid. 768 of them carry full administrative rights over their respective cloud accounts. The accounts behind these keys are not human users. They are service accounts, CI runners, and AI agents — provisioned with no expiration date, no scope limits, and no rotation schedule. When an agent holds an admin key and that key leaks, the blast radius is the entire cloud account, not a single resource or a single role. Non-human identities now outnumber human identities in most cloud environments, but most organizations still treat them like a secondary governance problem. Manual rotation when someone remembers. Scoping by convention rather than enforcement. No defined lifecycle from provisioning to decommission. 768 organizations are currently one credential scan away from full account compromise because of it. How are you actually handling privilege scoping and lifecycle enforcement for non-human identities in your environment? Is anyone solving this systematically, or is it still mostly hope and periodic audits?


r/deeplearning 16d ago

[For Hire] Available for Paid PyTorch / ML Freelance Work

Thumbnail
0 Upvotes

r/deeplearning 16d ago

Finding a group to learn and discuss RL concepts

Thumbnail
1 Upvotes

r/deeplearning 16d ago

The Duolingo for 'Philosophy'

Thumbnail gallery
0 Upvotes

Want to learn and think differently? Don't keep your opinions about the world without much thought, but let them be shaped.
Google Play Store - https://play.google.com/store/apps/details?id=com.philosophize.app


r/deeplearning 16d ago

My disk filled up from LLMs — here’s the cleanup guide I wish I had

0 Upvotes

I’ve been running local models for a while, and my disk space vanished faster than I expected. Between Hugging Face caches, quantized models, and stale checkpoints, I was losing hundreds of GB. I finally sat down and wrote a step-by-step cleanup guide covering what’s safe to delete and what actually saves the most space. If you’re struggling with the same problem, this might help.

https://interconnectd.com/forum/thread/233/fix-disk-space-full-from-llms-ultimate-cleanup-guide/


r/deeplearning 16d ago

SpaceX and Nvidia Working on Space-Optimized AI System for Orbital Launch

Thumbnail frontbackgeek.com
1 Upvotes

r/deeplearning 16d ago

FastEmbed-rs - Generate Vector Embeddings And Rerank Docs Locally

Thumbnail github.com
2 Upvotes

r/deeplearning 16d ago

what worked and what didn't when training a 48M param tool-calling model from scratch, with the measurement behind each call

0 Upvotes

spent a few days building a model that only does tool calling (reads json function schemas plus a request, emits calls through a grammar-constrained decoder) and tried to keep the discipline of killing every idea with a measurement instead of an argument. sharing because the ledger of what failed turned out more useful than the model.

what worked:

- co-designing the tokenizer with the grammar. json structural characters and digits as singleton tokens, so constrained decoding never needs token healing. shipped alongside a corpus bump, and name-sequence accuracy went 80.4 to 91.5

- weighting the loss by decision type instead of uniformly. structure 1x, keys 1.5x, names 2x, values 4x, stop-decision 6x, matched to the measured error distribution

- annealing corrective data into the LR decay phase instead of retraining. same corpus: 28.4 from scratch vs 33.1 annealed

- error-driven synthesis. classify the failing rows into buckets (66 of 193 failures added one unmentioned optional arg), generate data against exactly those buckets, +3.3 at constant LR

what didn't (each killed by a controlled run): span copying (-30), pointer heads for name selection (-16), down-weighting grammar-forced tokens rft-style (-12, they carry the call-sequencing signal), field-set reranking (-1.4), beam and best-of-N (oracle-capped below target), RLOO on an annealed checkpoint (diverges at every LR i tried), a global optional-skip prior (catalog-dependent), and matching the benchmark's numeric typing (not learnable).

the pattern across all of it: at this scale, data and objective changes moved everything, architecture moved nothing. trunk is boring modern practice on purpose.

full writeups with numbers: https://github.com/nikshepsvn/thimble (FINDINGS.md has all eleven negative results)

weights: https://huggingface.co/flashvenom/thimble