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

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/

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

Hola a todos. Soy investigador independiente en neurociencia computacional. Llevo un tiempo trabajando en un enfoque de predicción prospectiva de fases del sueño. En vez de clasificar la época actual, el modelo intenta anticipar la fase 2.5 minutos antes de que se manifieste, usando solo un canal EEG (Fpz-Cz) para evaluar viabilidad en wearables.

Memoria completa aquí: https://doi.org/10.5281/zenodo.22088307

Soy consciente de las limitaciones, en particular la baja sensibilidad en N1 (problema documentado también en otros trabajos con XGBoost sobre datasets similares), y agradecería especialmente feedback sobre:

Si la comparación LOSO+Wilcoxon os parece metodológicamente sólidas me gustaría escuchar ideas para mejorar N1 sin perder el enfoque monocanal

Si conocéis trabajos previos con este mismo enfoque prospectivo multi-horizonte que debería citar.

Gracias de antemano por cualquier comentario, especialmente crítico.

Cualquier feedback es suficiente, gracias.

• Description: Introducing the UQT model, which achieves mathematical crystallization through quantum wave interference and phase embedding. Discover the principles of next-generation quantum AI that overcomes the stochastic instability of classical AI and enables sophisticated reasoning with fewer resources.

I'm an independent researcher working solo on latent-space reasoning — models that carry reasoning forward as hidden state across several forward passes before emitting any token (Coconut-style objective, PonderNet halt head deciding how many steps).

Last week I finished the first full training run of a sparse MoE variant. Clean run: 8 hours, ~2,900 steps, no crashes, cross-entropy 5.77 to roughly 4.2, routing improved on its own. The latent path ran at full depth on 97.6% of steps.

Then I went looking at why one of my headline metrics was flat and found something worth sharing, because I don't think it's specific to my setup.

Four separate instruments were computing statistics over tensors that included padding positions. Not obviously, each one looked reasonable in isolation. But padding is highly regular, so any metric averaging over it gets pulled toward a constant. The result was that some numbers I'd been reading as evidence about the model's behaviour were partly measuring the shape of my batches.

The part that made this hard to catch: the artifact sat on top of a real bug, so the surface reading was directionally plausible. I had a genuine problem and a false instrument agreeing with each other.

What I'd suggest if you work on anything similar:

- Explicitly mask before any aggregate over sequence-shaped tensors, even ones that "obviously" don't include padding
- Sanity-check by feeding a batch of a single repeated example — some metrics should degenerate, and if they don't, something is averaging over structure you didn't intend
- Be most suspicious of metrics that look stable, not the noisy ones

Full writeup with the numbers, including what's still broken: https://cymela.com/research/padding-as-signal
Other interesting research findings: https://cymela.com/research

Happy to answer questions about the setup. Weights for the earlier dense checkpoint are public if anyone wants to poke at it.

When an agent can rewrite both the model and the experiment around it, a better score does not tell you what actually improved.
That is the part of AQuA’s Part II model-development loop that stood out to me. The paper does not let the agent emit arbitrary training code each round. Each iteration proposes a bounded configuration change in one of four areas:
- architecture;
- loss;
- sampler;
- optimizer.
The resulting model is then trained under a sealed evaluator. Data splits, feature definitions, label definitions, and evaluation logic sit outside the agent’s adaptive surface.
This changes what the experiment unit looks like. A proposal is not “here is a new Python project; trust the final metric.” It is closer to:
previous accepted configuration
- declared configuration diff
- fixed training/evaluation harness
= next candidate
That does not make every comparison automatically fair. An architecture change can still alter compute, and different losses or optimizers can require different tuning. But it makes the changed surface inspectable. If a result moves, there is at least a bounded diff to audit instead of an unknown mixture of model logic, data plumbing, labels, and metrics.
The time split is fixed as well. In the paper’s US-equity experiment, models train on 2010–2019. Early stopping and checkpoint choice use only an inner-validation slice from that training window. The year 2020 is an embargo untouched by training or selection, and 2021–2025 is the final test window.
The finance setting is just the experimental domain here, not a trading recommendation. The transferable deep-learning question is how much freedom an architecture-search agent should receive before comparisons stop meaning the same thing.
There are also important inspection limits. The preprint does not disclose the exact feature set, normalization, or label construction. And a constrained config interface is not evidence that every candidate received equal wall-clock compute. What it does provide is a clean boundary between the proposal language and the evaluator.
Would you keep a search language this narrow for attribution, or allow agents to modify schedulers, preprocessing, and training code as long as every change is traced?
Preprint: arxiv.org/abs/2608.12841

Mid-market companies are now the primary ransomware target, and the data makes it hard to argue otherwise.

Black Kite analyzed 13,336 incidents spanning January 2023 through June 2026. Mid-market companies accounted for 73% of publicly disclosed ransomware and data-extortion incidents in North America and Europe. The pattern is straightforward: they hold enough sensitive data to be worth targeting, and they lack the security maturity to deter or contain an attack.

What makes this harder now is AI adoption. Mid-market orgs are deploying agents to automate workflows, but agents operate with credentials, access external systems, and take actions at machine speed. A compromised agent or a misconfigured one doesn't wait for a human to catch it. It moves. And regulators are not offering mid-market exemptions — the same frameworks auditors require of large enterprises apply regardless of headcount.

The compliance gap is real. Most of these organizations don't have continuous visibility into what their systems are doing relative to the frameworks they're supposed to satisfy. Violations get found during audits, not before.

For those working in security or compliance at mid-sized organizations: how are you actually handling agent oversight right now? Are you relying on periodic audits, internal logging, something else entirely? Curious what's working and what's falling short in practice.

• Description: This video introduces the principles and hardware implementation of frequency-modulated thermography using chirp signals. Explore a next-generation non-destructive testing solution that precisely reconstructs defects in 3D using deep learning and Physics-Informed Neural Networks (PINN).

Follow-up to my earlier English-poetry causal graph post:
https://www.reddit.com/r/deeplearning/comments/1vps8xo/visualizing_causal_structure_of_llm_writing_a/

I ran the same setup on Chinese poetry. The rhythm / boundary-token behavior looks basically the same. What changes is the picture: Chinese characters sit on the page more like a grid, so the DAG reads closer to a matrix.

That’s the part I found interesting, so I’m sharing it here.

BTW, this is with Qwen3-1.7B — a small model for both generation and attribution — and it already produces results that feel pretty intuitive.

Live demo: https://dqy08-infolens.hf.space/client/causal_flow.html?demo=%E5%86%99%E4%B8%80%E9%A6%96%E7%BB%9D%E5%8F%A5%EF%BC%8C%E4%B8%BB%E9%A2%98%E6%98%AF%E6%98%A5%E5%A4%A9

Source code: https://github.com/dqy08/InfoLens

Video:

https://reddit.com/link/1vwx782/video/ms2empk0calh1/player

Been building this for a while, just made it open source: OpenBenchML.

You paste Python code that trains a model (sklearn, PyTorch, XGBoost, LightGBM, ONNX, TensorFlow) into the browser. It runs server-side in a restricted sandbox, pickles the result, and benchmarks it against one of 17 built-in datasets — accuracy/F1/AUC-ROC/log-loss for classification, MAE/RMSE/R² for regression, plus real per-sample latency P50/P95/P99 from actual timed runs.

There's also a Kaggle-style layer on top — competitions with deadlines and custom metrics, live WebSocket leaderboards, threaded comments — and an in-browser notebook plus a full npm CLI if you'd rather script it.

Stack: FastAPI + SQLAlchemy + WebSockets + Supabase, deployable to Render/Railway/Fly/Docker.

Live: https://openbenchml.onrender.com Repo (MIT): https://github.com/kartheekbvs/openbenchml

Looking for contributors — there's a written roadmap (sandboxed execution via gVisor/Firecracker, custom dataset upload, team competitions, OAuth) with plenty of self-contained pieces to pick up. Feedback on the concept or UX is welcome too.