标签：#mac

In the previous article , we started with a brief introduction to tensors . In this article, we will explore why tensors are useful . Why Tensors Matter Unlike normal scalars, arrays, matrices, and multi-dimensional matrices, tensors are designed to take advantage of hardware acceleration . Tensors do not just store data in different shapes. They are also designed to perform mathematical operations on that data efficiently and quickly . Tensors and Hardware Acceleration Tensors can take advantage of GPUs (Graphics Processing Units) , which many of us use in our day-to-day devices. GPUs are very good at performing many mathematical calculations in parallel, making them useful for training neural networks. There is also specialized hardware called TPUs (Tensor Processing Units) . TPUs are specifically designed to work with tensors and help neural networks run even faster. Automatic Differentiation Another important use case of tensors is in backpropagation . In neural networks, we estimate the optimal weights and biases using backpropagation. This process requires calculating many derivatives and applying the chain rule . Instead of manually calculating all these derivatives, tensor frameworks can handle this automatically using something called automatic differentiation . This means that even as neural networks become more complex, tensors help manage the difficult mathematical calculations behind the scenes. So that is it for tensors. In the next article, we will explore another topic AI agents write code fast. They also silently remove logic, change behavior, and introduce bugs -- without telling you. You often find out in production. git-lrc fixes this. It hooks into git commit and reviews every diff before it lands. 60-second setup. Completely free. Any feedback or contributors are welcome! It's online, source-available, and ready for anyone to use. Give it a ⭐ star on Github

Hey Dev.to the community, I'm Ashwin Gururaj — a Data Scientist & AI Engineer based in Melbourne, Australia, currently open to full-time, contract, and internship opportunities. I specialise in building production-grade AI systems — not just notebooks and demos, but end-to-end pipelines that actually run in production. What I work with: Python · LangChain · LangGraph · FastAPI · RAG pipelines · pgvector · Multi-agent systems · LLMs · Groq · HuggingFace · Pydantic · Docker · Celery · Redis · PostgreSQL · Data Science · SQL · Pandas · Scikit-learn What I've built recently: Sift — an open-source multi-agent fact-checking pipeline. Takes any text, extracts every factual claim, retrieves grounded evidence via HyDE RAG + live web search, and returns auditable verdicts with cited sources. Built with LangGraph, pgvector, FastAPI, and Docker. → GitHub Open to: Full-time Data Scientist / AI Engineer / ML Engineer roles Remote or Melbourne-based Companies building serious AI products If you're hiring or know someone who is — I'd genuinely appreciate a connection. GitHub: https://github.com/ashg2099 LinkedIn: https://www.linkedin.com/in/ashwin-gururaj-93943816a/ Thanks!

I Built a Local AI Agent That Thinks Like a Brain, Not a Database Most AI agents today are sophisticated autocomplete engines. Ask them something, they answer. Ask again in a new conversation, they start from zero. The context window is the only memory they have. Serenity is different. It's a fully local AI agent that encodes experiences the way biological brains do — semantically clustered, causally structured, and self-organizing. No cloud. No API calls to a vector database. No data leaves your machine. Ever. The Core Problem with Current AI Memory The standard approach to AI memory is essentially a hack: you stuff embeddings into a vector DB, do nearest-neighbor retrieval, and dump the results into the prompt. It sort of works. But it's not how brains work. Your brain doesn't search for memories. When one fires, related ones light up automatically. Serenity's architecture — called S.E.R.A (Semantic Experience Reasoning Agent) — tries to bridge that gap. Here's the key difference: Traditional Approach Serenity Vector search on embeddings Semantic node activation Prompt-injected context Persistent working memory One-shot retrieval Emergent recall via association Static embeddings Pruned & crystallized over time How It Works: The Neural Node Network At the core is the Neural Node Network (NNN) . Instead of storing facts in isolation, Serenity encodes experiences in causal format: ACTION → BEFORE → OUTCOME → AFTER When she learns something, she doesn't file it in a folder. She finds where it semantically belongs in a web of related concepts. Similar things cluster together — the same way neurons that fire together wire together. Then the abstraction layer kicks in. Three or more related concepts crystallize into a higher-order node: the thing they all have in common that none of them says directly. Those nodes bundle into pathways. Those pathways grow into domains. She also has inhibitors and pruning — weak connections get cut so strong ones sharpen. Her knowledge ge

🌟 Announcing the 2nd Workshop on Social Simulation with LLMs (Social Sim'26) @ COLM 📣 Welcoming Submissions! Submission here:. 🗓️ Deadline: June 23, 2026 (AoE) This year's theme is "Fidelity in Applications”, moving beyond compelling demos toward evaluation, robustness, interpretability, and empirical grounding of LLM-based simulated societies. 💬 Topics include (but aren't limited to): 🔹 Simulation evaluation & fidelity 🔹 Validation against real-world social data 🔹 LLM-based agent modeling 🔹 Persona modeling 🔹 Cultural evolution 🔹 Information diffusion in simulated populations 🔹 Human–AI hybrid simulations 🔹 Simulation interpretability 🔹 Applications: governance, platform design, societal risk analysis 🔹 Ethical, societal & policy implications of large-scale simulated societies 🤝 We invite perspectives from ML, social science, psychology, and policy — anyone building, validating, or reasoning about LLM-driven simulated societies. Hope to see you in SF! 🌉 submitted by /u/RSTZZZ [link] [留言]

RAG SOTA: I Tested 7 Pipelines and Built SEQUOIA (Open Source) After 20+ hours of compute time on local hardware, I benchmarked 7 RAG configurations against real-world tasks. SEQUOIA (RAPTOR tree + step-back prompting) consistently outperformed alternatives. The Full Pipeline List Method Core Approach No-RAG Direct LLM generation Classical RAG Dense retrieval (BGE-small + FAISS) Hybrid RAG BM25 + Dense + RRF + reranker LightRAG Key-value graph + dense hybrid PageIndex Two-stage hierarchical retrieval GraphRAG Entity graph + dense fallback Agentic RAG Multi-step reasoning pipeline SEQUOIA RAPTOR tree + step-back prompting SEQUOIA Pro Multi-query + rerank + compression Why LightRAG Underperformed The hype suggested graph-based RAG would revolutionize retrieval. On real banking documents and technical manuals: Graph construction is expensive (entity extraction, relationship mapping) Retrieval quality did not justify the overhead Academic benchmarks do not equal production reality Why RAPTOR Works Recursive Abstractive Processing for Tree-Organized Retrieval: Cluster leaf nodes (individual chunks) Summarize upward (hierarchical abstraction) Retrieve at multiple levels (specific details + high-level context) This mirrors how humans organize knowledge. Step-Back Prompting: Free Performance Before retrieving, generalize the query: User asks: "What's the error rate for Q3?" Step-back: "What metrics are tracked quarterly?" Retrieve broader context first, then narrow Result: ~15% improvement in recall. Zero latency cost. SEQUOIA Architecture User Query Step-back Prompting (generalize) RAPTOR Tree Retrieval (multi-level) Context Compression (summarize long contexts) Re-ranking (cross-encoder) Local LLM Generation Local LLM Evaluation I used a local model weaker than GPT-4 for judging. Key finding: relative rankings between methods stayed consistent even with a weaker evaluator. You can prototype and compare approaches without burning API credits on GPT-4 evaluations. Productio

Hey , I've been building VeritasReason — an open-source Python framework that adds a structured reasoning and provenance layer on top of LLMs and AI agents. The problem it solves: AI agents today make decisions but record nothing. When something breaks in prod, you have zero audit trail. What it does: • Context Graphs — queryable graph of everything your agent knows + decides • Forward-chaining rule engine (YAML rules, no code required) • W3C PROV-O provenance — every answer traces back to its source fact • Policy compliance: ask "Which purchase orders violated SoD policy in Q1?" • Works with OpenAI, Anthropic, Groq, Ollama, any LLM 30-second demo: pip install veritas-reason veritasreason-policy-demo GitHub: https://github.com/bibinprathap/VeritasGraph PyPI: https://pypi.org/project/veritas-reason/ Happy to answer questions — built this for regulated-industry AI (healthcare, finance, legal) where "trust me bro" answers aren't enough. — Bibin submitted by /u/BitterHouse8234 [link] [留言]

Are agents aging after deployment? : https://arxiv.org/abs/2605.26302 On a new longitudinal deployment benchmark, switching the Claude Code CLI agent from Sonnet 4.6 to Opus 4.7 dropped PyTest pass rate by ~15%. This (to me) is a counterintuitive-enough result to pay attention to. The authors built AgingBench , to measure how coding agents hold up over a long deployment, not just on a single task. On their S7 coding scenario, swapping the backbone model from Sonnet 4.6 to Opus 4.7, within the same Claude Code CLI harness, produced a 15% mean drop in PyTest pass rate across the deployment horizon. Their argument is that this is a longitudinal effect, not a raw-capability one. The benchmark stresses how an agent's memory state evolves over many sessions (compression, interference, revision, maintenance shocks), and a stronger base model doesn't automatically age better under a given memory policy. In fact, memory policy alone drove a 4.5x spread in agent half-life across scenarios, which is larger than any model swap they tested. All to say: "newer model, just swap it in" may not be a safe upgrade strategy for long-lived agents. More details and a runnable benchmark: https://agingbench.github.io Does this reflect your experience with long-lived agentic deployments? submitted by /u/CategoryNormal149 [link] [留言]

Wall-OSS-0.5 is a new 4B VLA release from X Square Robot, built on a 3B VLM backbone with action experts in a Mixture-of-Transformers layout. What caught my eye is that the report evaluates the pretrained checkpoint on real robots before task-specific fine tuning, instead of only reporting downstream fine-tuned performance. The reported numbers are: zero shot on a 17-task real-robot suite, 4 tasks above 80 task progress, including a held-out deformable task (Rope Tightening, 82). After fine tuning on a 15-task suite, they report 60.5 average task progress, +17.5pp over pi0.5, and +26pp on the 10-task manipulation subset. They also report +21.8pp on embodied grounding while general VL ability stays stable. The method bits I am trying to sanity check are the gradient bridge and the optimizer claim. They argue that discrete action-token CE is the dominant gradient into the VLM backbone, while flow matching's contribution to backbone updates collapses to roughly 5 percent within a few thousand steps. The Vision-Aligned RVQ tokenizer is supposed to make those action tokens semantically grounded instead of just numerical compression. For continuous actions, they still use flow matching, but supervise in recovered action space rather than velocity space. They also include DMuon, a distributed Muon optimizer, with a pretty aggressive overhead reduction claim. Code: https://github.com/X-Square-Robot/wall-x . Hugging Face org: https://huggingface.co/x-square-robot . Project page: https://x2robot.com/oss#resources . Paper: https://x2robot.com/api/files/file/wall_oss_05.pdf The questions I had after reading it: if you have run an analogous gradient-bridge ablation in another VLA, did action-token CE dominate in the same way? For people already using Muon, does the DMuon overhead claim sound plausible? And has anyone seen RVQ-with-vision-alignment clearly beat FAST-style tokenization outside this paper? If anyone is already trying to reproduce this on real hardware, drop notes.

Spent the last few months building a deeper context layer over arxiv. Each paper gets a Tomesphere page with a TLDR + key findings (LLM-curated), OpenReview reviews where the venue is public, linked GitHub repos, HuggingFace models, conference videos, the citation graph in both directions, and a SPECTER2-based semantic neighbor graph. Same panel renders inline on arxiv via a Chrome extension (MV3 side panel API), or you can browse directly at tomesphere.com. 3M arxiv papers indexed. Caveats: reviewer scores only cover venues that publish openly on OpenReview (NeurIPS, ICLR, ICML, TMLR, COLM). Blind-review venues like CVPR, AAAI, ECCV are out of scope until contributors fill them in. GitHub, Hugging Face, and conference video matches are best-effort. Free, no signup. Site: tomesphere.com Chrome: chromewebstore.google.com/detail/tomesphere/nopoigoclhjcopjppnehidnkljmabllk Would love feedback, especially: which paper did you check first, and what's missing that you'd actually use? submitted by /u/RegretAgreeable4859 [link] [留言]

Hello everyone. The new dataset is named MONET, is Apache 2.0 and available on HF: https://huggingface.co/datasets/jasperai/monet MONET is open, Apache 2.0-licensed image–text dataset. It was built from 2.9 billion images and refined to 104.9 million high-quality samples. We are also publishing a paper that explains how the dataset was created if you are curious and 3 compagnions projects A umap to visualize the distribution A retreival tool to do text or image search A codebase to train T2i model based on MONET Hope this will be usefull! submitted by /u/dh7net [link] [留言]

Hey all, we have a quick update for everyone who participated in the Gemma 4 Challenge. We were...

Why your age-gating algorithm is probably doomed to fail in the wild For developers building in the computer vision and biometrics space, there is a massive gap between a model that passes a NIST benchmark and a system that survives the "child-with-a-VPN" test. Recent data indicates that roughly 32% of children are successfully bypassing age-gating tech. As engineers, our first instinct is often to blame the model—to tweak the weights, gather more training data, or tighten the threshold. But the technical reality is more sobering: the failure isn't in the algorithm; it's in the deployment architecture. The Problem with Probabilistic Logic in Binary Workflows Most age estimation models rely on analyzing biometric markers—skin texture, bone structure ratios, and periocular geometry. They produce a probabilistic age range. However, according to NIST's evaluation of age estimation software, to maintain a low false-positive rate, systems often need to set a "challenge age" between 29 and 33 years. If you are a dev tasked with keeping 17-year-olds off a platform, you are essentially forced to build a "buffer zone" of over a decade. If the system flags anyone who might be under 30, the UX becomes a nightmare. If you lower the threshold to 18, the false-negative rate skyrockets. This is the fundamental trade-off of probabilistic facial analysis: precision and recall are at constant war, and in a high-traffic production environment, the "noise" of real-world variables (poor lighting, low-res sensors, off-axis angles) makes consistency nearly impossible. The Breakdown of the Identity Handoff Beyond the model, there are three technical failure points that no amount of Euclidean distance analysis can fix if the pipeline is broken: The Signal-to-Noise Ratio at Source: Evaluation datasets are clean. Production images are taken on scratched lenses in low-light bedrooms. The delta between training distribution and inference-time reality is where the first 10% of accuracy vanishes.

The AC email says the rebuttal is between 28 to 4th. The June 4th on website is the deadline. So I created this post for the discussion. I know it's a MM conference and less about ML but I think many people here are still submitting there. submitted by /u/Striking-Warning9533 [link] [留言]

AI Glossary: A to Z An A-to-Z glossary of AI terms, created with help from AI itself. Because in 2026, the best way to study AI is apparently to ask AI itself. 🤣 Written for beginners and practitioners alike. Each term includes a plain English definition and a real-world example. Quick Navigation A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · X · Y · Z ↑ Back to top A Term Definition Example Agent (AI Agent) An AI system that perceives its environment, makes decisions, and takes autonomous actions to achieve a goal A coding agent that writes, runs, and debugs its own code without human intervention AGI (Artificial General Intelligence) A hypothetical AI that can match or exceed human-level intelligence across any task — does not yet exist Often cited as a long-term goal by companies like OpenAI and DeepMind AI (Artificial Intelligence) The field of computer science focused on building machines that can perform tasks normally requiring human intelligence ChatGPT writing an essay, an algorithm detecting cancer in X-rays AI Ethics The principles and practices for developing and deploying AI in ways that are fair, transparent, and safe Auditing a hiring algorithm to ensure it doesn't discriminate by gender or race AI Safety The field dedicated to ensuring AI systems remain reliable, controllable, and beneficial as they grow more capable Research into preventing AI from pursuing goals that harm people Alignment The challenge of ensuring an AI system's goals and behaviour match what its designers and users actually intend Preventing a powerful AI from optimising for a metric in a way that causes unintended harm Annotation The process of labelling raw data so it can be used to train supervised learning models Humans drawing bounding boxes around cars in images to train a self-driving model API (Application Programming Interface) A defined interface that lets software systems communicate with each other Calling the OpenAI API to

I am responsible for a research project that is supposed to train a GPT-like model (Transformer-decoder) with 100M, 250M and 500M model variants. # params ## training dataset - 750M tokens - vocabulary is ~15k to ~100k tokens (depends on tokenizer settings) - ~3% of the vocabulary is used in ~50% of the training tokens (similar to language, where most of the vocabulary is used very sparsely) ## training hyper-params - optimizer = AdamW - lr = 1e-3 (works the best compared to 1e-2 and 1e-4) - betas = [0.9, 0.95] - effective batch size = 4M tokens - epoch = 16 - warmup steps ~200 (approx 1 epoch) ## model hyper-params - 16 layers (but variants with up to 48 layers were tested) - embedding = flexible to yield 100M, 250M and 500M model - MLP size = 4*n_embd - 16 attention heads - context window = 1000 # Issue The model seems to fail to learn the basic auto-regressive behavior. It often gets stuck on generating a single token (no repetition penalty, no sampling yet). Is training GPT-like models still a black magic? Is there some trick to this? *Disclaimer*: I will add/edit the parameters above as people ask clarifying questions. submitted by /u/gartin336 [link] [留言]

Blog post: https://wezteoh.github.io/posts/diffusion-for-sketch-guided-trajectory-simulation/ During NBA games, coaches often sketch attacking plays on a whiteboard and mentally simulate how teammates and defenders might react. In this project, I explored using diffusion models for controllable basketball trajectory simulation. Instead of only forecasting future trajectories, the model generates gameplay conditioned on partial “sketches” of player movement instructions. One interesting aspect is that diffusion models refine all player trajectories jointly, which makes sketch-conditioned simulation feel more natural compared to autoregressive generation. I wrote up the methodology, experiments, and implementation details in the link above. Code and model are fully open sourced as well. Curious to hear thoughts from others working on generative modeling, trajectory prediction, or sports analytics. submitted by /u/part-time-delver [link] [留言]

I'm hoping for some advice from any former PhD's outside of machine learning. If you made it into machine learning engineering and/or data science, what was the key for you? Any tips for this job market? It seems like non computer science PhD's are especially in trouble at the moment. submitted by /u/Electrical_Fan_9587 [link] [留言]

[R] BEAM 100K memory benchmark: CSM vs Hindsight local artifact comparison I’m looking for feedback on a local agent-memory benchmark comparison, especially from people who care about evaluation methodology. I built an open-source R&D memory system called Context Swarm Memory (CSM). It uses bounded read-only memory shards, query routing, probe/recall/synthesis, cited packets, and explicit Committer-gated writes. The current comparison is against the accepted local Hindsight artifact on BEAM 100K: CSM: 0.757573 AMB score, 342 / 400 correct Hindsight: 0.733658 AMB score, 326 / 400 correct CSM uses 38.2% fewer answer-visible context tokens CSM is slower: 29.23s average retrieval vs 6.38s I want to be precise about the claim: This is not an official leaderboard claim. It is not a BEAM 10M claim. It is a committed local accepted-artifact comparison at 100K, and the next step should be independent replication or official chart acceptance. Repo: https://github.com/muhamadjawdatsalemalakoum/context-swarm-memory Evidence and reproducibility notes: https://muhamadjawdatsalemalakoum.github.io/context-swarm-memory/ The main question: what would make this comparison scientifically stronger before it is presented as a serious agent-memory result? submitted by /u/keonakoum [link] [留言]

New preprint. A Mixture-of-Experts inference kernel (TritonMoE) written entirely in OpenAI Triton, targeting portability across NVIDIA and AMD without vendor-specific code. Highlights: A fused gate+up GEMM computes both SwiGLU projections from shared tile loads, eliminating 35% of global memory traffic. 89-131% of Megablocks throughput at inference batch sizes (up to 512 tokens) on A100; the same kernel runs on MI300X unchanged. Limitations: falls behind at 2048+ tokens, and degrades with 64+ experts under extreme routing skew. Paper: https://arxiv.org/abs/2605.23911 Code: https://github.com/bassrehab/triton-kernels Writeup with benchmarks: https://subhadipmitra.com/blog/2026/fused-moe-dispatch-triton/ submitted by /u/bassrehab [link] [留言]

Dataset for fine-tuning compliance assistants. Each pair includes: - A practical SME-facing question ("Can I use pre-ticked consent boxes?") - An answer with specific UK GDPR article references, ICO guidance by name, and actionable steps - Source metadata: which GDPR concepts were used, which generation strategy, timestamp Generation method: questions via local Qwen 14B from a curated term bank, answers via DeepSeek API for factual reliability. JSON + Parquet, MIT license for the 1K sample. This is a niche dataset — it's not a benchmark contender, it's for people building privacy tools for UK businesses. If you're doing legal NLP or compliance RAG, might be useful. Free sample: https://huggingface.co/datasets/Draeg82/uk-gdpr-small-business-qa submitted by /u/a_serial_hobbyist_ [link] [留言]