Hey everyone! 👋 If you’re building RAG or autonomous AI agents, you’ve probably hit the "Vector DB Wall": flat Euclidean vectors suck at modeling complex hierarchical reasoning, and loading millions of 1536D vectors + JSON metadata into memory causes massive RAM bloat and OOM crashes. We spent the last few months solving this from the ground up. Today, we are releasing HyperspaceDB v3.1.0, transitioning from a standard vector index to a full Spatial AI Engine. Here is what’s under the hood: 1. The RAM Diet (Schema-Driven MRL) Instead of loading full dense vectors into memory, we built native support for Matryoshka Representation Learning (MRL). The engine keeps a lightweight navigation core (e.g., 129 dimensions) in ultra-fast RAM, while the heavy semantic tail (672 dimensions) streams dynamically from NVMe SSDs for final top-K re-ranking. The benchmark: In our stress tests with 100,000 vectors, HyperspaceDB consumed just ~72.0 MB of RAM compared to >3,000 MB for Chroma and ~1,700 MB for Milvus. 2. 801D Hybrid Vectors (Lorentz + Euclidean) Flat vectors fail at taxonomy (e.g., Legal Codes, Medical Trees). We introduced an 801D Hybrid Vector. The first 33 dimensions live in a negatively curved Lorentz hyperboloid (allowing for native graph/tree embeddings), while the remaining 768 dimensions handle Euclidean semantic density. Agents can now verify facts geometrically using geodesic path tracing. 3. Killing the "Two-Database Problem" Gluing Pinecone to MongoDB for document storage is painful. We built Sidecar Document Storage. You store massive raw texts directly in the index, which automatically compresses (Zstd) and pushes them to fractal .hyp chunks on disk. Meanwhile, Typed Metadata (int, bool, enum) is compiled directly into the HNSW graph nodes in RAM, providing zero-latency pre-filtering with no JSON-parsing overhead. 4. Lock-Free Rust Performance Under a 1,000-concurrent-client stress test, our lock-free HNSW and L0/L2 DashMap cache held flat at 9,476 QPS with a p99 latency of 11.83 ms. Competitors hit severe lock contention at this scale, with latencies spiking over 2,000 ms. We’ve also added a WASM runtime, Raspberry Pi ARM64 support, and native LangChain/LlamaIndex/MCP integrations. Would love to hear your thoughts, answer any questions about the architecture, or get feedback from anyone pushing the limits of Agentic RAG! Ask me anything! 🚀 submitted by /u/Sam_YARINK [link] [Kommentare]
Hi folks, Niels here from the open-source team at Hugging Face. I continue working on a revival of paperswithcode.co as we're back to the "age of research" per Ilya Sutskever! Hence, it's important to discover each other's research and build on each other's work, so we can collectively build the next Transformer. Below, I'll go over each of the new features that were recently added. ## Support for SOTA badges Yes, that's right, totally like the old website. You can see that GLM-5.2, for instance, is obviously the hottest blog post today, achieves SOTA on PostTrainBench, and performs well on many other benchmarks. It is displayed whenever a paper gets a score within the top 3 of a given benchmark. Note that these are displayed on any paper feed, including https://paperswithcode.co/tasks/video-classification, for example. https://preview.redd.it/wawma8paeu8h1.png?width=2418&format=png&auto=webp&s=0ba3b6a0eaef231b7f3ca468cc3db4120f1b9e4d ## New trending score The papers are now ranked based on a new trending metric. This is a combination of the GitHub star velocity and the trending score of the linked Hugging Face artifacts (models, datasets, and Spaces). Previously, this only took into account GitHub star velocity. Thanks to this, papers like IndexCache are now trending, which is a core technique behind the trending GLM-5.2 model. https://preview.redd.it/b6g04w2ogu8h1.png?width=2380&format=png&auto=webp&s=13d59bbadd5f8e8295deac2ee6e1e0e3dbc0f40f ## Support for external evals Second, I've added support for "external" evals. This is a feature the legacy PwC website didn't actually have. Oftentimes, a paper has way more evals than the ones introduced in the paper itself. You can now view these third-party evals. Some examples: FrontierSWE and PostTrainBench numbers for GLM-5.2: https://paperswithcode.co/paper/98456#results?task=agents Artificial Analysis has numbers on CritPt, a though physics benchmark. See e.g. https://paperswithcode.co/paper/85629#results?task=reasoning https://preview.redd.it/mfnfdzxpeu8h1.png?width=1914&format=png&auto=webp&s=2b909ecf7c6e3fc088fd0a46fbc56f6859dfaf17 ## More tasks, benchmarks and evals I'm adding more benchmarks and adding evals of more papers. This happens gradually, based on the legacy PwC data available on the hub. Some new benchmarks include: - ImageNet - 10% of the data https://preview.redd.it/wr55g27ofu8h1.png?width=2880&format=png&auto=webp&s=e6e5ef7e3a36cd5aa6d2841b149194239f4ad1e0 - 3D semantic segmentation: https://preview.redd.it/zxgobrnqfu8h1.png?width=2880&format=png&auto=webp&s=6ee2935981825d5d7825709294ddb84a4b7a3ac9 - object counting: https://preview.redd.it/uhv4wbrsfu8h1.png?width=2880&format=png&auto=webp&s=183decb144d9779e41bf12ca58fbaab66cd29cbf and a lot more. Browse all of them at https://paperswithcode.co/tasks ## New domain Papers with Code is now also available from paperswithco.de :) Let me know what is missing, bug/feature requests, and whether you want to contribute! Kind regards, Niels submitted by /u/NielsRogge [link] [Kommentare]
Hey r/robotics, I've been working with tactile sensor data for a while, and there's a problem that kept bugging me: every tactile dataset has its own format, its own sensor, and its own way of labeling things. Want to compare your material classification model on GelSight vs DIGIT vs DMA? Good luck — the annotations don't line up, the schemas are different, and there's no standard way to even represent a "tactile label" across sensors. So we built two things to fix this: **TLabel** — an open-source sensor-agnostic tactile data labeling toolkit (Python + Panel UI). It supports annotation, quality scoring, batch processing, and exports to HDF5/CSV/JSON. Think of it as LabelImg but for touch data. **TLabel-Bench** — the first cross-sensor tactile annotation benchmark. It provides: - Unified JSON annotation schema that works across GelSight, DIGIT, and DMA sensors - Standardized evaluation scripts for material classification, episode segmentation, and cross-sensor transfer - Compatible with existing datasets (Touch and Go, SSVTP, ObjTac, Daimon-Infinity, CLAMP) The key idea: we only distribute annotation files + download scripts, not the raw data itself. This respects the original datasets' licenses while still letting researchers work with standardized labels. Why this matters: tactile sensing is moving fast (GelSight, DIGIT, DMA, Xense, etc.), but the tooling for *labeling and comparing* across sensors basically doesn't exist. Every paper re-implements their own annotation pipeline. We're trying to fix that. Would love feedback from anyone working with tactile data. What sensors are you using? What labeling tasks do you need? GitHub: - https://github.com/liesliy/tlabel (labeling toolkit, pip install tlabel) - https://github.com/liesliy/tlabel-bench (benchmark + evaluation) submitted by /u/ImmediateArm7942 [link] [Kommentare]
Hey guys We are a group of people working on QDD actuators and we want to know the demand for these and required specifications. Too blunt of a sentence but yeah, we are trying to build low cost QDD actuators ( < 30k INR, 300USD ) with good reliability, integration and support. Based in India. We are trying to do market validation. Keeping everything aside, if you're working in any company or a lab anywhere in the world which uses QDDs (preferred to be in India). Please let us know what are the required specs and how many can we expect an entity to need/order per year. submitted by /u/VisualDry7848 [link] [Kommentare]
I'm a recent CS grad trying to break into ML engineering, and I just finished the first version of a side project I've been working on. Posting it here because I want people who know this space better than me to poke holes in it. The idea started from that feeling every dev has had, where you commit something and a second later your stomach drops because you think you just pushed an AWS key. Server side scanning catches that eventually, but only after it's already in your git history. Local tools like gitleaks run before that, which is the right idea, but they're pure pattern matching, so anything that isn't a known secret format slips through and they say nothing about whether the code itself is risky. Piping your diff to a cloud LLM just trades that problem for a different one. So I built a git hook that runs three checks on a commit, all on device. A fast Rust regex pass catches known secret formats and blocks the commit if it finds one. A small classifier running on the Neural Engine through CoreML catches riskier patterns that don't have a fixed string to match, things like shell=True in a subprocess call or disabled TLS checks, and also blocks if it fires. A small local LLM (Qwen2.5-Coder, 1.5B, running through MLX) reads the diff more like a human reviewer and flags things like injection risks or dead code, but it never blocks anything, just leaves notes. I kept it that way on purpose, since a false positive that blocks your commit kills trust fast, but a false positive that's just a comment costs nothing. Biggest weaknesses right now: it's Apple Silicon only since CoreML and MLX are both Apple specific, and the classifier is trained on a fairly small dataset so I wouldn't call it bulletproof yet. Repo's here if anyone wants to dig into the code: https://github.com/stalzkie/local-forge Mainly curious whether the three layer split makes sense to people who do this for a living, and what risky code patterns I might be missing for the classifier. submitted by /u/StalWrites [link] [Kommentare]
I'm currently a software engineer (mostly mobile/iOS development) and have recently started learning machine learning because I genuinely find it interesting, especially the math behind it. I have a fairly strong math background and am comfortable with calculus, probability, and math in general. Right now I'm learning through a combination of Andrew Ng's ML course and Stanford CS229. My plan is to build some projects once I have a stronger foundation. What attracts me to ML is the mathematics behind it. My goal isn't just to use existing libraries to train models and tune hyperparameters; I want to understand the underlying theory, algorithms, and reasoning that make these models work. I'm interested in going deeper into the field rather than treating ML as a black box. That said, I keep seeing ML roles that prefer or require a Master's or PhD, so I'm trying to understand how realistic this path is. For people who have successfully made the switch: Did you have a Master's/PhD, or were you self-taught? How difficult was it to get interviews without an advanced degree? What types of projects helped you stand out? Did you transition into ML engineering first, or directly into more model-focused work? What level of math and statistics do you actually use on the job? If you were starting again today as a software engineer with a strong math background, what path would you follow? I'm looking for honest experiences, including failures and challenges, not just success stories. submitted by /u/Schmosby123 [link] [Kommentare]
Took apart an industrial QDD actuator today and found the internals interesting. It's a different feeling when you can actually look at how they are integrated. submitted by /u/Cubemars [link] [Kommentare]
This was my first time using ESP32, I used S3 Supermini because of its compact size which I needed to make this small pocket sized/keychain robot. I am calling it MiniSoul, as it is smaller version of a robot that I am working on called SoulBot. At its core it uses a behaviour engine I built which dictates it's behaviour based on the past interaction which affects different personality factors like Fear, Joy, Curiosity,Desire,Sadness and Anger. The interaction is using touch plate on the top by measuring capacitance and it differentiates between tap, aggression and caress based on small kNN model. I am also using seperate RTC module to give clock functionality like alarm/reminder and also the EEPROM on the RTC module is used to store personality states, storing personality on external EEPROM means it survives OTA firmware updates, not just power cycles. Also this would not damage the storage after multiple write cycles like it would to the flash memory. For touch classification I have used KNN model also on device data collection for touch tuning as every casing varies slightly. The whole MiniSoul OS is built on top of micropython which also allows OTA updates. submitted by /u/SobyDamn [link] [Kommentare]
Hey r/robotics, A while back I posted asking for name suggestions for my new mobile robot platform. Last time around, you guys gave me Arctos for the 6-DOF arm. This time, the top upvoted comment was Cary McCarface. So, officially, the robot is designated Arctos CMC. The "CMC" stands exactly for what you think it does. I finally finished the full build and just put together a quick video showing it driving around and doing its thing. Despite the ridiculous name, a lot of engineering went into making this thing work on a budget. If anyone wants to build one of these themselves, I’ve made the CAD files available. I’m also working on putting together a hardware kit that will be coming soon, but until that's ready, the full Bill of Materials (BOM) is available so you can source the parts yourself. submitted by /u/ganacbicnio [link] [Kommentare]
I wanted to see how far AI could actually help with CAM programming, so I ran an experiment. I gave Claude AI a humanoid robot knee joint and asked it to generate the machining strategy for Fusion 360. Then I took those recommendations, built the CAM setup, and machined the actual aluminum part. The result surprised me. It wasn't perfect, and I definitely wouldn't run AI-generated toolpaths without reviewing them, but it got much closer than I expected. A few things I'm curious about: Where do you think AI helps most: setup planning, tool selection, workholding, feeds/speeds, or actual toolpaths? What would it need to do before you'd trust it on your machine? Video here if anyone is interested: https://www.youtube.com/watch?v=L1HeTR-Eawg For context, this part is for an asimov open-source humanoid robot I'm building in my garage. submitted by /u/e-mando [link] [Kommentare]
It turns out LLMs have strong priors over character names that are model-specific and version-specific. If you find Elena Vasquez and Marcus Chen together on a website, there's a good chance Claude generated it. We stumbled on this as a side finding while working on a model diffing method (CDD), and it grew into its own paper. The short version: these names travel as correlated ensembles, appear across dozens of websites as volcano experts, podcast hosts, thriller protagonists, and authors of 1000+ papers published in two months. Then we found a third name in the ensemble. The collage in the comments shows three different websites independently hallucinating the same trio with AI stock photo faces. Preprint: https://arxiv.org/abs/2606.02184 submitted by /u/CebulkaZapiekana [link] [Kommentare]
A direct optimization test was conducted on a neural network for MNIST image classification. The network features a 784-32-10 architecture with a total of 25,450 continuous parameters (weights and biases). Instead of employing backpropagation or gradient information, the parameters were optimized using MDP, a Derivative-Free Optimization method. The objective was to directly minimize the Cross-Entropy Loss on a subset of 5,000 training images. Final evaluations were performed on independent validation and test sets. In the best run, MDP achieved an objective loss of 0.0004083, a validation accuracy of 93.7%, and a test accuracy of 93.4%. These results outperform the baseline established by Adam, which achieved a final loss of 0.002945, a validation accuracy of 91.8%, and a test accuracy of 91.7% using the same network architecture. Notably, this optimization was successfully performed over a 25,450-dimensional search space, achieving convergence across 1,000,000 function evaluations without relying on gradients or population-based methods. The code for this test, along with other Python implementation examples, is available in the examples folder of the official project repository: https://github.com/misa-hdez/sgo-lab submitted by /u/Mis4318 [link] [Kommentare]