Repo: https://github.com/AtharvBhat/fast-vad I needed something comparable to existing open-source VADs in quality, but with a strong emphasis on speed, simple integration, and streaming support. To my knowledge it's the fastest open-source VAD out there. Highlights: - Rust crate + Python package - batch and streaming/stateful APIs - built-in modes for sensible defaults - configurable lower-level knobs if you want to tune behavior yourself It's a simple logistic regression that operates on frame based features to keep it as fast as possible. It was trained using libriVAD dataset ( small version ) If anyone works on Audio, do try it out and let me know how it goes ! Feedback would be helpful 🙂 submitted by /u/AtharvBhat [link] [comments]

Before anyone hits me with "bootcamps have been dead for years", I know. I'm already a data scientist with a MSc in Math; the issue I've run into is that I don't feel I am adequate with the "full stack" or "engineering" components that are nearly mandatory for modern data scientists. I'm just hoping to get some recommendations on learning paths for MLOps: CI/CD pipelines, Airflow, MLFlow, Docker, Kubernetes, AWS, etc. The goal is basically the get myself up to speed on the basics, at least to the point where I can get by and learn more advanced/niche topics on the fly as needed. I've been looking at something like this datacamp course, for example. This might be too nit-picky, but I'd definitely prefer something that focuses much more on the engineering side and builds from the ground up there, but assumes you already know the math/python/ML side of things. Thanks in advance! submitted by /u/_hairyberry_ [link] [comments]

TL; DR: we built a platform that indexes your wandb projects and past experiments and makes it easy for AI agents to analyze and generate new promising hypotheses and experiments. We built new algorithms to be able to ingest and index raw, unstructured, and multi-modal research data and make it available for AI agents. This makes it easy for AI agents to analyze past experimental data to plan and execute new, high quality and diverse research tasks or experiments towards your project goals. It's free so please check it out (https://www.myluca.ai) and let us know what you think. DMs at open. If people are interested, should we work on a Python SDK so that you can bring your own agents (clawed or otherwise)? submitted by /u/hgarud [link] [comments]

I've been teaching myself how to build and tune CNN models for a class, and came across this github from somone who graduated a couple of years before me. I want to improve on their methods and results, and all i can think of is to either expand the dataset (which manually cleaning seems very time consuming) or simply adding noise to the data. I've ran a few tests incramentally changing the noise and im seeing very slight results, but no large improvements. Am i wasting my time? https://github.com/alirezamohamadiam/Securing-Healthcare-with-Deep-Learning-A-CNN-Based-Model-for-medical-IoT-Threat-Detection submitted by /u/wolfunderdog45 [link] [comments]

Tired of always using the Titanic or house price prediction datasets to demo your use cases? I've just released a Python package that helps you generate realistic messy data that actually simulates reality. The data can include missing values, duplicate records, anomalies, invalid categories, etc. You can even set up a cron job to generate data programmatically every day so you can mimic a real data pipeline. It also ships with a Claude SKILL so your agents know how to work with the library and generate the data for you. GitHub repo: https://github.com/sodadata/messydata submitted by /u/santiviquez [link] [comments]

submitted by /u/CryoSchema [link] [comments]

Hi all, I'm doing ML research in representation learning and ran into a computational issue while computing PCA. My pipeline produces a feature representation where the covariance matrix ATA is roughly 40k × 40k. I need the full eigendecomposition / PCA basis, not just the top-k components. Currently I'm trying to run PCA using sklearn.decomposition.PCA(svd_solver="full"), but it crashes. This happens even on our compute cluster where I allocate ~128GB RAM, so it doesn't appear to be a simple memory limit issue. submitted by /u/nat-abhishek [link] [comments]

[P] Hey folks! I built a tool that turns neural networks into readable math formulas - SDHCE I've been working on a small project called SDHCE (Symbolic Distillation via Hierarchical Concept Extraction) and wanted to share it here. The core idea: after you train a neural network, SDHCE extracts a human-readable concept hierarchy directly from the weights - no extra data needed. It then checks whether that hierarchy alone can reproduce the network's predictions. If it can, you get a compact symbolic formula at the end that you could implement by hand and throw the network away. The naming works through "concept arithmetic" - instead of just concatenating layer names, it traces every path back to the raw input features, sums the signed contributions, and cancels out opposing signals. So if two paths pull petal_length in opposite directions, it just disappears from the name rather than cluttering it. It also handles arbitrary interval granularity (low/mid/high, or finer splits like low/mid_low/mid/mid_high/high) without you having to manually name anything. Tested on Iris so far - the 4-layer network distilled down to exactly 2 concepts that fully reproduced all predictions. The formula fits in a text file. Code + analyses here: https://github.com/MateKobiashvili/SDHCE-and-analyses/graphs/traffic Feedback welcome - especially on whether the concept naming holds up on messier datasets. TL;DR: Tool that extracts a readable symbolic formula from a trained neural net, verifies it reproduces the network exactly, and lets you delete the model and keep just the formula. submitted by /u/stron44 [link] [comments]

I'm looking to continue my research into Graph-Oriented Generation (GOG) as a potential alternative to RAG, but I need to establish meaningful benchmarks. I want to build a showcase that proves whether GOG beats RAG or vice versa (honestly, who knows yet!). So far, my testing has shown a massive reduction in token usage and compute—which is awesome. However, it comes with an extreme lack of creativity and out-of-the-box thinking from the LLM. It essentially trades associative leaps for rigid, deterministic logic. It's a fascinating byproduct, but it means I need a highly accurate way to evaluate it. What does it actually mean to "dethrone" or even just rival RAG in a measurable way? In my mind, it comes down to: Higher Quality Responses: (e.g., lower hallucination rates, higher factual faithfulness, better context precision) Resource Efficiency: Lower tokens used, drastically reducing API costs and hardware needs. Are there standard datasets (like MultiHop-RAG or TriviaQA) or specific evaluation frameworks you would recommend using to test this? I want to get more atomic with these two broad categories, but I'm relatively new to formal benchmarking. For context, GOG is the first applied showcase of a broader theoretical framework I'm working on called a "Symbolic Reasoning Model." I want to make sure the foundation is solid before building further. Would love any advice on the best way to structure these tests! --- Anyone interested can see the current benchmark code/repo here. It's evolving and very primordial at the moment, but has potential! https://github.com/dchisholm125/graph-oriented-generation submitted by /u/BodeMan5280 [link] [comments]

Hi everyone, I'm looking for an arXiv endorsement in cs.AI for a paper on persistent memory for LLM agents. The core problem: LLM agents lose all accumulated context when a session ends. Existing approaches — RAG and summarization — either introduce noise from irrelevant chunks or lose information through lossy compression. My approach (Memento) treats memory as atomic, typed "fragments" (1–3 sentences each) rather than monolithic document chunks. The key design choices are a 6-type taxonomy (Facts, Decisions, Errors, Preferences, Procedures, Relations), biologically-inspired decay rates modeled on Ebbinghaus's forgetting curve, a three-tier hybrid retrieval stack (Redis → PostgreSQL GIN → pgvector HNSW with RRF), and an asynchronous pipeline that handles embedding and contradiction detection without blocking the agent's critical path. The system is deployed in a personal production environment supporting software engineering workflows. I'd describe the density improvement over standard chunk-level RAG as substantial, though the evaluation is qualitative at this stage — formalizing benchmarks is on the roadmap. Paper title: Memento: Fragment-Based Asynchronous Memory Externalization for Persistent Context in Large Language Model Agents GitHub: https://github.com/JinHo-von-Choi/memento-mcp If you're a qualified endorser and the work looks reasonable to you, the endorsement link is https://arxiv.org/auth/endorse?x=ZO7A38 (code: ZO7A38). Happy to discuss the fragment-level approach or take technical feedback in the comments. submitted by /u/Flashy_Test_8927 [link] [comments]

Welcome to this week's entering & transitioning thread! This thread is for any questions about getting started, studying, or transitioning into the data science field. Topics include: Learning resources (e.g. books, tutorials, videos) Traditional education (e.g. schools, degrees, electives) Alternative education (e.g. online courses, bootcamps) Job search questions (e.g. resumes, applying, career prospects) Elementary questions (e.g. where to start, what next) While you wait for answers from the community, check out the FAQ and Resources pages on our wiki. You can also search for answers in past weekly threads. submitted by /u/AutoModerator [link] [comments]

Hi! I am a huge F1 fan, but I believe it is one of the most rule-heavy sport. There are thousands of rules and regulations that govern the sport. Over the last few years the sport has gained increased popularity due to Netflix, and now the recently released film. I trained my model on about 1900 PDFs web-scrapped from the FIA website across all races from 2019 - 2025. The user describes the incident involved, for example "moving under braking" or "leaving the track to gain an unfair advantage" etc., a RAG model is implemented to lower hallucinations, and it predicts the penalty that might be implemented. The model also cites the top 3 sources and the respective PDF citations published by the FIA so that the users can read about the rule in detail. Give it a try here: https://huggingface.co/spaces/soumiks17/ai-fia-steward I am happy to share the source code with someone interested. Let me know what you all think. submitted by /u/SoumikSays07 [link] [comments]

We submitted a manuscript to ACL ARR 2026 that received review scores of 4 / 2.5 / 2. The reviewers who gave 2.5 and 2 mainly asked for additional statistical tests. Importantly, all reviewers acknowledged that the study itself is novel. We conducted the requested statistical tests and presented the results in our rebuttal. However, these additions were not acknowledged by the reviewers. Therefore, we submitted a Review Issue Report. In the report, we explained that the lower scores appeared to be based on the absence of certain statistical analyses, and that we had now completed those analyses. We also pointed out that the reviewers had not acknowledged this additional evidence. For the 2.5 review, the Area Chair responded with the comment: Thanks for the clarifications, they are convincing. For the 2 review, the Area Chair commented: Many thanks for the clarifications. Are these positive comments? Any body else got as such comments. submitted by /u/Distinct_Relation129 [link] [comments]

Happy to share that our paper “SymGPT: Auditing Smart Contracts via Combining Symbolic Execution with Large Language Models” has been accepted to OOPSLA. SymGPT combines large language models (LLMs) with symbolic execution to automatically verify whether Ethereum smart contracts comply with Ethereum Request for Comment (ERC) rules. SymGPT instructs an LLM to translate ERC rules into a domain-specific language, synthesizes constraints from the translated rules to model potential rule violations, and performs symbolic execution for violation detection. In our evaluation on 4,000 real-world contracts, SymGPT identified 5,783 ERC rule violations, including 1,375 violations with clear attack paths for financial theft. The paper also shows that SymGPT outperforms six automated techniques and a security-expert auditing service. OOPSLA—Object-oriented Programming, Systems, Languages, and Applications—is one of the flagship venues in programming languages and software engineering. Its scope broadly includes software development, program analysis, verification, testing, tools, runtime systems, and evaluation, and OOPSLA papers are published in the Proceedings of the ACM on Programming Languages (PACMPL). I’m also exploring how to further improve the tool and apply it to other domains. Discussion and feedback are very welcome. submitted by /u/songlinhai [link] [comments]

Been reading a lot of recent sim-to-real papers (LucidSim, Genesis, Isaac Lab stuff) and the results look impressive in demos, but I'm curious what the reality is for people actually working on this. A few things I'm trying to understand: When a trained policy fails in the real world, is the root cause usually sim fidelity (physics not accurate enough), visual gap (rendering doesn't match reality), or something else? Are current simulators good enough for most use cases, or is there a fundamental limitation that better hardware/software won't fix? For those in industry — what would actually move the needle for your team? Faster sim? Better edge case generation? Easier real-to-sim reconstruction? Trying to figure out if there's a real research gap here or if the field is converging on solutions already. Would appreciate any takes, especially from people shipping actual robots. submitted by /u/kourosh17 [link] [comments]

Good to see industry labs spending more time on curating large eval sets, benefits small research groups so much submitted by /u/Lorenzo_de_Medici [link] [comments]

End-summary Building TraceML, an open-source tool for PyTorch training runtime visibility. You add a single context manager: with trace_step(model): ... and get a live view of training while it runs: dataloader fetch time forward / backward / optimizer timing GPU memory median vs worst rank in single-node DDP skew to surface imbalance compact end-of-run summary with straggler rank and step breakdown The goal is simple: quickly show answer why is this training run slower than it should be? Current support: single GPU single-node multi-GPU DDP Hugging Face Trainer PyTorch Lightning callback Useful for catching: slow dataloaders rank imbalance / stragglers memory issues unstable step behavior Repo: https://github.com/traceopt-ai/traceml/ Please share your runtime summary in issue or here and tell me whether it was actually helpful or what signal is still missing. If this looks useful, a star would also really help. submitted by /u/traceml-ai [link] [comments]

submitted by /u/SubstantialDig6663 [link] [comments]

I'm a first-year PhD student and noticed that I'm not funneling down a topic during my PhD but covering a very broad topics within my domain. My core topic is a niche and I'm probably on application side, applying it to very broad range of topics. I'm loving it and I feel it might be a red flag. That instead of mastering an art, I'm just playing around random topics (by how it looks on my CV) submitted by /u/ade17_in [link] [comments]

I combined two recent approaches, Stanford's ACE and the Reflective Language Model pattern, to build agents that write code to analyze their own execution traces. Quick context on both: ACE (arxiv): agents learn from execution feedback through a Reflector (LLM-as-a-judge) and SkillManager that curate a Skillbook of strategies. No fine-tuning, just in-context learning. RLM (arxiv): instead of loading full input into context, an LLM writes and executes code in a sandbox to selectively explore the data. The problem ACE had: the Reflector reads execution traces in a single pass. Works fine for a few conversations, but once you're analyzing hundreds of traces, patterns get buried and single-pass analysis misses cross-trace correlations. The combination: the Recursive Reflector uses the RLM pattern to analyze ACE's execution traces. Instead of reading traces directly, it receives metadata in the prompt and gets full trace data injected into a sandboxed REPL namespace. It then writes Python to programmatically query, cross-reference, and explore the traces -> finding patterns that single-pass reading misses. Benchmark results (τ2-bench, Sierra Research): Measured on τ2-bench, a benchmark that challenges agents to coordinate with users across complex enterprise domains. I ran offline trace analysis on past runs, extracted strategies, and appended them to the agent's policy. The improvement grows with stricter consistency requirements: Metric Baseline With my engine Improvement pass1 41.2% 52.5% +27.4% pass2 28.3% 44.2% +56.2% pass3 22.5% 41.2% +83.1% pass4 20.0% 40.0% +100.0% Claude Haiku 4.5 · pass\**k measures consistency across k consecutive runs Open-sourced it here: https://github.com/kayba-ai/agentic-context-engine Happy to discuss the approach or answer questions about the architecture. submitted by /u/cheetguy [link] [comments]