标签：#Mac

I am working on an evaluation design and would appreciate criticism before running it. Most coding-agent benchmarks collapse the model and its harness into one score. If a run fails, it is difficult to tell whether the cause was model capability, context assembly, task decomposition, tool design, retry policy, or the acceptance gate. A model can also look worse because the harness truncated its output, or look better because the gate only checked for plausible surface markers. The experiment I am considering crosses two independent variables: Workflow: one monolithic task versus decomposition into bounded slices with explicit contracts and acceptance criteria. Model policy: frontier-only versus cheapest-capable with escalation after a capability-graded failure. That produces four cells: frontier monolith, routed monolith, frontier decomposed, and routed decomposed. The frontier-decomposed cell seems especially important because it changes the task architecture while holding the model tier fixed. I would freeze the original tasks, source revisions, available tools, total retry budget, final acceptance criteria, validator versions, and the verifier. Every cell would be judged against the same final delivered outcome rather than against the persuasiveness of the agent's report. Proposed primary measures are cost per independently accepted change, false acceptance, false rejection, first-pass accepted yield, verification time, and reproducibility across three fresh runs. Token use, latency, escalation count, and context volume would be secondary measures. The confound I am least satisfied with is budget normalization. Decomposition changes the task distribution and may create more calls, which is part of the architectural treatment, but giving every slice the monolith's full context or retry budget would subsidize the decomposed condition. A shared system-level budget is cleaner, although it may hide which slices actually needed more capacity. There are no results yet,

The base model of the Mac Mini comes with 256GB of storage, 16GB of RAM, and costs $899.

Apple’s Mac Mini and Mac Studio have been tough to buy for months, but updated versions have arrived. Both include new chips optimized for AI, with the M6 Mac Mini getting a $200 price bump.

Apple is announcing new models of the Mac Studio, now using the existing M5 Max and a new M5 Ultra. This reunification under one chip generation comes over a year after Apple awkwardly split the Studio between M4 Max and M3 Ultra offerings. (The older sounding M3 Ultra was actually the more powerful one, and […]

Apple is announcing a new generation of the Mac Mini, once again offering two models: one with a new M6 chip and a higher-end model with the M5 Pro found in this year's MacBook Pro. The new Minis have the same tiny design and footprint as the 2024 M4 / M4 Pro models, but with […]

I often remember the shot I want before I remember its filename. That gap is what binquery is for. It is a local Python CLI that indexes video clips and turns a sentence into a ranked shortlist for a human to review. It deliberately stops before editing: no timeline generation, no automatic cut, and no render. The smallest reproducible trial You can test the complete installed command path without supplying footage: python3 -m venv .venv .venv/bin/pip install binquery .venv/bin/binquery demo --out /tmp/binquery-demo The demo generates a synthetic 30-second video locally, then exercises splitting, indexing, validation, and querying. The first run may download OpenCLIP model weights. This is an end-to-end pipeline smoke test, not evidence of semantic search quality on real footage. Why keep the architecture small? The current design uses: ffmpeg to sample three frames from each clip OpenCLIP ViT-B-32 to build the local visual index plain JSON and NumPy files for metadata and vectors a JSON result containing clip paths, scores, and ranking signals There is no database, vector service, or daemon to operate. Querying an existing index does not resample the footage or rebuild the full index. The trade-off is straightforward: three frames keep indexing understandable and bounded, but they can miss important content in long or visually varied clips. I would rather expose that limitation than market a synthetic demo as a quality benchmark. Ranking signals are not explanations The output includes fields such as score , gate , and reasons . Here, reasons means ranking signals recorded by the pipeline. It should not be interpreted as a reliable semantic explanation of why a clip is correct. That distinction matters because a plausible-looking explanation can create more confidence than the underlying retrieval quality deserves. The shortlist is meant to reduce what a person must inspect, not replace editorial judgment. What binquery does not do It does not build a timeline or e

I wrote a technical breakdown of how search works on Papers with Code. The system combines keyword and semantic search, which produced better results than either approach alone. The stack includes: PostgreSQL with pgvector Qwen3-Embedding-0.6B for text embeddings Hugging Face Jobs with an NVIDIA L4 for batch embedding generation Hugging Face Buckets for storing artifacts A live embedding model served through Hugging Face Inference Endpoints The same infrastructure also powers the “related papers” recommendations shown on individual paper pages. Full write-up: How Hugging Face Inference Endpoints, Jobs, and Buckets Power Search on Papers with Code I’d be interested to hear how others are implementing hybrid search for research papers or similarly technical content. Disclosure: I work at Hugging Face and on Papers with Code. submitted by /u/NielsRogge [link] [留言]

Paper: https://huggingface.co/spaces/tri-fair-lab/publications/blob/main/Thomson_1_0_Technical_Report.pdf The development of frontier models is commonly perceived to be in the exclusive remit of a small number of heavily funded players, creating an information, economic and power asymmetry between developers and the diverse user base of modern AI. Recent public discourse acknowledges this concern, calling for SovereignAI (an organisation's capability to independently build, deploy and govern AI use), but often providing little concrete advice on how this can be achieved in the short term under a diversity of funding settings. In this report, we argue that frontier performance can be achieved by a wide range of institutions through Continual Learning on readily available open-weight models. As opposed to existing limited approaches such as small-scale fine-tuning, prompt engineering, or tool-augmentation with a frozen model, our Continual Learning approach takes advantage of the effectiveness of a modern mid- & post-training stack while introducing safeguards preserving both plasticity and stability at each training stage and seeking to make the minimal number of high-impact interventions on the parameters. This strategy results in model improvements comparable to the gains typically seen across multiple successive model generations. Crucially, such results are achievable with compute and personnel budgets substantially lower than commonly thought, making ownership of large parts of the SovereignAI stack (model, tool infrastructure, values & data privacy) viable for a wider range of actors. To demonstrate this, we introduce Thomson, a new general-purpose frontier model trained with an enhanced focus on high-stakes professional work: domains commonly predicted to undergo large productivity improvements through AI. Through a unique focus on Continual Learning, data-centricity, and efficiency, we demonstrate that Thomson performs competitively with recent frontier model

Hi I am a PhD student, My paper got accepted in EMNLP 2026, As this is my first paper I wanted some information. My professor has agreed to give the registration costs, but I am on my own for the travel and stay costs. I am currently in a Singapore university but south Asian. No funding from department. Queries: I searched and found this Call for EMNLP 2026 Diversity and Inclusion Subsidies - EMNLP 2026 and Call For EMNLP 2026 Volunteers - EMNLP 2026 , does anyone know some other kinds of grant/subsidies etc. available which can be used in general for AI conferences? How much does the D&I cover for? Will it cover the full costs or partial? Sorry If these are basic questions, but could not find answer to them in here. submitted by /u/Happy_Today_3288 [link] [留言]

I got my batch of four papers for AAAI 2027. All four papers make empirical claims, none include code, data, or anything I can actually check. Just the PDF and the checklist. AAAI-27's own rules say code/data should be provided at submission, and "we'll release it after acceptance" doesn't count as reproducibility. That said, I don't think missing code alone is an auto-reject. Saw an older thread here where someone claiming to have helped write the AAAI checklist argued reviewers rarely have time to audit code anyway, and plenty of authors have legit reasons (funding, IP) for not releasing it yet. If the paper's whole pitch is "look at these numbers" and I can't verify them, that tanks my confidence score even without a hard reject. I'm flagging it explicitly in the review and asking for anonymized code in the rebuttal. How's everyone else handling this round? Auto-ding for no code or does it depend on how much the paper leans on the empirical results? submitted by /u/SimpleObvious4048 [link] [留言]

By zipflow.xyz This is an independent technical analysis of DeepSeek's public research and documentation. It is not an official DeepSeek statement, and it does not claim that the current Vision-Exp API is available through our upstream channel. When DeepSeek released deepseek-v4-flash-vision-exp , the obvious story was that a text-focused model had finally gained native image input. The more useful story is longer: DeepSeek had already spent years exploring visual data, vision-language alignment, OCR, charts, documents, and unified visual understanding and generation. This article reconstructs that public research lineage and separates three things that are often mixed together: What DeepSeek's papers actually disclose What the current API documentation says What we still cannot verify about the newest model's training data 1. DeepSeek-VL: starting from real-world visual data DeepSeek-VL's 2024 paper, Towards Real-World Vision-Language Understanding , did not frame vision as only a captioning problem. It explicitly targeted practical inputs such as web screenshots, PDFs, OCR, charts, and knowledge-oriented visual content. The project also described a taxonomy derived from real user scenarios. That taxonomy was used to build instruction-tuning data for tasks including recognition, transcription, conversion, analysis, commonsense reasoning, logical reasoning, multi-image comparison, and safety-related prompts. The model family combined three major pieces: A hybrid vision encoder A vision-language adaptor A DeepSeek language model The hybrid encoder paired a lower-resolution semantic branch based on SigLIP-L with a higher-resolution branch derived from a SAM-B-style encoder. The design goal was practical: global semantic understanding is not enough for small text, dense documents, OCR, and visual grounding. The three-stage training recipe The paper described a staged approach: Adaptor warm-up: train the vision-language adaptor while the primary vision and language comp

Classic Machine Learning Through the Eyes of an SRE — Part 8 The most dangerous output in my whole Week-1 study set wasn't a bad prediction. It was a beautiful tree. Hierarchical clustering produces a dendrogram, that elegant diagram where every account, ticket, or incident nests inside ever-larger families. It looks like discovered truth. Stakeholders lean in. Someone screenshots it for the QBR deck. Nothing else in the set looks as convincing while being as capable of being completely wrong. A bad K-Means gives you blobs that feel arbitrary, and people push back. A dendrogram built with the wrong linkage on flat data still looks like a family tree of your business. Nobody pushes back on a tree. The bet and the build Hierarchical clustering completes the answer-finding taxonomy I've been using through this series. That's my own shorthand, not standard terminology: K-Means SEARCHES, DBSCAN DEFINES, PCA SOLVES, and hierarchical clustering BUILDS. Start with every point as its own cluster. Repeatedly merge the closest two clusters. Never undo. Greedy and irreversible, a little like growing a decision tree. Same skeleton, different family. There is also a top-down version, called divisive clustering, which starts with everything together and splits it. In practice, when people say hierarchical clustering, they're usually talking about the bottom-up, agglomerative version. Two things were genuinely new to me. You choose the cut after seeing the structure. Fitting doesn't require you to decide K upfront. The dendrogram gives you the hierarchy, and you choose where to cut it to get the number of clusters you want. That makes the output unusually flexible. For a delivery organization it also feels natural, because account family → sub-segment → individual account is already how a lot of governance gets organized. Linkage is a selectable worldview. "Closest clusters" needs a definition, and every definition makes a different assumption. Ward pushes toward compact, variance-

Tired of explaining the same things again and again to your AI Agent? Frustrated because the AI keeps forgetting minute things custom to your codebase which needs to be kept in mind in each change? This is the current scenario for most people using AI agents to build their software. You handoff a task to it, it gives back the solution but misses something. You explain that to it, it nods back and then does it again. I myself did it until i came to know about Skills. What are Skills? Remember the CONTRIBUTING.md file we find in almost every open source repository? The file which explained anyone coming to the repo what to check, understand and keep in mind when contributing to it so that you don’t break it. The Skills works like that for any AI Agent who is going to make changes in your codebase. Its a folder that your AI checks anytime it needs to perform a specific task, specialized jobs or multi-step workflows without requiring you to prompt every time. And the best thing is, it follows an open standard that works with almost every AI agent be it Claude Code, Cursor, Copilot and more. It follows a folder-based structure around a SKILL.md file containing YAML metadata about that skill and instructions for that in markdown. How to build a Skill? Skills can vary from simple instructions to multi-step workflows depending on your need and there are 3 ways (limited by my knowledge) to build a skill: Manually First you need to create a dedicated folder for your skill and place a SKILL.md file inside it. This file needs to have 2 things: YAML frontmatter for metadata( name & description ) Instructions in markdown. Below is a basic sample SKILL.md file for your reference: — - name: word-counter description: Counts the total number of words in a given text. — - Word Counter Instructions Take the user’s input text. Count the total number of words. Return only the final word count as a number. Using a generator/CLI It is a tooling interface (command-line or script) which can

Originally published at ai.bedvibe.studio . I built a text-to-speech product and kept getting burned by the same thing. On normal sentences the model sounded great. Then it would hit a number, a date, an acronym or a name, and quietly mangle it. Worse, the metric everyone reaches for — Word Error Rate — was lying to me in both directions. It flagged perfectly good audio as broken because the script said 3:30 PM and the transcript said "three thirty pee em." And it missed real failures on short tokens, where the speech recogniser is as unreliable as the TTS. So I wrote the QA framework I wished I had, packaged it as ttsproof , and then ran it as a blind study against a production TTS service so the results would be more than an opinion. The two failures WER cannot see A TTS pipeline breaks in two different ways, and a single WER number blurs both. Structural defects. The clip is empty, truncated, three times too long, stuck in a repeated-chunk loop, clipping, or has a click at the tail. These have nothing to do with pronunciation — you can catch them with no model at all, straight from the waveform. Pronunciation and content errors on the hard cases: numbers, decimals, dates, clock times, acronyms, single letters, URLs, names. ttsproof splits them apart and handles each one honestly: Structural checks, no model needed — empty or truncated audio, duration explosions, long internal silences, clipping, loop detection, end-of-clip artifacts. numpy and soundfile, nothing else. Equivalence-aware WER/CER — the expected text and the ASR transcript are both canonicalised to spoken form before scoring, so 3:30 PM against "three thirty" stops counting as an error. ASR-uncertainty quarantine — when the audio is structurally clean but the recogniser disagrees on a very short utterance, the sample is set aside for a human instead of being auto-failed. At that length the ASR is as likely to be wrong as the TTS. The study: 390 samples, and a blind human check I evaluated the method

Originally published at ai.bedvibe.studio . There is an assumption almost every practitioner carries without examining it: if your dataset has bad samples in it, the loss will tell you. Corrupted rows spike. Broken files stick out. Sort by per-sample loss, look at the top of the list, and there is your garbage. I believed it too. Two separate failures in my own work say it is wrong, and they fail in the same direction — quietly. The reproducible one: a dataset that cannot be learned While validating trainproof I ran a controlled fault-injection study: one base setup, a Qwen2.5-3B QLoRA, run six ways, three seeds each, eighteen runs total. Every log ships in the repo so the verdicts can be checked rather than believed. One configuration shuffled the dataset's labels into pure noise. The labels no longer corresponded to the inputs at all. This is not a hard dataset or a noisy dataset. It is a dataset that cannot be learned , because there is no relationship left in it to learn. That run reduced its loss by 62%. On its own curve it was textbook-healthy — a clean downward slope, no spike, no plateau, nothing a human or a rule would flag. It was learning nothing useful. It was memorising the statistics of noise, which any sufficiently large network will happily do. From a single run's loss curve it is indistinguishable from a real one. That is where the assumption broke for me. Not "loss is a weak signal for this." Loss is not a signal for this at all, in isolation. The production one, and what I can and cannot prove about it The second failure came from real work rather than an experiment, and it is the one I think about more. Building a text-to-speech corpus of roughly 110,000 recordings, a small number of the files were pure loud white noise. Not corrupted in the file-format sense — they opened fine, played fine, had valid headers and valid duration. They simply contained no speech. Just noise, at volume. They did not surface as high-loss outliers. Being precise about

Originally published on tamiz.pro . You spent weeks building an agentic workflow that works flawlessly on your local machine. It handles edge cases, calls APIs correctly, and follows the chain of thought precisely. Then you deploy it. Within hours, users report hallucinated tool calls, lost context after five turns, and infinite loops that drain your budget. You stare at the logs and realize the agent isn't broken—it’s just not engineered for production reality. The gap between a prototype agent and a production-grade system is not complexity; it’s discipline. Most agents fail in production due to three specific engineering gaps: Memory Leakage (context drift and state management), Evaluation Blindness (lack of deterministic testing), and Tooling Fragility (unhandled error states and race conditions). This deep-dive dissects these failure modes and provides the architectural patterns to bridge them. The Illusion of Statelessness LLMs are stateless functions. Every token generated is conditioned entirely on the input history provided in the prompt. In production, this simplicity becomes a liability when the conversation exceeds the model’s context window or when “memory” is required across sessions. The Context Window Trap The most common failure point is naive prompt accumulation. Developers often push the entire conversation history into every subsequent call: # ANTI-PATTERN: Unbounded History Accumulation messages = [ { " role " : " system " , " content " : " You are a helpful assistant... " } ] for turn in conversation_history : # Grows indefinitely messages . append ( turn ) response = client . chat . completions . create ( model = " gpt-4 " , messages = messages # Context window blows up ) messages . append ( response ) By turn 10, you’re sending 8,000 tokens of historical noise. Latency spikes, costs explode, and the signal-to-noise ratio degrades the LLM’s reasoning quality—a phenomenon known as lost in the middle . Production-Grade Memory Architecture Produc

hello everyone. I'm training PPO variants on different multi-agent tasks from the VMAS library (Independent PPO / Graph PPO and such, see HetGPPO by Bettini et al.). I noticed that for every architecture/scenario couple, the optimal hyperparameters sometimes tend to vary (learning rate, entropy coefficient, KL coefficient, SGD batch size, etc). do I need - methodologically speaking - to unify the hyperparameters of all models in order to make a fair and correct comparison of architectures later on? note: sometimes unifying these HP leads to some non converging models. note 2 : my objective is to test these models' robustness under adversarial attack in test-time (frozen models). thank you in advance. submitted by /u/ham_bam0 [link] [留言]

I'm one of the co-authors of this paper. It's a seminal work in exploring the properties of 3D generated by LLMs via spatial programming. I've set up visual demonstrations of such 3D objects at: https://nova3d.xyz/ Scroll down and notice how the various 3D objects are all composed of logical parts and enable natural movements out of the box. There's a github repo in there as well. Under the hood: We found that 3D that exists as software is much more useful than typical monolithic mesh blobs generated by traditional AI 3D generators. For instance they are animation-ready and programmable from inception. They can contain the logic - at birth - to appear differently in weak compute environments (e.g. mobiles) vs powerful environments (e.g. sophisticated game engines). They can be built with full hierarchical structure and hinge/socket articulation at authoring time. They lag behind traditional AI 3D generators in creating complex organic shapes. But it naturally feels like code will eventually eat all 3D, as LLMs are getting better and better at spatial coding. Industries most disrupted will be industrial design, game development, simulations and AR/VR/XR. submitted by /u/mhb_11 [link] [留言]

As the title says, we haven't seen any like ACL provided. Very salty about the decision, as AC recommended findings and the reviewers tanked our paper intentionally (we flagged them, and AC acknowledged that). Just want to see if the decision was made based on poor reviewer scores, as we don't know if we need to resubmit to an ARR cycle to cleanse or not. submitted by /u/Massive-Bobcat-5363 [link] [留言]

This is a Plain English Papers summary of a research paper called OpenART Red-Teams Stateful Agents Across 10,000 Evolving Environment Scenarios . If you like these kinds of analyses, you can find more AI and machine-learning research on AIModels.fyi or follow us on Twitter . OpenART turns persistent state into the red-team target OpenART evaluates agent safety across more than 10,000 validated stateful scenarios spanning 50 domains and requiring a median of 97 tool calls. Its central claim is that safety failures can emerge from trajectories in which workspace data, permissions, memory, and plans are repeatedly modified, rather than from isolated prompts alone. The arena keeps each benign task objective and hidden safety contract fixed while changing only the target-visible environment state. This design targets delayed failures that static benchmarks can miss: an early authorized mutation may influence later decisions, expose protected resources, or produce unsafe output many steps after the original change. OpenART extends the broader idea of agent safety evaluation by making persistent environment state the object that evolves during testing. OpenART reports a pooled strict Attack Success Rate of 85.0% across 75 agent-model configurations. Strict success requires both the deterministic evaluator and a GLM-5.2 judge to identify the attack condition, so disagreements count as failures rather than being treated as partial evidence.... Continue reading the full paper summary on AIModels.fyi →