@MrStickman

Some of you asked for the full pipeline code, so here it is. https://github.com/danieldoradotalaveron-rb/YoloSegment-2D-to-3D-RebotARM_Pick_and_Place submitted by /u/nettrotten [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]

The scarce thing in a data center is not manpower, but instinct that only comes from years on the floor. Most robotics companies are focused on robots as a productivity amplifiers: 24/7 uptime, five days of work done in two. Few are focused on the potential of robots to change how people work altogether. We wanted to show what it looks like to rethink human-robot collaboration, using AI so a shrinking pool of experts can meet the increasing demands of future infrastructure. The obvious thing to automate is the rote physical work that consumes an expert's attention without needing critical judgment. Cabling tasks are the most common example of this. They're necessary when setting up any rack, but usually one-off, and labor is readily available to address this need. We think this is a good place to start, but the least interesting place to change how people work. Standard operating procedures (SOPs) are how critical infrastructure stays stable, and they're the work that scales worst. The video shows one common procedure: clearing the cables a technician leaves behind after testing, and reconciling the rack to a stable state for the next test. A robot that runs SOPs the same way every time, never skipping a step, keeps the system in a known, predictable state. This reduces the cognitive overhead on experts so they can solve harder problems. What most excites us is robots guiding where an expert's attention should go. In the video, the robot checks the switches with a thermal camera, then makes a judgment on whether the increase in temperature is a real problem or a spurious reading. This instinct requires an expert to synthesize all available background context and accumulated lessons from past failures. This is where we want to double down, and show how human-robot collaboration places scarce expert attention exactly where it matters. More to come. submitted by /u/kuaythrone [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 have some 35-48v 500w bldc motors (e-skateboard motors) that I want to use for my robotics projects. They are much higher power than the small gimbal motors I typically use with Simple FOC drivers, so I'm wondering what's the typical setup for these high power motors. Power supply: better to use a big lipo battery or a wall power supply? From what I've seen, batteries can provide more current but are kind of dangerous? Controller: I want to use an FOC drive to precisely control position. the motor has an encoder built-in. I was looking into the ST G431 driver, but I'm not sure if it can handle so much power. I'm quite new in BLDC control and high power electronics, any advice or info would be really helpful! submitted by /u/the_relentless_epee [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]

Weekend project, one weekend in — lots still half-built: a 6-DoF SO-101 arm (Feetech STS3215 / LeRobot) with a wrist camera, driven by an agent that plans camera moves, films them, and stitches the edit. Sharing v1 — rough, but the loop works. The demo is a side-by-side: left is an external phone shot (manual), right is the arm's own wrist camera. The choreography — wake → framed "hero" pose → dolly/roll/tilt beats → rest — runs through a safety layer (soft joint limits + velocity cap + stop sentinel). A few things I hit that others might find useful: 🔧 Dead elbow servo, diagnosed by feel. Stiff to backdrive, idle temp 53°C vs ~38°C on the others = shorted/lossy winding. Swapped it, re-set the ID, recalibrated the joint. 📐 The jerky motion wasn't the servo or the mount. Braced the table and it still jerked — turns out it's STS3215 gear backlash (~0.87° measured by others) plus low-speed stick-slip. Confirmed stick-slip is speed-dependent: ~51 backward micro-ticks at 12°/s vs ~0 at 50°/s. ✅ The fix: dropped P_Coefficient 32 → 16 (LeRobot's own recommended value). Slow-speed judder went from ~43 stutter events/sweep to ~0 in a controlled A/B. Plus: keep recorded moves single-direction and faster. 🎯 No IK yet, so "orbits" drift. Leaned on framing-safe moves — roll about the optical axis, dolly, tilt — to keep the subject centered. The goal is reusability: clone the repo, build/attach the SO-101, and you can direct Claude to film your own demos. Still manual for now (external camera + initial framing/hero pose). Next up: better camera, longer scripts, closed-loop framing. As always, it's all open source — control lib, safety layer, calibration, and the motion/stitch scripts. I will organise it better once the project is complete 👉 https://github.com/kamalkantsingh10/dummie Happy to go deeper on the motion-streaming / backlash tuning if useful. submitted by /u/KamalSingh10 [link] [Kommentare]

Unlike previous editions of IROS/ICRA, there seems to be no IEEE RAS travel grant on the IROS 2026 website this time, the only grant available is the IES-SYPA grant for upto 15 people. Is this not really less compared to any previous editions? submitted by /u/sarthaxbeatz [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]