@MrStickman

So, from what I've seen across twitter(x) and reddit, I've inferred that we'll be seeing NeurIPS reviews drop on July 22nd 5:30 pm AoE(Anywhere on earth), what's your thoughts to those who've submitted to NeurIPS 2026 ? Would love to hear your opinion by the reviewers, the people who've submitted to the workshops (who should've already gotten their decisions too by now I think) and to the main tracks and other available tracks. submitted by /u/Practical-Buddy6323 [link] [Kommentare]

I've been working on incremental indexing pipelines lately, basically keeping a vector store in sync as the source data changes, and I keep finding the same bugs never show up until it's been running a while. Biggest one for me is deletes. I tested the "new doc comes in, gets embedded" path a hundred times and it was fine. Never really tested what happens when a doc gets deleted upstream. Turns out if you don't handle that, your index just keeps growing with stuff that shouldn't be there anymore, and you don't notice until search starts returning weird results. Partial updates got me too. I didn't want to re-embed a whole doc every time something small changed so I did partial updates instead. Cheaper, but I ended up with drift between what's in the index and what's actually true in the source, especially once chunk boundaries moved around. Didn't notice until a query happened to hit the stale part. Also learned the hard way that idempotency isn't optional. My pipeline gets retried and backfilled all the time, and if reprocessing the same input twice doesn't give the same result, I get duplicate docs every time something routine reruns. None of this feels like new information, it's just normal distributed systems stuff, but I feel like it gets way less discussion than embedding models or chunking strategies. Anyone else dealt with this or have a setup that's actually held up long term? submitted by /u/Whole-Assignment6240 [link] [Kommentare]

Thrilled to announce the VultronRetriever family of models, which were announced during Raise Summit Paris and demonstrated running Q&A and embedding documents on the iPhone, fully offline! 📱 Some highlights from the VultronRetriever model family: 🥇 Each model ranks #1 in its respective class on the MTEB Leaderboard, with VultronRetrieverPrime-8B as the global #1 📦 VultronRetrieverPrime-8B has up to 16x smaller index storage footprint and 12x higher throughput versus previous 9B-class leaders 🎯 VultronRetrieverCore-4.5B ranks second only to Prime on the leaderboard, outperforming models twice its size ⚡ VultronRetrieverFlash-0.8B outperforms models up to 5x its size, runs cool on edge devices, and indexes up to 60 images per minute, fully offline! 🐍 Deploying the VultronRetriever models with the Hydra Architecture gives you late interaction retrieval at unparalleled precision, plus generation at up to half the memory of comparable models 🧪 All models were trained on datasets with 0% cross-dataset duplication and 0% eval contamination, and show no overfitting on privately run MTEB evals Grab them, break them, make them your own 🔧 🏆 Prime: https://huggingface.co/vultr/VultronRetrieverPrime-Qwen3.5-8B ⚙️ Core: https://huggingface.co/vultr/VultronRetrieverCore-Qwen3.5-4.5B ⚡ Flash: https://huggingface.co/vultr/VultronRetrieverFlash-Qwen3.5-0.8B 📊 MTEB Leaderboard: https://mteb-leaderboard.hf.space/benchmark/ViDoRe(v3)) 🐍 Hydra Architecture: https://arxiv.org/abs/2603.28554 submitted by /u/madkimchi [link] [Kommentare]

Hello r/machinelearning! I've been working on a protocol for a bit now and have just released a whitepaper with the implementation on GitHub. It's a spec and reference implementation for a coordination layer where every message is signed, every state change is hash-chained into an audit log, and a privacy guarantee is enforced by routing precedence rather than by policy. There's an optional ZK principal-attestation primitive (heavy handshake vs. default Apache 2.0) in the spec. The handshake (capability intersection) is a setup step; the audit log is what the protocol actually delivers. The protocol is not agent-specific, but a motivating use case is auditing how autonomous agents operate; the audit log gives the verifier the same answer the operator gets; any cross-organizational service coordination is in scope. Five invariant(s) at the core: Every message is signed (Ed25519 over canonical JSON, RFC 8785) Every session has a capability-intersecting handshake Every state change produces a hash-chained audit entry Principal identity is attested by a use-once ZK proof, not transmitted Personal data is forced local by routing precedence (the first thing the router checks - no override) Spec (CC BY 4.0): https://github.com/githubscum/aip-protocol/blob/v1.1.0/docs/aip-v1.0-spec.md Whitepaper (CC BY 4.0): https://github.com/githubscum/aip-protocol/blob/v1.1.0/docs/AIP-whitepaper.md Reference implementation (Apache 2.0): https://github.com/githubscum/aip-protocol Cite (Zenodo DOI): https://doi.org/10.5281/zenodo.21267380 Bitcoin-anchored OTS chain: whitepaper, spec, release tarball, and v1.1.0 commit SHA-256 all attested in Bitcoin blocks 957210–957217 (mined 2026-07-08). See dev-logs/ots/ in the repo. Author (ORCID): https://orcid.org/0009-0006-2476-1615 Looking for feedback on the wire format, the audit chain, and the routing precedence rules, thanks for taking the time! submitted by /u/rredditscum [link] [Kommentare]

Thinking about getting two months at his website and getting a stronger understanding of machine learning since I am building tools with ai models from hugging face. Have anyone tried it? submitted by /u/TheSmashingChamp [link] [Kommentare]

I’ve been working on a project called MemoryOps AI. The problem I’m trying to solve is context debt in AI agents. Most memory demos look like this: chat message → vector database → retrieve later That works for demos, but I think production agents need more than retrieval. They need rules for what memory is allowed to survive, what should expire, what should be blocked, what can be updated, and what must be audited. MemoryOps AI treats memory as governed state. The lifecycle is: Capture → Evaluate → Store → Retrieve → Rank → Compose → Update → Forget → Audit Some things I built into it: Policy-before-storage, so sensitive/secret-like content is filtered before memory is saved Typed memories instead of one generic memory bucket Tenant isolation Deletion guarantees Provenance for stored memory Append-only audit logs Retention policies Legal hold Consent-aware memory Background workers for lifecycle tasks A small playground/demo to test memory behavior I’m not posting this as a polished company launch. I’m mainly looking for feedback from people building agents, RAG systems, evals, or AI infrastructure. The questions I’m trying to answer are: What should an AI memory system be allowed to remember? How should old memory expire or get overwritten? How would you test that deleted memory never influences future output? What invariants would you expect before trusting memory in a real assistant? GitHub: https://github.com/patibandlavenkatamanideep/memoryops-ai Demo: memoryops-ai-production.up.railway.app Would appreciate any technical feedback, especially around memory lifecycle design, governance, and evals. submitted by /u/Fit_Fortune953 [link] [Kommentare]

Hey! The EML function made the rounds recently on the internet as a “cool trick” that allows for the representation of all elementary functions through composition. As a mathematical curiosity, we prove a universal approximation theorem for EML(-type) trees. Intuitively, one expects that if elementary functions can be presented by compositions of EMLs, then so too can polynomials, and polynomials are dense in other functional spaces (like continuous functions or certain Sobolev spaces), then one expects to be able to approximate (to desired accuracy) any function (in a reasonably general space) through an EML tree (with an upper bound on size and depth). One of the key steps in the proof (detailed in the appendix) is an explicit construction of EML(-type) representation of binary operations, polynomials, hyperbolic tangent, and approximate partitions of unity, and subsequently using them as “LEGO” blocks to get more complex functions. There are some technical difficulties that need to be dealt with in the proof, especially in what relates to the the ill-definedness of the natural logarithm for nonpositive inputs, which prompts us to do some “sign-based decompositions” in Theorem1.Step 5 and a suitable affine map in Corollary 1. Comments are welcome! Paper: https://arxiv.org/pdf/2606.23179 (Note: I use the term “EML(-type)” in the above description because, due to some theoretical and practical reasons detailed in the paper, we generalize the original EML function by adding some learnable parameters.) submitted by /u/JoeGermany [link] [Kommentare]

I've been thinking about this for a while. AI can now write functions, explain code, refactor projects, generate tests, and even solve many programming problems better than many junior developers. I've also noticed that Stack Overflow seems far less active than it used to be because many developers now ask AI instead. This made me wonder: Is learning algorithms still as important as it used to be? I'm not talking about memorizing LeetCode solutions for interviews. I mean actually spending months studying data structures and algorithms. If AI can generate efficient implementations, explain the complexity, and even optimize code, where is the real value in deeply learning algorithms today? Do experienced engineers still think it's essential, or is understanding the concepts enough while letting AI handle the implementation? I'm curious to hear opinions from people working in the industry. submitted by /u/Senior_Note_6956 [link] [Kommentare]

Hello, I'm currently working on my dissertation and feel like I could really use some advice from someone who looks at the problem with fresh eyes. I appreciate all input. The Problem: Multi Agent Path Finding is the problem of finding paths for several agents to their destinations. Lifelong MAPF is the same, but upon task completion an agent is assigned a new task. For my dissertation (and usually in research) agents move on a grid-like graph and time is discrete. Each timestep an agent can move to an adjacent tile or wait. A good LMAPF algorithm creates paths which maximise average jobs completed per timestep. Some LMAPF algorithms can also work on weighted graphs where each edge to an adjacent node (or itself) has its own cost. Such a graph is called guidance graph and the choice of edge weights can influence which paths the LMAPF algorithm creates also impacting throughput. My supervisor wanted to explore whether Evolutionary algorithms can be suitable for finding a guidance graph that improves throughput without changing the underlying LMAPF algorithm. A guidance graph is scenario specific meaning it is optimised for a specific LMAPF algorithm, map, and agent count. My algorithm so far: So far I've implemented a very basic evolutionary algorithm. An initial population of guidance graphs is randomly initialized (Limited to 10 at the moment). Then each candidate is plugged into the LMAPF algorithm for a certain amount of time steps and the completed jobs are counted to create that candidates fitness score. The top (2) candidates are selected and the rest are discarded. The top candidates are used to make a new set of candidates (no crossover). These step are repeated indefinitely. Issues I've has so far: The simulation can use a seed and is deterministic. The seed determines which nodes the jobs appear on. Using the same guidance graph but different seeds yields random fitness scores. The higher the simulation time the lower the coefficient of variation (standard deviation/mean). For 5000 steps the CV is 0.006. Using guidance graphs with the same parent graph and on different seeds should yield throughputs that have a much higher CV than 0.006 in order for the selection of the best candidates to be somewhat reliable. You could make the argument that given enough time statistically speaking the best candidate will tend towards a better guidance graph but if 9/10 of the candidates I create are worse than the best of the last generation then the solution will tend towards getting worse with each generation. It seems there are so many ingredients for a working evolutionary algorithm that I am missing: I need a mutation strategy that creates solutions with high enough amount of variation but that don't create better offspring once in a blue moon. Also simulating 5000 time steps takes roughly 30 seconds so 300 seconds for one tiny generation of 10 candidates. If my guidance graph is a 25x25 grid -> 625 tiles -> 3125 weights. If my mutation strategy changes 10 weights at a time it will take years to go through enough iterations to even tough every weight once. If the mutation strategy changes more than 10 weights at a time the change of good changes cancelling out bad ones increases. Mutation strategies I've tried are: 1. Iterate through each weight. Each has a certain chance of getting mutated by a random amount. 2. Select n amount of tiles. Mutate the 3x3 area around that tile. Each tile gets the same changes. 3. Create n pair of nodes. Calculate the shortest path connecting the nodes of each pair and lower the weight of the edges along that path in one direction while increasing the weights against the direction. The third method has worked best yet decreasing throughput for low agent counts but increasing throughput for high agent counts by avoiding congestion. However I can't attribute this "success" at all to the evolutionary algorithm but only to the mutation strategy. The other strategies have only produces worse results than a guidance graph with uniform weights. My supervisor is convinced that there is a way to make this work but I have doubts. Any advice would be very appreciated. submitted by /u/Michi122211 [link] [Kommentare]

Hey everyone! New to the subreddit so please forgive if I have broken some rules. I am approaching ML and wanted to ask what the community thinks the best online courses are. Could you please recommed who offers the best overall programs and maybe some advantages and disadvantages of the various platforms teaching these topics? Thank you so much! submitted by /u/Life-Relationship126 [link] [Kommentare]

I work in firmware adjacent to AI, so not an ML guy exactly, so that's why I've come here. For work we got a bit concerned about Mythos and all the hype made me explore some benchmarking work. I now have this pretty cool benchmark that's about 80% done sitting around and haven't had the time to polish it up and show it off. I was hoping some more AI focused people could check it out, tell me if it's duplicate work, or if it is worth putting some time into and finishing. Also happy for some help too. The rundown of the code is that it is Juliet code that's been "hidden" to look somewhat like a real codebase, removing LLM's natural advantage when viewing known CWEs, while preserving the "ground truth" associated with Juliet. I also used an LLM to inject comments into the code in accurate, misleading, or neutral sentiments, allowing the user to examine how comments and plain English data can manipulate an LLMs ability to identify a CWE. There are a couple hundred CWEs, generally enough code to fill up the input context, the work that needs to be done is around presentation, actual benchmarking of publish LLMs, and possibly pruning of a couple CWEs that might occasionally get caught by certain LLMs as Juliet code still. Here's the project. Hopefully this doesn't break rule 6. I am not a regular here, just looking for advice. submitted by /u/Psychological_Meat_6 [link] [Kommentare]

Recommend some of the best modern books about probability and/or statistics to help you get that probability intuition or mindset needed to excel at ML, from beginning to advanced or separated please! submitted by /u/c_carav_io [link] [Kommentare]

I was pondering on this question and decided to dive deep into torch.compile. It was a lot of fun learning about operator fusion as the central idea behind torch.compile. So I created a tiny version of torch.compile in 500 lines of python and a notebook showing how this works: https://github.com/purohit10saurabh/tinytorchcompile Let me know if you find this interesting! 🙂 submitted by /u/Other-Eye-8152 [link] [Kommentare]

I trained a 128×128 DCGAN on my Macbook M3 and deployed it on a Raspberry Pi 4 connected to a LILYGO TTGO T-Display ESP32. The whole thing runs headlessly as a systemd service and generates hallucinated face hybrids at the press of a button. It is a 6-block generator (latent → 4×4 → 8×8 → 16×16 → 32×32 → 64×64 → 128×128) with feature maps starting at f×16=1024. Corresponding 6-block discriminator. Trained for 800 epochs on Apple Silicon MPS, 4 hours. Dataset was 2480 images across 11 subjects. One dominant anchor class (2000 images) contaminated with minority classes to produce hybrid outputs. (Can you guess who and what was included?). : ) I exported the model from PyTorch to ONNX (float32, 53MB). Inference takes 3 seconds per face on Pi 4. The Pi generates the face and sends it to the ESP32. The title is generated through a dictionary and a template sentence: "This is a NFT and I want to it." The device was built as an art piece. I took it to the streets of NYC and let strangers use it. Full video: https://youtu.be/y-S74aoud54?si=yPh5GmCJZFIIzwq6 Happy to discuss the training pipeline, ONNX conversion, or anything you're curious about. submitted by /u/Numerous-Dentist-882 [link] [Kommentare]

Hi everyone, I have a fairly weak undergraduate: a 3.3/5 GPA in Computer Engineering from an average Nigerian university. For my Master's, I studied Artificial Intelligence at an average European university, where I finished with an 8/10 GPA. A condensed version of my Master's thesis was recently accepted at ACL 2026, with a meta-review score of 8/10 and a confidence score of 5/5. It's scheduled for presentation next month. I want to pursue a PhD focused on expanding linguistic resources for low-resource African languages. I know my weak undergrad GPA and the relatively unknown reputation of my previous universities will make it hard to get into top NLP programs (CMU, Edinburgh, ETH, MBZUAI, etc.), though I'm hoping the ACL paper helps offset that somewhat. At the same time, I don't want to end up at a less competitive university just for the sake of getting in somewhere, if it doesn't do meaningful work on low-resource NLP. How should I think about structuring my application strategy here (reach vs. safety schools, how to frame my profile, what to emphasize)? I'd also genuinely appreciate honest feedback on my overall profile. Thanks. submitted by /u/Unlikely_Screen_9287 [link] [Kommentare]