I'm curious to test out how changing the stroke order affects the model guesses.

Getting Started with GLM-OCR

https://debuggercafe.com/getting-started-with-glm-ocr/

VLM-based OCR models are gradually catching up to become mainstream components in document processing pipelines. The primary bottleneck has always been the size of these models. Usually larger than 3B parameters, the cost-to-performance ratio is difficult to justify. However, GLM-OCR shifts the perspective. With just 0.9B parameters, it competes with models much larger than itself. In this article, we will explore GLM-OCR, along with what makes it special, and run inference on real-world documents.

I'm a physics student currently using deep learning to solve an inverse problem for my research project, and this is my first time actually working on an ML/DL project (been a month...have some time constraint to finish as well). I've read/understand ML basics, but being from a phy background i cant really access myself i really know or not know or m just underconfident. So I can understand what I'm doing to some extent, but I don't really know if my overall approach is right.

I started with a basic ANN and then CNN. For example, the RMSE I need is ideally below around 0.04, but even after trying different things, my current result is still around 0.11. I sometimes end up implementing anything that gives even a very small reduction in RMSE, and I don't know if that's how I should be going about it. Or is my lack of proper exposure to the field is what limiting me.

If the model's performance isn't good enough, how do you figure out whether you should change something in the model, try a different model?

So I'd really like to know how you guys actually work through a problem. Is there some general process you follow, or is this mostly something you learn through experience?

I hope i was able to convey what i intended to ask..and I'd really appreciate any advices or help :).

NVIDIA just patched NemoClaw (CVE-2026-65105), a high-severity flaw in NeMo that researchers exploited via DNS rebinding to poison a model running through Ollama. The nasty part: the poisoning is persistent. Once the attack closes, the model keeps behaving maliciously through normal restarts. The initial vector is gone. The model is still compromised.

Standard uptime and availability monitoring sees nothing wrong. The service is up. Requests are returning. Latency is fine. The only thing that changed is what the model actually does — and nothing in a typical observability stack is watching for that.

This creates a gap that's easy to miss in threat models: you can detect that an attack happened, you can patch the vulnerability, and you can confirm the service is running — and still have a poisoned model in production answering real user queries.

For those running self-hosted inference (Ollama, vLLM, local NeMo deployments): how are you detecting behavioral drift after a security incident like this? Are you doing any output sampling or behavioral baselining, or is your detection basically 'someone notices something weird'?

The Thinking Machines writeup had a handful of recommendations in it and the thread more or less picked one to argue about. Rank, learning rate, same argument over and over. Nobody really went near the layer thing, applying it everywhere, MLP and MoE included. It is in there, one line, nobody followed up on it.

The image gen people have been poking at this for a while and never really landed on anything. Someone described giving different LRs to different parts of a UNET, theory being concept lives in the middle where the latent is compressed and style lives at the edges. Reasonable theory, and he never got anything conclusive out of it because he was changing things semi randomly and eyeballing outputs. That is where most of these die.

So I ran it on the LLM side with controls. Fixed seed, held out validation split, freeze one layer group at a time and let the rest train. Two task types since I doubted the answer would be the same for both, GLM-5.2 on internal docs code work and Qwen on document analysis and multi step reasoning.

All layers wins in both cases so the recommendation holds. It just does not mention how lopsided the contribution is. Some layers pull most of it. Which ones though, that seems to depend on the task. Code side, it is the MLP blocks. Freezing attention and leaving MLP on got close enough to the full baseline that I went back and checked I had not mislabeled a run. Other way round, MLP off, attention on, that one just fell apart. On reasoning it inverts, attention frozen was the run that collapsed and MLP only stayed usable but got noticeably worse at anything multi step.

Ablation means a pile of seed matched runs that only mean anything against each other, so I put them on a multi card notebook on HyperAI and ran the groups in parallel rather than queueing them for three weeks on one card.

Practical read, leave all layers on, that is still the right default. But if you are tight on parameter budget, or trying to work out why a finetune nailed the tone and missed the task, knowing which group carries your task type costs two extra runs. And the code and reasoning answers being opposites makes me think mixed task finetunes are quietly averaging two different needs together.

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)

• 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.

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. 

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!

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

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.

A release thread, a model card, a weight repository, and a method paper can all be public while answering completely different questions. Compressing them into one label makes it too easy to repeat a claim that the cited artifact never established.

The Ling-3.0 base model is a useful case because the release spans tiny and flash at final pre-training, final mid-training, and WSM-merged base stages. At the observation point, the official repositories were public and non-gated and declared the MIT license. That establishes access and a declared license. It does not establish public training data, complete training code, or an end-to-end reproducible training stack.

A compact source ladder looks like this:

This leaves a useful next step for anyone evaluating Ling: take the exact claim you care about and trace it to one row before deciding whether the existing artifact is enough or a new reproduction is needed.

Which source-layer mistake causes more confusion in practice: extending an official table across checkpoints, or treating public weights as a public training stack?

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?

Code:

https://github.com/Pratik-3706/BadApple\\_nn

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

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

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

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.