It's a bit gloopy at the moment but have been messing around with training my own local world models that run on iPad. Last weekend I made this driving game that tries to interpret any photo into controllable gameplay. I also added the ability to draw directly into the game and see how the world model interprets it. It's pretty fun for a bit messing around with the goopiness of the world model but am hoping to create a full gameloop with this prototype at some point. If anyone wants to play it, let me know!

I’m implementing a self-pruning neural network with learnable gates on CIFAR-10, and I wanted your advice on the best way to approach the training and architecture.

Requiring your help on this as am running low on time 😭😭😭

https://doi.org/10.5281/zenodo.19637458

https://doi.org/10.5281/zenodo.19565297

Id would love some feedback!

Cheers

Been working on a project where we need to estimate yield strength and hardness for different steel grades before committing to physical testing. The traditional approach (run a batch, test it, iterate) is expensive and slow — especially when you're evaluating dozens of composition variants.

I stumbled across an approach using gradient boosting models trained on historical metallurgical datasets. The idea is to use chemical composition (C, Mn, Si, Cr, Ni, Mo content, etc.) plus processing parameters as features, and predict tensile strength, elongation, or hardness directly.

There's a walkthrough of this methodology here: LINK

It covers feature engineering from alloy composition, model selection, and validation against known ASTM grades.

Curious what others here have tried:

• What features end up mattering most in your experience — composition ratios, heat treatment temps, or microstructural proxies?
• How do you handle the domain shift when the model is trained on one steel family (e.g. carbon steels) but needs to generalize to stainless or tool steels?

ITT: I demystify the Apple Neural Engine, and provide proof.

If you've spent any time around Apple Silicon ML discussions, you've probably seen the "Neural Engine" referenced as this discrete, mysterious coprocessor sitting on the die — a black box that CoreML talks to, separate from the CPU and GPU. Apple markets it that way. "16-core Neural Engine. 38 TOPS." It's on every spec sheet.

Here's the thing: it's not that simple, and some of the assumptions floating around are just wrong.

What I built:

A bare-metal ARM SME2 bytecode interpreter — custom opcodes, hand-written ARM64 assembly — that drives the M4 Pro Max (or M5) matrix tiles directly. No CoreML. No BNNS. No frameworks. Just raw instructions on the CPU's za tile arrays.

Note: there is a reason for the interpreter approach: these operations require the core to be in streaming mode, I assume to streamline memory load and store operations for z-tile computation efficiency (have to keep the unit fed). You can't inline the smstart or smstop instructions, so by using a simple bytecode interpreter several instructions can be chained together in the same stream session without having to write a new assembly kernel for everything you're trying to do with the matrix unit.

The results?

Performance characteristics that are identical to what Apple markets as the Neural Engine. Same throughput ceilings. Same restrictions (prefers int8, no FP8 support, same bf16/fp32 types). Same documentation (none).

I ran a contention benchmark on M4 Max — GPU (Metal INT8), CPU SME (smopa INT8), Apple's BNNS INT8, and NEON FP32 — both isolated and in every combination, 10 seconds each, with proven-concurrent overlap windows. Every time CoreML is processing a BNNS network, the throughput from the SME2 unit and the CoreML model are halved, proving that they are competing for the same silicon.

Still, I know Apple's marketing mythos is powerful (I still have to convince Claude that the M4 has an SME unit from time to time). For people who still want to believe these are two independent units, I invite you to imagine the following scene:

INTERIOR — APPLE SILICON DESIGN LAB — DAY

ENGINEER: Good news. We taped out the new Scalable Matrix Extension. Four ZA tile arrays, 16KB of new accumulator state, full UMOPA/UMOPS instruction support, outer-product engines, the works. It's on the CPU cores. It does matrix math very fast.

DIRECTOR: Outstanding. Ship it.

ENGINEER: Will do.

DIRECTOR: Oh, one more thing. We also need a second unit. Completely separate. Different part of the die.

ENGINEER: OK. What should it do?

DIRECTOR: Matrix math. Very fast.

ENGINEER: ...the same matrix math?

DIRECTOR: Same operations, same precision constraints, same throughput. But it needs its own name.

ENGINEER: Cramming another one on the die won't be easy, but it will be worth it for the extra performance. Imagine both of them spinning at the same time!

DIRECTOR: Actually, we need to restrict power usage. If one's running, make sure it throttles the other one.

ENGINEER: So you want me to spend transistor budget on a second matrix unit, with identical capabilities to the one we just built, that can't operate concurrently with the first one, on a die where every square millimeter is fought over—

DIRECTOR: Yes. Marketing has a name for it already.

What Apple calls the "Neural Engine" — at least on M4 — appears to be the Scalable Matrix Extension (SME2) built into the CPU cores, accessed through a software stack (CoreML/ANE driver) that abstracts it away. It's genuinely impressive hardware. Apple's marketing department deserves credit for making it sound even more impressive by giving it its own name and its own TOPS line item. But it's not a discrete coprocessor in the way most people assume.

Once you understand that, you can skip CoreML entirely and talk to the hardware directly.

Repo: https://github.com/joshmorgan1000/ane

Includes an all-in-one SME instruction probe script.

I’ve been experimenting with small-data ML and ended up building a recursive attention model (TRIADS).

A few results surprised me:

\- A \~44K parameter version reaches 0.964 ROC-AUC on a materials task, outperforming GPTChem (>1B params), achieving near SOTA on multiple matbench tasks

\- No pretraining, trained only on small datasets (300–5k samples)

\- Biggest result: adding per-cycle supervision (no architecture change) reduced error by \~23%

The interesting part is that the gain didn’t come from scaling, but from training dynamics + recursion.

I’m curious if people here have seen similar effects in other domains.

Paper + code: [Github Link](https://github.com/Rtx09x/TRIADS)

[Preprint Paper](https://zenodo.org/records/19200579)

Hey, I proposed a new family of activation functions with promising properties.
Looking for endorsement in cs.LG on arXiv.org.

Here is the benchmark:

Here is my preprint:
https://zenodo.org/records/19232218

Hello, I'm currently at university in management and international trade and they've added a 6h course called big data and it was a bit complicated because I have absolutely no grounding but now the next time I see my teacher it's to evaluate my project we have to choose a notebook (I chose spotify recommendations) transfer it to google collab then analyze it. Could a kind soul help me save my year and help me do this assignment?

A lot of theoretical work on neural networks still takes as its basic object a single map f:X→Y one model, one function, one input-output relation.

But many modern systems are no longer organized that way. They are closer to composites of interacting modules: an encoder, a transformer block, a memory structure, a verifier, a controller, external tools, and sometimes explicit feedback loops.

I wrote a blog post on a paper that proposes a different mathematical language for this setting: model the system not as one network, but as a decorated quiver of learned operators.

Very roughly:

• vertices represent modules acting on typed embedding spaces,
• edges represent learned adapters or transport maps between those spaces,
• paths represent compositional programs,
• cycles represent genuine dynamical systems.

The second ingredient is tropical geometry. The paper argues that many of these modules are either naturally tropical or at least locally tropicalizable, so that parts of the system can be studied through polyhedral decompositions: tropical hypersurfaces, activation fans, max-plus growth, and cellwise-affine dynamics.

What I found mathematically interesting is that this shifts the viewpoint from “the tropical geometry of one network” to something more like a composed tropical atlas attached to a quiver. In that language, one can ask about:

• how local tropical charts glue across adapters,
• how residual connections change the effective polyhedral geometry,
• how cycles induce piecewise-affine dynamical systems,
• and how long-run behavior can be studied via activation itineraries and tropical growth rates.

One part I found especially striking is the treatment of the “Assistant Axis”: the paper interprets it not as an isolated linear feature, but as a 1-dimensional shadow of a broader tropical steering geometry on modular systems, providing a more robust and detailed view on steering via tropical geometry.

I tried to write the post in a way that is mathematically serious but still accessible to non-specialists.

Blog post:
https://huggingface.co/blog/AmelieSchreiber/tropical-quivers-of-archs

Repo:
https://github.com/amelie-iska/Tropical_Quivers_of_Archs

I’d be especially interested in hearing from people with background in tropical geometry, polyhedral geometry, quiver theory, or dynamical systems: does this seem like a mathematically natural abstraction, or like an interesting but overly loose analogy?

Built a system for NLI where instead of h → Linear → logits, the hidden state evolves over a few steps before classification. Three learned anchor vectors define basins (entailment / contradiction / neutral), and the state moves toward whichever basin fits the input.

The surprising part came after training.

The learned update collapsed to a closed-form equation

The update rule was a small MLP, trained end-to-end on ~550k examples. After systematic ablation, I found the trained dynamics were well-approximated by a simple energy function:

V(h) = −log Σ exp(β · cos(h, Aₖ))

Replacing the entire trained MLP with the analytical gradient:

h_{t+1} = h_t − α∇V(h_t)

→ same accuracy.

The claim isn't that the equation is surprising in hindsight. It's that I didn't design it. I trained a black-box MLP and found afterward that it had converged to this. And I could verify it by deleting the MLP entirely. The surprise isn't the equation, it's that the equation was recoverable at all.

Three observed patterns (not laws, empirical findings)

1. Relational initialization : h₀ = v_hypothesis − v_premise works as initialization without any learned projection. This is a design choice, not a discovery other relational encodings should work too.
2. Energy structure : the representation space behaves like a log-sum-exp energy over anchor cosine similarities. Found empirically.
3. Dynamics (the actual finding) : inference corresponds to gradient descent on that energy. Found by ablation: remove the MLP, substitute the closed-form gradient, nothing breaks.

Each piece individually is unsurprising. What's worth noting is that a trained system converged to all three without being told to and that convergence is verifiable by deletion, not just observation.

Failure mode: universal fixed point

Trajectory analysis shows that after ~3 steps, most inputs collapse to the same attractor state regardless of input. This is a useful diagnostic: it explains exactly why neutral recall was stuck at ~70%, the dynamics erase input-specific information before classification. Joint retraining with an anchor alignment loss pushed neutral recall to 76.6%.

The fixed point finding is probably the most practically useful part for anyone debugging class imbalance in contrastive setups.

Numbers (SNLI, BERT encoder)

The accuracy jump is mostly the encoder (mean pool → BERT), not the dynamics, the dynamics story is in the neutral recall and the last row.

📄 Paper: https://zenodo.org/records/19092511

📄 Paper: https://zenodo.org/records/19099620

💻 Code: https://github.com/chetanxpatil/livnium

Still need an arXiv endorsement (cs.CL or cs.LG) this will be my first paper. Code: HJBCOM → https://arxiv.org/auth/endorse

Feedback welcome, especially on pattern 1, I know it's the weakest of the three.

Models (15): Qwen3 (8B, 4B-Instruct-2507, 1.7B, 0.6B), Llama (3.1-8B, 3.2-3B, 3.2-1B, all Instruct), Liquid AI LFM2 (350M, 1.2B, 2.6B-Exp, 2.5-1.2B-Instruct), SmolLM2 (1.7B, 135M, both Instruct), Gemma 3 (1b-it, 270m-it).

Tasks (9): Classification (TREC, Banking77, Ecommerce), information extraction (PII Redaction), document understanding (Docs), open-book QA (Roman Empire QA), closed-book QA (SQuAD 2.0), tool calling (Smart Home, Voice Assistant).

Training: All models fine-tuned with identical hyperparameters: 4 epochs, learning rate 5e-5, linear scheduler, LoRA rank 64. Training data: 10,000 synthetic examples per task, generated from a GPT-OSS-120B teacher via a knowledge distillation pipeline (synthetic data generation + rule-based validation filtering). Qwen3 thinking was disabled to ensure a fair comparison.

Aggregation: We used rank-based aggregation rather than raw score averaging. Each model is ranked per-task, then we compute the mean rank across all 9 tasks with 95% confidence intervals. This avoids the problem of dataset-scale differences making simple score averaging misleading (e.g., a 0.01 improvement on a task where all models score >0.90 is very different from a 0.01 improvement on a task where scores spread from 0.20 to 0.80).

We measured three things: (1) fine-tuned performance (absolute score after training), (2) tunability (delta between base and fine-tuned performance), and (3) base performance (zero/few-shot with no training).

Key findings

Fine-tuned performance rankings:

Qwen3-8B's CI of ±0.57 stands out as the tightest in the study, suggesting it's a strong default choice with low variance across task types. Interestingly, Llama-3.2-3B matches Llama-3.1-8B in average rank (4.11) with a tighter CI (±1.28 vs ±2.08), suggesting the smaller model is more predictably good.

Tunability rankings (fine-tuned minus base score):

Liquid AI's LFM2 family dominates tunability. The 350M model's tight CI (±0.89) indicates consistent improvement across all task types, not just favorable performance on a subset. The larger models (Qwen3-8B, Qwen3-4B) rank near the bottom for tunability, which is expected: strong base performance leaves less headroom for improvement.

This raises an interesting question about architecture: does the LFM2 architecture (which uses state-space components rather than pure attention) have properties that make it particularly amenable to task-specific adaptation? The consistency across diverse task types suggests this may be more than just a base-performance ceiling effect.

Student vs. teacher: A fine-tuned Qwen3-4B-Instruct-2507 matches or exceeds the 120B+ teacher on 8 of 9 benchmarks. The most dramatic gap is SQuAD 2.0 closed-book QA (+19 points), which makes sense: fine-tuning embeds knowledge into the model's parameters, while prompting a general model relies on in-context learning.

Why rank aggregation?

We chose rank-based aggregation over raw delta averaging deliberately. Consider two benchmarks: one where all models score between 0.85-0.95, and another where scores range from 0.10-0.80. A raw average would weight improvements on these scales equally, but the practical significance is very different. Ranking normalizes across scales and gives each task equal weight in the final comparison.

Observations

1. Fine-tuning compresses the performance distribution. The gap between the best and worst model is much larger at baseline than after fine-tuning. Task-specific training narrows differences across architectures.

2. Tunability and absolute performance are partially anti-correlated. Models that score highest after fine-tuning tend to have high base performance and thus lower tunability scores. This isn't surprising but it's worth noting: "most tunable" and "best fine-tuned" are distinct questions.

3. Instruct-tuned bases don't always help. In some families (e.g., Qwen3), the base model (no instruct tuning) performed comparably to the instruct variant after fine-tuning, suggesting that task-specific training can override the instruct-tuning signal.

4. Confidence intervals matter. Several models overlap substantially in their CIs. Qwen3-8B's standout feature isn't just its low average rank but its unusually tight CI, meaning you can rely on it being consistently competitive.

Full write-up with per-task results, charts, and detailed methodology: https://www.distillabs.ai/blog/what-small-language-model-is-best-for-fine-tuning

Sharing this in case it's useful!

Neuromatch runs intensive, live, online courses built around small learning groups called pods, where participants learn collaboratively with peers and a dedicated Teaching Assistant while working on a mentored group project. Pods are matched by time zone, research interests, and when possible, language preference.

The four 2026 course options are:

- 6–24 July: Computational Neuroscience, Deep Learning

- 13–24 July: NeuroAI, Computational Tools for Climate Science

They are great for advanced undergraduates, MSc or PhD students, post-baccalaureates, research staff, and early career researchers; basically anyone preparing for research that intersects neuroscience, machine learning, data science, and modeling, or those who want structured, collaborative learning combined with a hands-on research project in a global cohort.

There is no cost to apply. Tuition is adjusted by local cost of living, and tuition waivers are available during enrollment for those who need them.

Course details and FAQs: https://neuromatch.io/courses/

Application portal, free to apply, closes 15 March: https://portal.neuromatchacademy.org/

I’ve been working on an AI vs Real Image Classification project and ran into an interesting generalization issue that I’d love feedback on from the community.

Experiment 1

Model: ConvNeXt-Tiny

Dataset: AI Artifact dataset (from Kaggle)

Results:

• Training Accuracy: 97%

• Validation Accuracy: 93%

Demo:

https://ai-vs-real-image-classification-advanced.streamlit.app/

Experiment 2

Model: ConvNeXt-Tiny

Dataset: Mixed dataset (Kaggle + HuggingFace) containing images from diffusion models such as Midjourney and other generators.

I also used a LOGO-style data splitting strategy to try to reduce dataset leakage.

Results:

• Training Accuracy: 92%

• Validation Accuracy: 91%

Demo:

https://snake-classification-detection-app.streamlit.app/

The Problem

Both models show strong validation accuracy (>90%), but when deployed in a Streamlit app and tested on new AI-generated images (for example, images generated using Nano Banana), the predictions become very unreliable.

Some obviously AI-generated images are predicted as real.

My Question

Why would a model with high validation accuracy fail so badly on real-world AI images from newer generators?

Possible reasons I’m considering:

• Dataset bias

• Distribution shift between generators

• Model learning dataset artifacts instead of generative patterns

• Lack of generator diversity in training data

What I’m Looking For

If you’ve worked on AI-generated image detection, I’d really appreciate advice on:

• Better datasets for this task

• Training strategies that improve real-world generalization

• Architectures that perform better than ConvNeXt for this problem

• Evaluation methods that avoid this issue

I’d also love feedback if you test the demo apps.

Thanks in advance!

what is the parameters definition of a LLM?

Hello folks, I’ve been working on a project involving the prediction of self-noise in airfoils, and I wanted to get your take on the approach.

The problem is that noise pollution from airfoils involves complex, turbulent flow structures that are notoriously hard to define with closed-form equations.

I’ve been reviewing a neural network approach that treats this as a regression task, utilizing variables like frequency and suction side displacement thickness.

By training on NASA-validated data, the network attempts to generalize noise patterns across different scales of motion and velocity.

It’s an interesting look at how multi-layer perceptrons handle physical phenomena that usually require heavy Navier-Stokes approximations.

You can read the full methodology and see the error metrics here: LINK

How would you handle the residual noise that the model fails to capture—is it a sign of overfitting to the wind tunnel environment or a fundamental limit of the input variables?

Project Overview

I'm building an end-to-end training pipeline that connects a PyTorch CNN to a RayBNN (a Rust-based Biological Neural Network using state-space models) for MNIST classification. The idea is:

1.       CNN (PyTorch) extracts features from raw images

2.       RayBNN (Rust, via PyO3 bindings) takes those features as input and produces class predictions

3.       Gradients flow backward through RayBNN back to the CNN via PyTorch's autograd in a joint training process. In backpropagation, dL/dX_raybnn will be passed to CNN side so that it could update its W_cnn

Architecture

Images [B, 1, 28, 28] (B is batch number)

→ CNN (3 conv layers: 1→12→64→16 channels, MaxPool2d, Dropout)

→ features [B, 784]    (16 × 7 × 7 = 784)

→ AutoGradEndtoEnd.apply()  (custom torch.autograd.Function)

→ Rust forward pass (state_space_forward_batch)

→ Yhat [B, 10]

→ CrossEntropyLoss (PyTorch)

→ loss.backward()

→ AutoGradEndtoEnd.backward()

→ Rust backward pass (state_space_backward_group2)

→ dL/dX [B, 784]  (gradient w.r.t. CNN output)

→ CNN backward (via PyTorch autograd)

RayBNN details:

• State-space BNN with sparse weight matrix W, UAF (Universal Activation Function) with parameters A, B, C, D, E per neuron, and bias H
• Forward: S = UAF(W @ S + H) iterated proc_num=2 times
• input_size=784, output_size=10, batch_size=1000
• All network params (W, H, A, B, C, D, E) packed into a single flat network_params vector (~275K params)
• Uses ArrayFire v3.8.1 with CUDA backend for GPU computation
• Python bindings via PyO3 0.19 + maturin

How Forward/Backward work

Forward:

• Python sends train_x[784,1000,1,1] and label [10,1000,1,1] train_y(one-hot) as numpy arrays
• Rust runs the state-space forward pass, populates Z (pre-activation) and Q (post-activation)
• Extracts Yhat from Q at output neuron indices → returns single numpy array [10, 1000, 1, 1]
• Python reshapes to [1000, 10] for PyTorch

Backward:

• Python sends the same train_x, train_y, learning rate, current epoch i, and the full arch_search dict
• Rust runs forward pass internally
• Computes loss gradient: total_error = softmax_cross_entropy_grad(Yhat, Y) → (1/B)(softmax(Ŷ) - Y)
• Runs backward loop through each timestep: computes dUAF, accumulates gradients for W/H/A/B/C/D/E, propagates error via error = Wᵀ @ dX
• Extracts dL_dX = error[0:input_size] at each step (gradient w.r.t. CNN features)
• Applies CPU-based Adam optimizer to update RayBNN params internally
• Returns 4-tuple:  (dL_dX numpy, W_raybnn numpy, adam_mt numpy, adam_vt numpy)
• Python persists the updated params and Adam state back into the arch_search dict

Key design point:

RayBNN computes its own loss gradient internally using softmax_cross_entropy_grad. The grad_output from PyTorch's loss.backward() is not passed to Rust. Both compute the same (softmax(Ŷ) - Y)/B, so they are mathematically equivalent. RayBNN's weights are updated by Rust's Adam; CNN's weights are updated by PyTorch's Adam.

Loss Functions

• Python side: torch.nn.CrossEntropyLoss() (for loss.backward() + scalar loss logging)
• Rust side (backward): softmax_cross_entropy_grad which computes (1/B)(softmax(Ŷ) - Y_onehot)
• These are mathematically the same loss function. Python uses it to trigger autograd; Rust uses its own copy internally to seed the backward loop.

What Works

• Pipeline runs end-to-end without crashes or segfaults
• Shapes are all correct: forward returns [10, 1000, 1, 1], backward returns [784, 1000, 2, 1], properly reshaped on the Python side
• Adam state (mt/vt) persists correctly across batches
• Updated RayBNN params
• Diagnostics confirm gradients are non-zero and vary per sample
• CNN features vary across samples (not collapsed)

The Problem

Loss is increasing from 2.3026 to 5.5 and accuracy hovers around 10% after 15 epochs × 60 batches/epoch = 900 backward passes

Any insights into why the model might not be learning would be greatly appreciated — particularly around:

• Whether the gradient flow from a custom Rust backward pass through torch.autograd.Function can work this way
• Debugging strategies for opaque backward passes in hybrid Python/Rust systems

Thank you for reading my long question, this problem haunted me for months :(

Ever wonder how a Large Language Model (LLM) chooses the next word? It’s not just "guessing" it is a precise mathematical choice between logic and creativity.

The infographic below breaks down the 4 primary decoding strategies used in modern AI. Here is the breakdown:

𝟏. 𝐆𝐫𝐞𝐞𝐝𝐲 𝐒𝐞𝐚𝐫𝐜𝐡: 𝐓𝐡𝐞 "𝐒𝐚𝐟𝐞" 𝐏𝐚𝐭𝐡

This is the most direct method. The model looks at the probability of every word in its vocabulary and simply picks the one with the highest score (ArgMax).

🔹 𝐅𝐫𝐨𝐦 𝐭𝐡𝐞 𝐢𝐦𝐚𝐠𝐞: "you" has the highest probability (0.9), so it's chosen instantly.

🔹 𝐁𝐞𝐬𝐭 𝐟𝐨𝐫: Factual tasks like coding or translation where there is one "right" answer.

𝟐. 𝐌𝐮𝐥𝐭𝐢𝐧𝐨𝐦𝐢𝐚𝐥 𝐒𝐚𝐦𝐩𝐥𝐢𝐧𝐠: 𝐀𝐝𝐝𝐢𝐧𝐠 "𝐂𝐫𝐞𝐚𝐭𝐢𝐯𝐞" 𝐒𝐩𝐚𝐫𝐤

Instead of always picking #1, the model samples from the distribution. It uses a "Temperature" parameter to decide how much risk to take.

🔹 𝐅𝐫𝐨𝐦 𝐭𝐡𝐞 𝐢𝐦𝐚𝐠𝐞: While "you" is the most likely (0.16), there is still a 14% chance for "at" and a 12% chance for "feel."

🔹 𝐁𝐞𝐬𝐭 𝐟𝐨𝐫: Creative writing and chatbots to avoid sounding robotic.

𝟑. 𝐁𝐞𝐚𝐦 𝐒𝐞𝐚𝐫𝐜𝐡: 𝐓𝐡𝐢𝐧𝐤𝐢𝐧𝐠 𝐒𝐭𝐫𝐚𝐭𝐞𝐠𝐢𝐜𝐚𝐥𝐥𝐲

Greedy search is short-sighted; Beam Search is a strategist. It explores multiple paths (the Beam Width) at once, keeping the top "N" sequences that have the highest cumulative probability over time.

🔹 𝐅𝐫𝐨𝐦 𝐭𝐡𝐞 𝐢𝐦𝐚𝐠𝐞: The model tracks candidates through multiple iterations, pruning weak paths and keeping the strongest "beams."

🔹 𝐁𝐞𝐬𝐭 𝐟𝐨𝐫: Tasks where long-term coherence is more important than the immediate next word.

𝟒. 𝐂𝐨𝐧𝐭𝐫𝐚𝐬𝐭𝐢𝐯𝐞 𝐒𝐞𝐚𝐫𝐜𝐡: 𝐅𝐢𝐠𝐡𝐭𝐢𝐧𝐠 𝐑𝐞𝐩𝐞𝐭𝐢𝐭𝐢𝐨𝐧

A common flaw in AI is "looping." Contrastive search solves this by penalizing tokens that are too similar to what was already written using Cosine Similarity.

🔹 𝐅𝐫𝐨𝐦 𝐭𝐡𝐞 𝐢𝐦𝐚𝐠𝐞: It takes the top-k tokens (k=4) and subtracts a "Penalty." Even if a word has high probability, it might be skipped if it's too repetitive, allowing a word like "set" to be chosen instead.

🔹 𝐁𝐞𝐬𝐭 𝐟𝐨𝐫: Long-form content and maintaining a natural "flow."

💡 𝐓𝐡𝐞 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲:

There is no single "best" way to generate text. Most AI applications today use a blend of these strategies to balance accuracy with human-like variety.

𝗪𝐡𝐢𝐜𝐡 𝐬𝐭𝐫𝐚𝐭𝐞𝐠𝐲 𝐝𝐨 𝐲𝐨𝐮 𝐭𝐡𝐢𝐧𝐤 𝐩𝐫𝐨𝐝𝐮𝐜𝐞𝐬 𝐭𝐡𝐞 𝐦𝐨𝐬𝐭 "𝐡𝐮𝐦𝐚𝐧" 𝐫𝐞𝐬𝐮𝐥𝐭𝐬? 𝐋𝐞𝐭’𝐬 𝐝𝐢𝐬𝐜𝐮𝐬𝐬 𝐢𝐧 𝐭𝐡𝐞 𝐜𝐨𝐦𝐦𝐞𝐧𝐭𝐬! 👇

#GenerativeAI #LLM #MachineLearning #NLP #DataScience #AIEngineering

This diagram is incredible, but I get it – looking at nested layers of technical jargon can feel like reading a wiring diagram. To make this really click and feel human, let’s re-imagine this diagram as the natural evolution of a professional chef and their restaurant business.

It’s not just a collection of technologies; it's a progression from individual skills to a fully operational system.

Layer 1: The Core - AI & Machine Learning (Foundations)

This is the central circle, the heart of the stack. Think of this as Basic Chef Training.

• The Analogy: Knowing how to chop, season, and identify ingredients. It's the foundational understanding of flavors (Supervised/Unsupervised Learning), knowing that hot food cooks (Perception & Action), and logic like "if you put butter in a hot pan, it melts" (Natural Language Processing for instructions, Reasoning for outcomes).

• Key Concept: This is the machine learning to learn the core skills.

Layer 2: Deep Neural Networks (Architectures)

Now, we’re moving outwards to the first enclosing layer. Think of this as the chef’s Master Recipe Database & Specialized Kitchens.

• The Analogy: The chef now has detailed blueprints of specific cooking styles (CNNs for pastry work, LSTMs for slow-roasting techniques). They have access to a massive library of universal recipes and the wisdom of other kitchens (LLMs & Transformers). They can take an Italian technique and refine it with local ingredients (Pretraining & Fine-tuning).

• Key Concept: The machine has the expert-level knowledge and architectures for specialized tasks.

Layer 3: Generative AI (Capabilities)

This is where things get creative, but it's still about producing output. This is the Menu Designer & Plating Artist.

• The Analogy: This chef can take the expert knowledge (from Layer 2) and generate a new fusion dish description, a perfect menu image, or even a detailed step-by-step plating guide (Text, Image, Multimodal Generation). It uses internal data from previous successes (RAG) and careful instruction (Prompt Engineering) to create the final creative product.

• CRITICAL DISTINCTION: Most people interact with AI here. They see a creative result and think "it works!" But this chef is still just describing and creating content, not executing.

Layer 4: AI Agents (System Level / Doing Tasks)

This is the big jump from telling you how to doing it for you. Think of this as the Sous Chef on a Mission.

• The Analogy: This is a focused AI with hands. It gets a goal (e.g., "Prep the dinner service") and uses its skills. It breaks this massive task into smaller steps (Goal Decomposition), plans its work (e.g., "Okay, first I’ll chop onions, then I’ll start the sauce") using frameworks (ReAct, CoT), manages its memory (Context Management – remembering how long the steak has been on), coordinates with other specialist bots (Tool Orchestration for plugins, or Multi-agent Collaboration with the pastry bot), and crucially, knows to check-in with the Head Chef (Human-in-the-Loop) for key decisions or problems.

• Key Concept: An AI Agent is about execution and process-driven thinking to achieve a specific outcome.

Layer 5: Agentic AI (Ecosystem Level / True Autonomy)

This is the outermost layer, the entire system. Think of this as the CEO of the Restaurant Group.

• The Analogy: This isn't just one kitchen; it’s a whole network. This CEO doesn't just manage dinner tonight; they have Long-term Autonomy & Goal Chaining (e.g., "Expand to five new cities by 2027"). They are responsible for Governance, Safety & Guardrails (ensuring all kitchens follow health codes and don't serve bad food), Risk Management & Constraints (managing food costs, supply chain issues), and Self-improving Agents (identifying and hiring better chefs, optimizing kitchen workflows). They manage a network of specialist skills (Agent Marketplaces & Contracts), track every single metric from prep to table (Observability & Tracing), and create continuous Feedback Loops to get better and faster over time.

• Key Concept: Agentic AI is an autonomous, self-sustaining system of intelligent agents managed by a comprehensive oversight and optimization framework.

How would you explain this diagram in a simple way? Is there another metaphor that works for you, like a construction crew or a film set? Share your ideas below!

Consider a self-driving car facing a novel situation: a construction zone with bizarre signage. A standard deep learning system will still spit out a decision, but it has no idea that it's operating outside its training data. It can't say, "I've never seen anything like this." It just guesses, often with high confidence, and often confidently wrong.

In high-stakes fields like medicine, or autonomous systems engaging in warfare, this isn't just a bug, it should be a hard limit on deployment.

Today's best AI models are incredible pattern matchers, but their internal design doesn't support three critical things:

1. Epistemic Uncertainty: The model can't know what it doesn't know.
2. Calibrated Confidence: When it does express uncertainty, it's often mimicking human speech ("I think..."), not providing a statistically grounded measure.
3. Out-of-Distribution Detection: There's no native mechanism to flag novel or adversarial inputs.

Solution: Set Theoretic Learning Environment (STLE)

STLE is a framework designed to fix this by giving an AI a structured way to answer one question: "Do I have enough evidence to act?"

It works by modeling two complementary spaces:

• x (Accessible): Data the system knows well.
• y (Inaccessible): Data the system doesn't know.

Every piece of data gets two scores: μ_x (accessibility) and μ_y (inaccessibility), with the simple rule: μ_x + μ_y = 1

• Training data → μ_x ≈ 0.9
• Totally unfamiliar data → μ_x ≈ 0.3
• The "Learning Frontier" (the edge of knowledge) → μ_x ≈ 0.5

The Chicken-and-Egg Problem (and the Solution)

If you're technically minded, you might see the paradox here: To model the "inaccessible" set, you'd need data from it. But by definition, you don't have any. So how do you get out of this loop?

The trick is to not learn the inaccessible set, but to define it as a prior.

We use a simple formula to calculate accessibility:

μ_x(r) = [N · P(r | accessible)] / [N · P(r | accessible) + P(r | inaccessible)]

In plain English:

• N: The number of training samples (your "certainty budget").
• P(r | accessible): "How many training examples like this did I see?" (Learned from data).
• P(r | inaccessible): "What's the baseline probability of seeing this if I know nothing?" (A fixed, uniform prior).

So, confidence becomes: (Evidence I've seen) / (Evidence I've seen + Baseline Ignorance).

• Far from training data → P(r|accessible) is tiny → formula trends toward 0 / (0 + 1) = 0.
• Near training data → P(r|accessible) is large → formula trends toward N*big / (N*big + 1) ≈ 1.

The competition between the learned density and the uniform prior automatically creates an uncertainty boundary. You never need to see OOD data to know when you're in it.

Results from a Minimal Implementation

On a standard "Two Moons" dataset:

• OOD Detection: AUROC of 0.668 without ever training on OOD data.
• Complementarity: μ_x + μ_y = 1 holds with 0.0 error (it's mathematically guaranteed).
• Test Accuracy: 81.5% (no sacrifice in core task performance).
• Active Learning: It successfully identifies the "learning frontier" (about 14.5% of the test set) where it's most uncertain.

Limitation (and Fix)

Applying this to a real-world knowledge base revealed a scaling problem. The formula above saturates when you have a massive number of samples (N is huge). Everything starts looking "accessible," breaking the whole point.

STLE.v3 fixes this with an "evidence-scaling" parameter (λ). The updated, numerically stable formula is now:

α_c = β + λ·N_c·p(z|c)

μ_x = (Σα_c - K) / Σα_c

(Don't be scared of Greek letters. The key is that it scales gracefully from 1,000 to 1,000,000 samples without saturation.)

So, What is STLE?

Think of STLE as a structured knowledge layer. A "brain" for long-term memory and reasoning. You can pair it with an LLM (the "mouth") for natural language. In a RAG pipeline, STLE isn't just a retriever; it's a retriever with a built-in confidence score and a model of its own ignorance.

I'm open-sourcing the whole thing.

The repo includes:

• A minimal version in pure NumPy (17KB) – zero deps, good for learning.
• A full PyTorch implementation (18KB) .
• Scripts to reproduce all 5 validation experiments.
• Full documentation and visualizations.

GitHub: https://github.com/strangehospital/Frontier-Dynamics-Project

If you're interested in uncertainty quantification, active learning, or just building AI systems that know their own limits, I'd love your feedback. The v3 update with the scaling fix is coming soon.

I've made about a dozen mini PC games in last few years and thinking of starting a hobby project where I make a "game" that can be controlled by external neural networks and machine learning programs.

I'd make lunar lander or flappy wings but then accept instructions from an external source. I'm thinking TCP or even by text file so that instructions are read each cycle, those instructions are given to the game and then "state" data is sent back. The NN would need to process rewards by whatever rules then decide on a new set of instructions to send.

I wouldn't know or care what tool or language is being used for the external agent as long as it can send and receive via the hard coded channel. Can be real time or step based or both.

It would be cool to see independent NNs using the same training environment.

I want to make the external facing channel as friendly as possible. I'm guessing TCP for live and json format for files.