标签：#MachineLearning

Hey guys, I was playing around with Nanotron recently and got super frustrated by how many heavy, hardware-specific dependencies it imports at the module level ( flash-attn , triton, functorch , etc.). If you try to run it on older or budget GPUs like a T4 or V100, it just crashes on import. So I wrote Picotron ( https://github.com/Syntropy-AI-Labs/picotron ) to solve this. It's a clean-room rewrite that gets rid of all mandatory GPU-specific dependencies. It runs on pretty much any GPU that supports PyTorch (defaults to FP16 on older cards under compute capability 8.0, and BF16 on newer ones). It falls back to standard PyTorch SDPA by default, but still hooks into FlashAttention-2 at runtime if it detects you have it installed. I used an AI assistant to write a lot of the boilerplate/code modules, but I've got it working locally and just trained a tiny 2M model on FineWeb-Edu. Also added configs for: • GQA / MLA (Multi-head Latent Attention) • QK-Norm & logit soft-capping (Gemma 2 style) • Parallel FFN/Attn runs • ZeRO-1 wrapping on DDP Roadmap is pretty short right now: MoE prep (routing capacity factors and load balancing loss) Making dataset prep easier than streaming manually Check it out if you've been fighting with CUDA dependency hell: https://github.com/Syntropy-AI-Labs/picotron submitted by /u/Capital_Savings_9942 [link] [留言]

Hey everyone, I'd like to share my project along with a short explanation of the process and why it came about in the first place. To start off, I'm not exactly the best at cryptography/steganography, in my case it's always been something that sat in the background, as one of the sub-fields needed for another (main) field I'm actually interested in. For this project I tried to look up as much information as possible about what's currently considered best practice (I mainly relied on NIST for this), what implications exist, and what potential "attacks" exist against this way of hiding information, but I honestly can't say whether I covered everything, which is why I wanted to share this project here, mainly for the sake of learning. I'd be grateful for any feedback on what I could have done better / what I might have missed, etc. Right now, I consider this project closed at this point and will most likely not update it further, although I'd like to apply all the feedback to my own knowledge going forward. For over a month I did a lot of research into using ML models as a carrier for hiding data. I needed this as one of the stages for my main project. That's how I ended up on the topic of hiding information in model weights. Initially I assumed a simple method of directly writing data into randomly selected weights. I quickly concluded, though, that this would be absurdly trivial to detect, and potentially also to read. Next came the idea of using something like a deterministic coordinate map describing where to read the data from (location-id + position-id). The program wouldn't modify all the bits needed to write the message instead, it would write separate bits representing already-existing values (pointing to specific locations in the model) from which the existing 0s and 1s would need to be read. In practice, only parties A and B would know how to derive these positions. This way, someone unaware of the algorithm would only see what looks like noise of varying va

Hey all, a bit of background - I'm an ex Amateur MMA fighter and BJJ brown belt and am also in the AI/ML space ... weird combo but wanted to know if anyone else was at the intersection of ML/AI and MMA/BJJ. In short, I'm building AI models that "watch" fights and are able to detect positions and moments throughout the fights - things like standing vs clinching vs ground (with intention of becoming more granular in time) along with detecting knockdowns, takedowns, etc. There's a timeline at the bottom of each fight with markers for different moments so you can jump straight to them. Anyway this is where my worlds collide and was curious for thoughts for anyone who wants to check it out. If you do, it's at https://cagesight.ai . All feedback welcome. Thanks all. submitted by /u/UnholyCathedral [link] [留言]

Hey ! I’m starting a series to document my work on GPU infrastructure, LLMs, and CV. Stop #1 is up: A brief look at why GPUs are the center of the industry, the CPU/GPU divide, and why nvidia-smi is the first place you check when things break. We’ll move past the basics quickly to focus on: Empirical architecture differences (Ampere vs. Hopper vs. Blackwell). Handling register pressure in custom kernels. Asynchronous memory paradigms (TMA/wgmma). #CUDA #GPU #KernelOptimization #SystemsProgramming submitted by /u/Positive_Canary1723 [link] [留言]

It is like pytest but for statistical tests: it ensures no regression of your metrics at a statistical level. It manages tedious things such that seeds, past benchmark results, ... Simple CLI working like pytest but with benchmarks/ directory instead of tests/: pybench # 1st time: samples seeds, saves a baseline, marks NEW pybench # later: reruns on the same seeds, marks PASS / FAIL pybench update # re-baseline after an intended change pybench show # print current baseline stats (--history for per commit) Please give me your feedback, Github: https://github.com/AnthonyBeeblebrox/pybench Docs: https://pybench.readthedocs.io/en/latest/ submitted by /u/SpecificPark2594 [link] [留言]

I submitted one of my NeurIPS review ~6 hrs later than the official deadline. Will this still affect my own submission? Asking because I’m a first time reviewer. I pinged the AC a day before that I might be a few hours late, but didn’t hear back. So wondering if I might have triggered something that’ll now affect my own submission. submitted by /u/confirm-jannati [link] [留言]

the insight that started this project hit me while i was finishing a bytecode-compiled language i'd written in C i'd spent months building a hand-written lexer, a single-pass Pratt compiler, a stack VM with 35 opcodes, and a mark-and-sweep garbage collector. and right near the end i had this realization: an LLM inference engine is the same problem. it's a graph-compile plus memory-plan plus kernel-schedule problem. i'd just built one so i decided to find out if that was actually true the project the result is ignis, a from-scratch LLM inference engine in Rust. i used it specifically to see how far the compiler analogy held up. the dependency count ended up at 2: memmap2 (to mmap the weight blob off disk) and fancy-regex (for one look-ahead in the BPE tokenizer). everything else is hand-written, because the whole point was to understand what's actually happening the compiler analogy holds up better than i expected the interesting part of any inference engine isn't loading the weights or doing matrix math. it's what happens between "here's a compute graph" and "here's an efficient execution plan." that's a compiler problem ignis builds an SSA (static single assignment) IR of the entire Qwen2 forward pass. every operation in the transformer (the RMSNorm layers, the SwiGLU activations, the attention projections, all of it) becomes a node in the graph with explicit data dependencies then fusion passes run over the graph. the intuition is simple: if operation B always and only reads the output of operation A, you can merge them into one op and eliminate the intermediate buffer. in practice this fused 49 RMSNorm ops and 24 SwiGLU ops, bringing the total from 435 operations down to 362 that part felt expected. the liveness analysis surprised me the liveness analysis after fusion, the graph still needs activation buffers: scratch memory to hold intermediate results as the plan executes. the naive approach allocates one buffer per node. the smarter approach asks: which buffer

You don't have a million labeled images or a GPU farm — and you don't need them. Transfer learning lets you stand on a model someone else trained and reach high accuracy with a few examples in minutes. Here's the idea, visualized. ♻️ Race scratch vs transfer: https://dev48v.infy.uk/dl/day17-transfer-learning.html The insight The early layers of a trained network learn general features — edges, textures, shapes — that are useful for almost any vision task. Only the last layers are task-specific. So why relearn edges from scratch? Two ways to do it Feature extraction: freeze the pretrained backbone, replace the final classifier with a small new "head," and train only the head on your data. Fast, needs little data. Fine-tuning: also unfreeze the top few backbone layers and train them at a low learning rate so you adapt without wrecking what they learned. The demo races two accuracy curves: "from scratch" crawls up and plateaus low (not enough data); "transfer learning" starts high and climbs fast. Tweak the example count and freeze/fine-tune to see them respond. Why it matters now This is exactly why fine-tuning an open LLM works: a foundation model already learned language; you adapt it cheaply. Transfer learning is what makes deep learning practical for the rest of us. 🔨 Full recipe (load pretrained → freeze → new head → train → optionally fine-tune low-LR) on the page: https://dev48v.infy.uk/dl/day17-transfer-learning.html Part of DeepLearningFromZero. 🌐 https://dev48v.infy.uk

While experimenting with GRPO training, I kept running this shit that when reward increases, it becomes difficult to tell whether the policy is genuinely improving or simply exploiting the reward function. So I built a small library called rewardspy that wraps an existing reward function and continuously monitors indicators that often precede reward hacking. It currently tracks things like rolling reward statistics, reward variance collapse, reward component imbalance, response length drift, reward slope changes, GRPO group collapse, anol. This is my first major RL project so I would absolutely love some technical advice Check it out here: https://github.com/AvAdiii/rewardspy (credits to u/Oranoleo12 , posting on their behalf) submitted by /u/BaniyanChor [link] [留言]

This is just an opinion of what I experience and am witnessing, but looking at how LLMs scale feels like I've seen it before: with CPUs trying to outrun Moore's Law and break the rules of physics. Heat, power leakage, and diminishing returns made it increasingly expensive to squeeze out even small gains in clock speed. The GHz race shifted because it had to. For LLMs, more compute, more data, more parameters, and everything just keeps getting better? That curve seems to hit a ceiling and innovation needs to succeed the scaling race now. History does not repeat itself, but it rhymes. What learnings can we make from history to "predict" a potential future? History In the early 2000s, CPUs ran into a wall, a very physical one ^^ So makers adapted. Instead of crunching every single watt out of a single core, multi-cores became common. Athlon 64 x2, Pentium D, PS3 with its heavy Cell approach. From linear to parallel. From sequential to multi-threaded (and funny race conditions ;). Talks of distributed systems, SIMD/MIMD and new benchmarking spawned into what we have today. We still use CPUs, but differently. We still have Memory, but think about Cache, RAM, GPU or Unified. Same same, but different. Innovation because of limitation. Present I feel something similar is about to happen to gen AI. Yes, there are improvements in different areas, some in scaling, some optimisation, some performance, but the slope is becoming slippery. The last 12 months went from "Opus 4.5 is the pinnacle" to "What the hell is wrong with Claude?". The perfect (business) storm of scaling execution! But the low-hanging fruits have been eaten and the crops don't grow as fast anymore. Costs rise quickly, latency becomes a constraint, and even large context windows feel more like extensions than breakthroughs. What remains is more incremental, more expensive, and more complex. You could argue the whole venture of "agents" is the same multi-core experience repeating itself. A different kind of orch

My question on live continual learning use cases was removed by moderators here because they think i asked basic level question about live continual learning which i thought is a frontier level research. But anyways. Is anyone interested in talking about continual learning (live) and catastrophic forgetting? submitted by /u/fourwheels2512 [link] [留言]

I've been developing an AI product using LLM APIs (from OpenRouter) but want to deploy an open-source LLM in my own Prod env. which I can control. Few reasons behind this are: - I wanna own the complete stack around my product. - Second I wanna fine-tune the model around my usecase. So, what's the most affordable but a good platform for this? I'm not an AI engineer so don't wanna stuck in CUDA or Transformers hell, anything which can give me a straight path towards my private deployment. Thanks, submitted by /u/Necessary_Gazelle211 [link] [留言]

Sharing a project I have been working on called Third Eye. It does visual geolocation. Given a video, it figures out where it was filmed using only the image content, and draws the route on a map. Pipeline in short: per frame place recognition against a street imagery index a trajectory search that stitches the frames into one coherent path a geometric verification step to catch false matches per frame confidence so weak frames are flagged, not faked I ran it on real dashcam footage and it traced the route quite well. Cross domain matching like this is genuinely hard, so a fair amount of the work went into making it honest about uncertainty. Keen to hear feedback on the matching and trajectory side. Video Demo: https://youtu.be/U3sItFlvq6E?si=-KJrwb0gSlk-GxVH The Index was covering a 12KM 2 Area around NYC. submitted by /u/Ok-Apricot956 [link] [留言]

A deep dive into the podcasts, papers, tweets, and tutorials of the engineer who made me add a fifth...

source files + final paper pdf. ZIP containing the source files and final paper.pdf. Where does the supplemental materiel get uploaded? Because in that email it says include it in a "supplementary_materiel" folder. this is all very confusing. can someone clarify? submitted by /u/redskydawns [link] [留言]

I've been experimenting with a compiler/runtime project that I'm not entirely sure is a good idea, so I'd love some feedback from people who've worked on deployment systems. The idea is to compile an exported PyTorch model into a self-contained package that contains: graph binary weights backend kernels (currently WGSL) runtime metadata A lightweight runtime loads that package and executes it directly in the browser with WebGPU. No Python, no server inference, and no dependency on a heavyweight runtime. Right now the attached demos are just neural video representations because they were easy to test, but the motivation is actually operator networks and scientific ML, where I like the idea of distributing a single portable artifact. The repo is here: https://github.com/Slater-Victoroff/Kuma I'm mostly looking for architectural feedback. Some questions I'm wrestling with: Is embedding backend kernels in the artifact a terrible idea? Is this solving a real deployment problem or just reinventing ONNX Runtime? Are there existing systems I should study that take a similar approach? If you were designing a deployment format today, what would you change? I'd especially appreciate thoughts from people who've worked on ONNX, IREE, TVM, ExecuTorch, MLIR, or similar compiler/runtime projects. submitted by /u/svictoroff [link] [留言]

Since the steam sale is live I wanted to post a Dev log on my personal project https://nextsteamgame.com/ sharing some outcomes from the web traffic and how I changed the project from the great feedback I got! I made a post about a month ago explaining how I made this opensource explainable search engine built around steam reviews to people find new video games, Not through Relevancy but through aspect based similarity. Check out the old post for a better explanation if you want! https://www.reddit.com/r/MachineLearning/comments/1tb8k3n/steam_recommender_using_similarity_undergraduate/ I wanted to say thank you to all the people of r/datascience and r/MachineLearning that gave me feedback and tried out my tool! I improved the UI/UX of the website to make the vectors more clear and controllable, I Implemented a thumbs up and down feature on recommendations to see if users even like the tool. I also wanted to share the after effects of promoting this tool on reddit! from the 2,652 searches I got in the website 913 of them resulted in steam clicks! the games that were discovered were all in a uniform distribution and did not share much of a pattern showing me that the engine did its job in helping people find niche games across all genres! (More images attached to post to see data viz) I wanted to disclose that I made this tool to not make any profit of some kind, but it does use posthog so I can collect diagnostics now. submitted by /u/Expensive-Ad8916 [link] [留言]

In the recent Springer/Meteor email, it says: The deadline for the upload of the camera-ready manuscripts and source files is 30 June. This is a hard deadline and will not be extended. However, in the same email, the Meteor submission line for my paper says: submission due: June 27, 2026 A previous email from the ECCV Program Chairs also stated that the camera-ready deadline had been extended to 30.06 AoE and that this deadline is final. Does anyone know whether June 27 is just an internal/default Meteor due date, or whether it is the actual deadline for uploading in Meteor? Since the email says there is only one upload and the first upload is final, I want to avoid uploading too early if June 30 is the correct deadline. this is really confusing. submitted by /u/National-Resident244 [link] [留言]

What if there was a new programming language where the meaning of each token was so dense (or perhaps so specific) that an LLM could write robust code with fewer tokens and faster inference? Assuming there’s enough training data, do you think something like this allow an LLM to write better code faster? Rationale: 1) It would allow for faster inference. Fewer tokens required to do the same thing in Python = finish faster. 2) It would allow for more information in a 1M context window. Whatever you could fit in 1M tokens of Python, you could do 100x that in this theoretical language. 3) It would effectively remove the “noise” from human readable language (semi-colons, curly braces for example) which I would think would make the LLMs coding ability stronger. I could be wrong about this of course. submitted by /u/Spongebubs [link] [留言]

Token-based billing is causing my company to reevaluate small language models. I came across this paper that shows SLM supervised fine-tuning on traces from orchestration of frontier models can be nearly as performant and much cheaper. Has any tried this in the real world? submitted by /u/ThirdWaveCat [link] [留言]