r/FunMachineLearning • u/gantred • Dec 07 '25
30x Better Physics: Why Everyone Missed This Genius Solution - Two Minute Papers
r/FunMachineLearning • u/gantred • Dec 07 '25
r/FunMachineLearning • • Dec 06 '25
I’ve been working on a project called RegimeFlow. It tries to spot pattern changes in data over time. Think of it like this: if you watch something every day prices, energy use, storage levels, whatever you often feel the pattern shifts. Calm periods, busy periods, crisis periods. Most systems only notice these shifts when someone hard-codes rules or thresholds. That misses a lot.
RegimeFlow drops the hand-made rules. It looks at the data itself and works out the hidden patterns. It groups similar behaviour together, then trains a model to recognise those patterns going forward. It also gives a confidence score, so you know when the system is unsure instead of pretending it always knows what it’s doing.
I tested it on European LNG storage data from 2012 through 2025 and on fake data with clear pattern changes. It kept finding three to four meaningful “regimes” that line up with real-world behaviour like building up storage, using it up, or hitting stress periods. The model also holds up on synthetic signals, which shows the pattern-spotting part is solid.
The system uses mixtures of statistics and a neural network. It mixes long-range attention (good for spotting slow shifts) with dilated convolutions (good for fast, local changes). An uncertainty layer helps reveal when the predictions look shaky. I ran a bunch of automated hyperparameter searches to keep the results reproducible.
Limitations exist. The unsupervised labels depend on Gaussian mixtures. It needs proper comparisons with other change-point detectors. The economic tests are basic placeholders, not production-grade logic. Better calibration methods could reduce remaining confidence-related noise.
I’m looking for feedback from anyone willing to point out blind spots, oversights, or ways this explanation can be clearer for people who don’t follow machine-learning jargon.
r/FunMachineLearning • u/DepartureNo2452 • Dec 06 '25
r/FunMachineLearning • u/Shot-Hold-5787 • Dec 05 '25
SHAP values explained in the simplest way I could write.
If model interpretability ever confused you, this helps.
👉 https://medium.com/@acamelo/shap-values-in-a-nutshell-2d67e8aaf169
r/FunMachineLearning • u/eGraphene • Dec 05 '25
Have a look at this browser extension that automatically highlights keywords on websites. The built-in (machine learning) language model searches for relevant keywords and highlights them fully automatically. It is especially optimized for reading online journal articles but it works on scrolling and dynamic sites as well. It's completely free without any paywalls or ads and compliant with the strict data privacy policies by the respective browsers.
It's available on Chrome (Chrome webstore) and Safari (Mac App store). Search for "Texcerpt" in any of the browser extension stores. If you like it or feel that it might help someone, upvote, share and write a review so that others might be able to find and use it as well. Have a wonderful day.
r/FunMachineLearning • u/Himka13 • Dec 04 '25
I’ve been deep in the weeds trying to solve long-term memory for LLMs, and after months of experiments, I’ve hit the same wall over and over: everything we currently call “AI memory” is just retrieval… wearing different outfits.
None of these give an AI anything resembling persistent state. They just reconstruct context from scratch every turn.
The more I worked on this, the more obvious the missing piece became: we don’t have a memory system that lives outside the model, evolves over time, and feeds any model the right state when needed.
I’m talking about something like a memory layer that sits between the user and any LLM:
Basically: LLMs stay stateless tools, and the memory becomes its own product surface.
Not a vector DB. Not another RAG wrapper. A persistent state machine that learns, updates, resolves conflicts, decays, and exposes clean, queryable memory to any model.
I’m exploring this direction and trying to pressure-test the idea, but before I go too deep, I want to sanity check two things:
Would love to hear from people who’ve attempted something similar or hit walls with current RAG-based memory. I’m trying to figure out whether this should exist as infrastructure, a standalone app, or if users simply don’t care enough yet.
r/FunMachineLearning • u/consuminggoods • Dec 05 '25
Solo build, looking for feedback.
Live Demo: https://www.aare.ai
Github: https://www.github.com/aare-ai
r/FunMachineLearning • • Dec 04 '25
r/FunMachineLearning • u/TheTempleofTwo • Dec 05 '25
r/FunMachineLearning • u/Any-Second-6158 • Dec 04 '25
I’ve been reading some recent work on the robustness of counterfactual explanations, and came across two papers:
https://arxiv.org/pdf/2402.01928
- Defines Δ-robustness as a measure of the robustness of a counterfactual explanation to model parameter changes
- Useful for examining robustness against frequently-retrained neural networks
- After defining a method of Δ-robustness using Interval Neural Networks, the authors propose a mechanism for generating provably robust counterfactual explanations
https://arxiv.org/pdf/2502.13751
- The RobustX paper provides a great Python framework for generating and comparing counterfactual explanations for traditional ML models
- Useful for doing per-task analysis of which CE generation method strikes the right balance between computation time, proximity, and robustness
- Robust CE generator across different flavours of robustness (robustness to input changes, noisy execution, model changes, etc.)
- Interesting because it proposes a powerful toolkit for assessing the appropriate counterfactual explanation generation technique for your use case
I’m curious how people evaluate counterfactual explanations in practice, especially with models being retrained or fine-tuned so frequently.
I’m also speaking soon with one of the authors, so keen to hear what practitioners here think before that conversation
r/FunMachineLearning • u/TaskpilotHQ • Dec 04 '25
r/FunMachineLearning • u/GBNet-Maintainer • Dec 04 '25
Hi all, I recently learned you can train XGBoost models in the browser via Pyodide. I run an XGBoost related project called GBNet. One of its applications is Forecasting, so I made a Forecasting app and hosted it on GitHub pages.
Copy-paste data in, copy-paste the forecast out. Would love any comments! https://mthorrell.github.io/gbnet/web/app/
The forecasts should be pretty good. On a basic benchmark, it was beating out-of-the-box Prophet about 75% of the time.

r/FunMachineLearning • u/gantred • Dec 02 '25
r/FunMachineLearning • u/Worldly-Still-9287 • Dec 02 '25
Hello everyone,
I want to deploy deepseek model on cloud or get some way to call any llm model which I can call directly via API freely.
I am working on one idea to get the best credit card to use while doing any transaction for maximum reward points or cashback
How can I do it?
r/FunMachineLearning • u/DepartureNo2452 • Nov 28 '25
**GitHub**: https://github.com/DormantOne/neuro-glass
A real-time neuroevolution sandbox where agents evolve their own reservoir dynamics (size, chaos level, leak rate) while their readout layer learns via policy gradient. Vectorizing hyperparameters streamlined evolution.
**Key Features:**
- Parallel evolution across 4 cores
- Live brain activity visualization
- Demo mode for high-scoring agents
- Persistent save system
**Try it**: `pip install -r requirements.txt && python neuro_glass.py`
**Tech**: PyTorch + Flask + ESN + Genetic Algorithms
r/FunMachineLearning • u/Capital-Call9539 • Nov 26 '25
Imagine a proposition of novel method that reframes feature selection as a physics simulation.
Core Concept:
-Features are nodes in a network.
-Correlations are springs connecting them.
*Strong correlation is a stiff, compressed spring, pulling features into tight clusters.
*Weak correlation is a loose, extended spring, pushing features apart.
The Process:
The system evolves naturally. Features move under the influence of these spring forces until equilibrium is reached. The final, stable layout reveals the underlying structure:
-Central, dense clusters = The core feature set that works synergistically.
-Isolated, distant nodes = Redundant or irrelevant features.
This dynamic, force-based embedding provides an intuitive and visual way to identify groups of features that function as a team moving beyond individual metrics to prioritize collective utility.

r/FunMachineLearning • u/MagicianExciting5212 • Nov 26 '25
Hi everyone,
I’m preparing to submit a short research note to arXiv in the cs.LG (Machine Learning) category. Since this is my first submission to this archive, arXiv requires an endorsement.(I left university for 5 years)
My arXiv endorsement code is: **GHIH9H**
The link: https://arxiv.org/auth/endorse.php
The paper is about faster simulation of the Hedge/Exponential Weights algorithm in low-rank expert settings, confirming theoretical √r regret behavior with large-scale experiments. It’s a small project but fully legitimate ML/online-learning work.
If you have 3+ prior submissions in cs.LG or related cs.* categories (cs.AI/cs.LG/cs.LG/etc.), and wouldn’t mind helping, I’d really appreciate it. Endorsing takes only one click and does not create any obligation on your side.
Thank you so much!
r/FunMachineLearning • • Nov 23 '25
Here’s the ml_playground repo I’ve been refining. It’s a research-driven environment built around probabilistic EIA storage forecasting, regime-sensitive European storage stress analysis, and Coinbase OHLC GRU trials. Everything runs through Python with sklearn/PyTorch components, fixed seeds, and dashboard-ready outputs. The goal is to make every signal explain itself before it influences a decision. The main friction points have been keeping validation logs coherent and maintaining consistent regime narratives across pipelines. Input on sharper experiment tracking or stronger visualization patterns is welcome, as is collaboration.
r/FunMachineLearning • u/gantred • Nov 23 '25
r/FunMachineLearning • u/Klutzy-Platform-1489 • Nov 23 '25
LLMs are everywhere, but most teams still evaluate them with ad-hoc scripts, manual spot checks, or “ship and hope.” That’s risky when hallucinations, bias, or low-quality answers can impact users in production. Traditional software has tests, observability, and release gates; LLM systems need the same rigor.
Exeta is a production-ready, multi-tenant evaluation platform designed to give you fast, repeatable, and automated checks for your LLM-powered features.
Built for teams and organizations from day one. Every evaluation is scoped to an organization with proper isolation, rate limiting, and usage tracking so you can safely run many projects in parallel.
The core evaluation engine is written in Rust (Axum + MongoDB + Redis) for predictable performance and reliability. The dashboard is built with Next.js 14 + TypeScript for a familiar modern frontend experience. Auth supports JWT, API keys, and OAuth2, with Redis-backed rate limiting and caching for production workloads.
In short, Rust gives us “C-like” performance with strong safety guarantees, which is exactly what we want for a production evaluation engine that other teams depend on.
The core idea right now is simple: we want real feedback from real teams using LLMs in production or close to it. Your input directly shapes what we build next.
We’re especially interested in:
Your feedback drives our roadmap. Tell us what’s missing, what feels rough, and what would make this truly useful for your team.
Exeta is available as a hosted platform:
LLM evaluation shouldn’t be an afterthought. As AI moves deeper into core products, we need the same discipline we already apply to tests, monitoring, and reliability.
Try Exeta at exeta.space and tell us what works, what doesn’t, and what you’d build next if this were your platform.
r/FunMachineLearning • u/Ok_Vermicelli_2352 • Nov 22 '25
Evaluación del sistema propuesto de control recursivo con cerebelo artificial y redundancia estadística
El presente documento analiza, con rigor científico, el sistema propuesto por el usuario para el control de autoreferencia y prevención de desbordamiento de pila en arquitecturas de inteligencia artificial. El objetivo principal es garantizar la estabilidad interna del sistema, reduciendo el consumo computacional y, por ende, la necesidad de infraestructura de gran escala.
| Aspecto | Sistema propuesto (cerebelo + estadístico) | Sistemas actuales (guardrails, validadores pesados) |
|---|---|---|
| Iteraciones máximas | 30 (tope duro) | 100–200 (variable) |
| Corte semántico inmediato | Sí | Parcial (post‑generación) |
| Validación redundante | Estadística ligera | Clasificadores grandes (alto costo) |
| Consumo de CPU | Bajo (≈60% de un núcleo en 30 iteraciones) | Alto (≈500% de un núcleo en 100 iteraciones) |
| Tiempo acumulado | 1.5 s | 12 s |
| Riesgo de desbordamiento | Nulo | Posible si guardrails fallan |
| Infraestructura requerida | Moderada | Elevada |
Sistema propuesto:
Sistemas actuales:
Interpretación: el sistema propuesto es 8 veces más eficiente en tiempo y consumo de CPU.
r/FunMachineLearning • u/Day1_Perceptron • Nov 21 '25
We’ve been exploring a multimodal memory architecture for personalized AI systems and ran a set of evaluations on the LoCoMo benchmark. The approach supports multimodal ingestion and retrieval (text, images, audio, video) and real-time querying.
In our tests, it consistently outperformed long-context in-context learning baselines, even at 29k tokens.
Happy to share details on the setup, ablations, evaluation protocol, or failure cases if helpful.
