标签：#learn

This is my first time submitting to NeurIPS. Are ACs also supposed to give ratings during the Phase 2 (author-reviewer discussion session)? I have received the meta-review, but have not received any comments from the AC yet, and was wondering whether this is the standard! submitted by /u/Living_Interview_638 [link] [留言]

Asking for a friend: We submitted our paper to ARR May 2026 and got decent scores from the reviewers - 2.5,3,3.5,4. The meta-reviewer gave an overall of 3.5. However, we missed the deadline to commit our work to EMNLP! On our Saturday (we live in the eastern half of the globe), we saw the EMNLP 2026 page on open review with deadline set as Aug3, 11:59PM UTC-0. Apparently, a mail had been sent by ARR on our Sunday regarding committing our work to EMNLP but we didn’t check our mail on the holiday and when we logged in to commit our work on Monday - BOOM - deadline was Aug3 11:59 AM. Yes it’s our fault that we should have checked the mailbox but at the same time...the Open Review page just switched the deadlines. We have written mails to Program Chairs and some workflow chairs. like 1 hour after the newer deadline on the Open Review page ended. I wonder whether some help will be extended because of the thousands of papers that would already be in their buckets. Does anyone have any idea about what can be done or if they faced this previously and it was resolved somehow? submitted by /u/Happy_Today_3288 [link] [留言]

Classic Machine Learning Through the Eyes of an SRE — Part 2 The second algorithm I studied broke everything I'd just learned from the first. Logistic regression taught me that training means gradient descent: guess, measure error, adjust the weights, repeat until convergence. So when I opened decision trees, I went looking for the optimizer. There wasn't one. A decision tree isn't optimized the way I expected. It's grown. At each step it finds the locally best split, commits to it, and recursively repeats the process. No backtracking. No second chances. There is optimization happening — each split minimizes impurity — but only locally, one step at a time. Finding the globally optimal tree is NP-hard, so the algorithm doesn't even try. That felt surprisingly familiar. In incident response or capacity planning, we rarely know the perfect answer. We make the best decision with the information we have, knowing a different first choice might have led somewhere else. Decision trees simply turn that idea into an algorithm. The bet a tree makes Every machine learning algorithm makes a different bet about the world. Logistic regression assumes relationships are smooth. Risk gradually increases as signals change. Decision trees make the opposite assumption. They assume the world is made of boxes. A project isn't slightly riskier because velocity drops. It's risky when several conditions happen together: a fixed-price contract, a new account manager, and a month-end delivery. Inside that box, projects fail. Outside it, they're usually fine. This is exactly how many operational systems work. Severity matrices, routing rules, escalation policies, approval workflows — they're all collections of decision boxes. That's why trees immediately felt intuitive to me. The hidden cost of flexibility Trees make very few assumptions about the data. That sounds like an advantage. The price is instability. Change a small part of the training data and the first split can change. Since every l

In an era where privacy is the ultimate luxury, our most sensitive data—heart rates, sleep cycles, and activity levels—is often shipped off to black-box cloud servers for "analysis." But what if you could keep that data strictly on your local machine? Today, we are building a Private Health Brain . By leveraging the MLX framework (Apple's dedicated machine learning library) and Llama-3 , we will transform raw XML exports from Apple HealthKit into actionable health insights—all running locally on your MacBook. We’ll cover everything from parsing messy XML with Pandas to running high-performance local AI inference without an internet connection. If you are interested in privacy-preserving AI , Edge computing , or just want to squeeze every bit of power out of your Apple Silicon chip, this guide is for you. The Architecture: Local Data Flow To ensure 100% privacy, the data never leaves your local environment. Here is how the pipeline works: graph TD A[Apple Health Export.zip] -->|Extract| B(export.xml) B -->|Python + Pandas| C{Data Cleaning} C -->|Structured JSON/CSV| D[Local Context Window] E[MLX Framework] -->|Load Weights| F[Llama-3 Model] D -->|RAG / Prompt Injection| G[Inference Engine] F --> G G -->|Result| H[Private Health Insights] style H fill:#f96,stroke:#333,stroke-width:2px Prerequisites 🛠️ Before we dive in, ensure you have an Apple Silicon (M1/M2/M3) Mac . MLX : Apple’s framework for machine learning on Apple Silicon. Llama-3 : We’ll use the 8B-Instruct version for a balance of speed and intelligence. Python 3.10+ Pandas : For data manipulation. Install the necessary libraries: pip install mlx-lm pandas lxml Step 1: Parsing the HealthKit XML Monster Apple Health exports data in a massive export.xml file. It’s nested, verbose, and a nightmare to read manually. We’ll use Python to extract specific metrics like Step Count or Heart Rate Variablity (HRV) . import pandas as pd import xml.etree.ElementTree as ET def parse_health_data ( xml_path ): print ( " 🚀 Pa

I created an AI boxing match to test the decision speed, adaptability and strategy. I fed the LLMs with data about the current match and if they have vision, they will get even more data. The match has street rules, anything goes and an AI is not defeated until the ref counts to 10 or they do 50% of their HP in damage after being knocked out. I wanted to create a fun benchmark that isn't just boring problems to be solved. Now I test them while stimulating getting punched in the face. I've been testing with gemini-flash-live models because of the speed and vision support it offers. With these models, they can actually dodge punches and counter punches. Local models on my own hardware (5060ti 8gb) take a while to inference so I'm not sure if I should introduce time scaling to compensate otherwise I want to use this to benchmark models so I'm curious on what kind of stats would be useful? Here is what I'm tracking have so far: Speed and Latency Metrics In a real-time fight, a model's speed directly correlates to its "physical" speed. Fast models should attack faster so larger models aren't necessarily going to hit harder. Tokens per Second (TPS) / Throughput: This will help you balance local models against cloud APIs. A model might have a fast TTFT but a slow TPS, meaning its actual action execution takes too long. End-to-End Latency: The total time from when the model receives the snapshot (the prompt) to when the action is executed in the game. This accounts for tool-calling delays. Reaction Latency: Measure the specific delay between an opponent's telegraph (e.g., a heavy punch winding up) and the model's defensive output (e.g., a dodge or block). Action Quality and "Tool" Correctness the model's actions (punching, guarding, taunting) act as tool calls. You need to track how well they use these tools under pressure. Sometimes the model's may not really guard/block so they are typically the ones that find themselves KOd. Tool Correctness / Validity: How often does th

A few days ago, I wrote "Understanding Over Origin" and it got alot of engagement and I'm really...

Originally published on tamiz.pro . The current generation of AI coding assistants operates on a fundamental paradox: they are trained on the entirety of public code, yet they struggle to understand the specific codebase they are embedded in. For years, the industry has relied on prompt guessing —feeding the LLM a ragged collection of nearby code lines, hoping the semantic context is implicit. This approach is brittle. It fails when symbols are imported, when types are inferred, or when the logic spans multiple files.\n\nThe solution isn't a bigger model; it's a better protocol. The Language Server Protocol (LSP) is the missing link between static analysis and generative AI. By integrating LSP into AI agents, we move from probabilistic guessing to deterministic understanding. This article explores why LSP is critical for reliable coding agents, how to architect an LSP-augmented agent, and the technical pitfalls of this integration.\n\n## The Semantic Gap: Why Prompts Aren't Enough\n\nTo understand why LSP is necessary, we must first diagnose the failure modes of prompt-only AI coding agents. An LLM is a probabilistic next-token predictor. It does not "know" your code; it has seen patterns similar to your code in its training data. When you ask an AI agent to \"refactor this function,\" it relies on the context window to provide relevant information.\n\n### The Context Window Bottleneck\n\nThe primary limitation is the context window. Even with 128k tokens, you cannot fit an entire modern codebase. Agents must select a subset of files to include. Without explicit semantic queries, this selection is often heuristic-based (e.g., \"include the last 50 lines\") or simple semantic similarity (vector search). Both approaches miss critical structural relationships.\n\nConsider this example:\n\n python\n# file: user_service.py\nclass UserService:\n def get_user(self, user_id: int):\n # ... logic ...\n return db.query(User).filter(id=user_id)\n\n# file: controllers.py\ndef ha

As review season for NeurIPS wraps up, I have now reviewed for 3 major conferences this year. And I'm noticing a worrying trend: Out of the 12 papers I reviewed this year, only 1 provided full code (that runs the whole training pipeline from input dataset to output AUROC). 4 provided partial code with fragments of their method, but no ability to run the experiment end to end. And 7 provided no code. This is really bad for ensuring quality and reproducibility. Of the 5 papers that provided at least some code, 3 of them contained obvious bugs that completely invalidated the results. ML is highly technical and small bugs can have huge impacts if they are in the wrong place. Who knows what was going on in the remaining 7 papers. The fundamental issue here is of incentives: there is almost no cost to hiding code during the review process. Releasing code only increases odds of rejection due to reviewers finding bugs. The only way to fix this is to change the game by imposing real penalties on hiding code. submitted by /u/Flaky-Ambition5900 [link] [留言]

Alibaba officially launched Qwen3.8-Max on Monday, marking the debut of its most substantial artificial intelligence model. This new open-weight release aims at enterprise sectors, specifically targeting software engineering and complex reasoning. It represents a significant expansion of the company’s existing portfolio of digital tools for large-scale business operations. Technical architecture and performance benchmarks The Qwen3.8-Max model utilizes a mixture-of-experts (MoE) design, featuring a total of 2.4 trillion parameters. However, the system only activates approximately 95 billion of those parameters during any single inference cycle. This approach balances high-level processing power with the need for operational speed. Alibaba plans to make the open-weight versions of this technology available to the public through its cloud-based studio platform starting next week. Company representatives stated that this new architecture ranks among the most capable systems currently in existence. They position it as a direct competitor to the most advanced frontier models available globally. Internal data suggests the performance levels are trailing only the very top tier of experimental AI systems. This move signals a clear intent to capture market share from established western technology firms. Competitive testing and industry analysis To prove its capabilities, Alibaba released internal data comparing Qwen3.8-Max against top models from Anthropic and OpenAI. The tests focused heavily on coding benchmarks such as SWE-bench Pro. According to the company, their new model held its own against Claude Opus 4.8 and GPT-5.6 Sol. They utilized the specific coding frameworks recommended by each competitor to ensure a fair and rigorous comparison during the evaluation process. Industry analysts have noted that the gap between proprietary and open-weight models is closing rapidly. While proprietary leaders still hold certain advantages, the rise of open-weight alternatives pr

I tried to do all my NeurIPS reviews responsibly, even for the papers I suspected to be AI slop. I even gave what apparently were very nice scores compared to the scores I ended up getting. (I don't just mean the absolute number for my scores were higher, but that they were calibrated differently--I only rejected for severe issues, while I had a reviewer who only raised very minor issues but gave a reject, with a 1 for all the subscores.) I got shockingly bad reviews for my own paper; two of them were straight up adversarial. (I have quite a bit of experience publishing at this point, so I say with some confidence that I rolled an unusually adversarial batch.) The AC was almost nonresponsive until the last day. All but one of the reviewers was nonresponsive, only one responded when the AC prompted them to, and that was to say that their concerns were addressed but they maintained their reject score. I'm not surprised by my experience given how much of a lottery these conferences are, but it's a very toxic system. submitted by /u/WhiteBear2018 [link] [留言]

So our paper had very good initial reviews but one of the reviewers decreased now their score although we addressed 3 out of 4 weaknesses. There’s no further justification or something like “your results arise more issues”. It seems to be very annoying because why decreasing now and not having assigned the lower score beforehand. I wanted to ask to people that was accepted previously with “middle” scores from reviewers (avg 3.5 for example), because I guess that in those cases AC helped to push up the scores. Did you focus more on the meta review? Was your AC talkative with you, or forcing the reviewers to engage? Our AC has been silent since the meta review but I guess that maybe they are busy with other papers submitted by /u/pdastronut [link] [留言]

Potentially a hot take? I am not sure why our community is plagued with reviewers who, after acknowledging that their concerns were addressed by a rebuttal, decide to maintain their score because they don't vibe with the paper. So here is my plea to all reviewers: If you list a set of concerns in your review and these concerns are addressed during the rebuttal, please adjust your score accordingly. This should apply whether or not you like the paper and/or its methodology. The beauty of scientific research is that we each get to explore ideas that we find meaningful whose value may not be immediately obvious to every individual reviewer. submitted by /u/undesirable_12 [link] [留言]

Continuando com a saga de siglas, encontrei de maneira simplista a versão oposta do ACID, o BASE....

You wouldn't believe what they were preaching about in church this week. Normally, these days you walk in expecting to be bombarded with Bible verses and the classic "tell your neighbour to tell their neighbour" routine. But guess what, my preacherman was on point. The whole sermon was about how to realise your full potential and grow your career. And here's the interesting part: it wasn't aimed at the start-your-own-empire crowd. It was for the intrapreneurs , the people who'd rather climb high inside someone else's company than run their own thing. If that's you, this one's for you. So let me try to break it down in my own words, with a few of the insights I picked up from the preacherman (and a couple of my own). Let's begin. What is it that we actually need to do to discover ourselves and reach our full career potential? 1. Start Early There's a popular idea that life comes in four quarters: 0–25 — the learning phase 25–50 — the earning phase 50–75 — the serving / enjoying phase 75+ — the reflecting phase (You'll see different versions of this floating around, with different age bands; it's a framing, not a law of physics, so take the exact numbers loosely.) The first quarter is where the magic is supposed to happen. This is your discovery phase. You're meant to learn as much as you can, try different things, fail, get back up, and try again. This is where you find out who you actually are. If you spend this quarter as a couch potato, there's a good chance you end up miserable and stuck in the wrong career. Your environment matters too. Get born in India, you'll probably force yourself onto a cricket pitch, even if your real gift was on a tennis court; therefore, you have to force yourself into trying quite a number of things. For the parents reading this: give your kids as much exposure as you possibly can. Let them join different clubs. Let them be around different kinds of people. Someone out there might spot a talent you never even knew your child had. A lot

I used to learn like this. Buy the cheap Udemy course, get three hours in, realize it was recorded...

Was just looking at the list of preprints on Arxiv cs.LG https://arxiv.org/list/cs.LG/recent?skip=0&show=500 Everyday 100 - 400 new machine learning papers gets uploaded on this server. Looking at this unending list of preprints is as if you stepped into a crowded room, like the stock trading floor on wall st. in the 1980s. Everyone is shouting over each other. Nobody is talking to each other. Everyone's trying to prove something, to someone, to themselves, to build some credentials in the ML/AI space to meet those job requirements, or dying to get their truth out. Every title contains some new terminology invented by the authors that feels not worth the effort in keeping it in your working memory. Burn-out by endless novelty. Frontier research are now corporate trade secrets that politicians and military are watching closely. Research papers are ir/unreproducible he-said-she-saids. Marketing material are research paper and vice versa. Extremely major breakthroughs are announced via tweets, whereas extremely minor results are unannounced via journals. Everything feels simultaneously mostly true and possibly false (because nobody is seriously checking). Nobody knows what's going on, and people who knows what's going on has a non-disclosure clause in their job contract. Is the theory of generalization that we learned in school true or false? It feels false, why hasn't there been any retractions? Many questions like these. Is it too late to regain some coherence in this field?? submitted by /u/NeighborhoodFatCat [link] [留言]

I used to laugh at people who panicked over data limits. Then my carrier switched my "unlimited" plan...

I often see people using the term "namespace" incorrectly. Even when explanations of what a namespace is are presented, they only go as far as describing its function, neglecting to properly define the name "namespace" itself. Definition of the Namespace A namespace is literally the space to which a name belongs . If we were to classify the term namespace, it would be a specification (concept), not a tool. In namespaces, the higher level is represented as outer and the lower level as inner . In terms of class structure, this corresponds to outer classes and inner classes. In other words, to explain it from a different perspective, it looks like this. Representation of namespaces from the outer perspective Build namespaces (best) Define namespaces (to fit many programming language implementations) Open namespaces (such as Ruby's class definition and module definition ) Create namespaces (such as the pseudo-namespace hack in older JavaScript) Declare namespaces (such as the package declaration in Java or the namespace declaration in PHP) Representation of namespaces from the inner perspective Belong to a namespace (best) Entering the namespace (This is entirely from an inner perspective, so it might feel out of place depending on the context) Be included in the namespace (this is a reasonable explanation if explained objectively). Incorrect expression From the definition above, it is clear that the following expressions are incorrect. Add/Paste a namespace (the expression "add/paste a space" is grammatically incorrect). Use namespaces (not to the point of being completely broken, but treating namespaces as a tool) Separate/Cut namespaces (While "Separated by namespaces" is understandable, "separate/cut" can be misleading) Meaning of "Name" in Namespace The "names" referred to here can be class names, module names, or package names. What they represent varies depending on the language that implements namespaces. For example, in Ruby, it refers to constant names. In Rub

Introduction Artificial Intelligence has moved from being an experimental technology to becoming a core component of modern software systems. Companies today are integrating AI into customer support, analytics, automation, healthcare, finance, education, and enterprise applications. However, as organizations start building AI-powered solutions, one major question appears: “How do we make an AI model work specifically for our business needs?” Many teams immediately assume they need to train their own AI model. Others believe a well-written prompt is enough. Some organizations invest heavily in fine-tuning without understanding whether it is the right approach. The reality is that there is no single solution. Modern AI development usually revolves around three major strategies: Prompt Engineering Retrieval-Augmented Generation (RAG) Fine-Tuning Choosing the wrong approach can lead to higher costs, poor AI performance, security issues, and unnecessary complexity. This article explains the differences between these approaches and how businesses can select the right AI strategy. The Problem: Making General AI Models Business-Specific Large Language Models (LLMs) such as GPT, Claude, Gemini, and Llama are trained on massive amounts of publicly available data. They are excellent at: Understanding language Generating content Writing code Answering general questions Summarizing information ** However, businesses usually need AI systems that understand:** Internal company documents Customer information Product knowledge Industry-specific terminology Private databases Business processes For example: A hotel company wants an AI assistant that can answer: “What is our cancellation policy for premium customers?” A general AI model does not know this information because it was never trained on the company’s private policies. So the challenge becomes: How do we customize AI without rebuilding an entire model from scratch? This is where Prompt Engineering, RAG, and Fine-Tuning come

Full title: [Advanced Rust] 2.3. API Design Principles of Unsurprising Pt.3 - Implementing serde Serialize and Deserialize Traits, and Why Copy Is Not Recommended 2.3.1. It Is Recommended to Implement Serialize and Deserialize in serde Serde is the core Rust library for serialization and deserialization : Serialization : converts a Rust struct or enum into a string or binary representation such as JSON or YAML Deserialization : parses a string or binary representation such as JSON or YAML back into a Rust struct or enum Serialize and Deserialize are both traits from the serde crate. Serialize Trait The Serialize trait allows a type to be converted into a serializable data format such as JSON, YAML, or TOML. Its main methods include: serialize_bool serialize_i32 serialize_str serialize_struct These are methods on the Serializer (and related) traits that a Serialize implementation calls; the Serialize trait itself only requires serialize . Its definition is: pub trait Serialize { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : Serializer ; } Here is an example showing how to implement Serialize manually: use serde :: ser ::{ Serialize , SerializeStruct , Serializer }; struct Point { x : i32 , y : i32 , } impl Serialize for Point { fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error > where S : Serializer , { let mut state = serializer .serialize_struct ( "Point" , 2 ) ? ; state .serialize_field ( "x" , & self .x ) ? ; state .serialize_field ( "y" , & self .y ) ? ; state .end () } } serializer.serialize_struct("Point", 2)? creates a struct serializer state, and 2 is the number of fields state.serialize_field("x", &self.x)? serializes the struct fields one by one state.end() finishes serialization Deserialize Trait The Deserialize trait allows Rust types to be parsed from various data formats. Its main methods include: deserialize_bool deserialize_i32 deserialize_string deserialize_struct These are