Committee

arXiv:2511.09345v2 Announce Type: replace Abstract: Test-time scaling improves the inference performance of Large Language Models (LLMs) but also incurs substantial computational costs. Although recent studies have reduced token consumption through dynamic self-consistency, they remain constrained by the high latency of sequential requests. In this paper, we propose SeerSC, a dynamic self-consistency framework that simultaneously improves token efficiency and latency by integrating System 1 and System 2 reasoning. Specifically, we utilize the rapid System 1 to compute the answer entropy for given queries. This score is then used to evaluate the potential of samples for scaling, enabling dynamic self-consistency under System 2. Benefiting from the advance and accurate estimation provided by System 1, the proposed method can reduce token usage while simultaneously achieving a significant decrease in latency through parallel generation. It outperforms existing methods, achieving up to a 47% reduction in token consumption and a 43% reduction in inference latency without significant performance loss.

In 2026, I’m going to be closely watching the price of lithium. If you’re not in the habit of obsessively tracking commodity markets, I certainly don’t blame you. (Though the news lately definitely makes the case that minerals can have major implications for global politics and the economy.) But lithium is worthy of a close look right now. The metal is crucial for lithium-ion batteries used in phones and laptops, electric vehicles, and large-scale energy storage arrays on the grid. Prices have been on quite the roller coaster over the last few years, and they’re ticking up again after a low period. What happens next could have big implications for mining and battery technology. Before we look ahead, let’s take a quick trip down memory lane. In 2020, global EV sales started to really take off, driving up demand for the lithium used in their batteries. Because of that growing demand and a limited supply, prices shot up dramatically, with lithium carbonate going from under $10 per kilogram to a high of roughly $70 per kilogram in just two years. And the tech world took notice. During those high points, there was a ton of interest in developing alternative batteries that didn’t rely on lithium. I was writing about sodium-based batteries, iron-air batteries, and even experimental ones that were made with plastic. Researchers and startups were also hunting for alternative ways to get lithium, including battery recycling and processing methods like direct lithium extraction (more on this in a moment). But soon, prices crashed back down to earth. We saw lower-than-expected demand for EVs in the US, and developers ramped up mining and processing to meet demand. Through late 2024 and 2025, lithium carbonate was back around $10 a kilogram again. Avoiding lithium or finding new ways to get it suddenly looked a lot less crucial. That brings us to today: lithium prices are ticking up again. So far, it’s nowhere close to the dramatic rise we saw a few years ago, but analysts are watching closely. Strong EV growth in China is playing a major role—EVs still make up about 75% of battery demand today. But growth in stationary storage, batteries for the grid, is also contributing to rising demand for lithium in both China and the US. Higher prices could create new opportunities. The possibilities include alternative battery chemistries, specifically sodium-ion batteries, says Evelina Stoikou, head of battery technologies and supply chains at BloombergNEF. (I’ll note here that we recently named sodium-ion batteries to our 2026 list of 10 Breakthrough Technologies.) It’s not just batteries, though. Another industry that could see big changes from a lithium price swing: extraction. Today, most lithium is mined from rocks, largely in Australia, before being shipped to China for processing. There’s a growing effort to process the mineral in other places, though, as countries try to create their own lithium supply chains. Tesla recently confirmed that it’s started production at its lithium refinery in Texas, which broke ground in 2023. We could see more investment in processing plants outside China if prices continue to climb. This could also be a key year for direct lithium extraction, as Katie Brigham wrote in a recent story for Heatmap. That technology uses chemical or electrochemical processes to extract lithium from brine (salty water that’s usually sourced from salt lakes or underground reservoirs), quickly and cheaply. Companies including Lilac Solutions, Standard Lithium, and Rio Tinto are all making plans or starting construction on commercial facilities this year in the US and Argentina.  If there’s anything I’ve learned about following batteries and minerals over the past few years, it’s that predicting the future is impossible. But if you’re looking for tea leaves to read, lithium prices deserve a look.  This article is from The Spark, MIT Technology Review’s weekly climate newsletter. To receive it in your inbox every Wednesday, sign up here.

Yann LeCun is a Turing Award recipient and a top AI researcher, but he has long been a contrarian figure in the tech world. He believes that the industry’s current obsession with large language models is wrong-headed and will ultimately fail to solve many pressing problems.  Instead, he thinks we should be betting on world models—a different type of AI that accurately reflects the dynamics of the real world. He is also a staunch advocate for open-source AI and criticizes the closed approach of frontier labs like OpenAI and Anthropic.  Perhaps it’s no surprise, then, that he recently left Meta, where he had served as chief scientist for FAIR (Fundamental AI Research), the company’s influential research lab that he founded. Meta has struggled to gain much traction with its open-source AI model Llama and has seen internal shake-ups, including the controversial acquisition of ScaleAI.  LeCun sat down with MIT Technology Review in an exclusive online interview from his Paris apartment to discuss his new venture, life after Meta, the future of artificial intelligence, and why he thinks the industry is chasing the wrong ideas.  Both the questions and answers below have been edited for clarity and brevity. You’ve just announced a new company, Advanced Machine Intelligence (AMI).  Tell me about the big ideas behind it. It is going to be a global company, but headquartered in Paris. You pronounce it “ami”—it means “friend” in French. I am excited. There is a very high concentration of talent in Europe, but it is not always given a proper environment to flourish. And there is certainly a huge demand from the industry and governments for a credible frontier AI company that is neither Chinese nor American. I think that is going to be to our advantage. So an ambitious alternative to the US-China binary we currently have. What made you want to pursue that third path? Well, there are sovereignty issues for a lot of countries, and they want some control over AI. What I’m advocating is that AI is going to become a platform, and most platforms tend to become open-source. Unfortunately, that’s not really the direction the American industry is taking. Right? As the competition increases, they feel like they have to be secretive. I think that is a strategic mistake. It’s certainly true for OpenAI, which went from very open to very closed, and Anthropic has always been closed. Google was sort of a little open. And then Meta, we’ll see. My sense is that it’s not going in a positive direction at this moment. Simultaneously, China has completely embraced this open approach. So all leading open-source AI platforms are Chinese, and the result is that academia and startups, outside of the US, have basically embraced Chinese models. There’s nothing wrong with that—you know, Chinese models are good. Chinese engineers and scientists are great. But you know, if there is a future in which all of our information diet is being mediated by AI assistance, and the choice is either English-speaking models produced by proprietary companies always close to the US or Chinese models which may be open-source but need to be fine-tuned so that they answer questions about Tiananmen Square in 1989—you know, it’s not a very pleasant and engaging future.  They [the future models] should be able to be fine-tuned by anyone and produce a very high diversity of AI assistance, with different linguistic abilities and value systems and political biases and centers of interests. You need high diversity of assistance for the same reason that you need high diversity of press.  That is certainly a compelling pitch. How are investors buying that idea so far? They really like it. A lot of venture capitalists are very much in favor of this idea of open-source, because they know for a lot of small startups, they really rely on open-source models. They don’t have the means to train their own model, and it’s kind of dangerous for them strategically to embrace a proprietary model. You recently left Meta. What’s your view on the company and Mark Zuckerberg’s leadership? There’s a perception that Meta has fumbled its AI advantage. I think FAIR [LeCun’s lab at Meta] was extremely successful in the research part. Where Meta was less successful is in picking up on that research and pushing it into practical technology and products. Mark made some choices that he thought were the best for the company. I may not have agreed with all of them. For example, the robotics group at FAIR was let go, which I think was a strategic mistake. But I’m not the director of FAIR. People make decisions rationally, and there’s no reason to be upset. So, no bad blood? Could Meta be a future client for AMI? Meta might be our first client! We’ll see. The work we are doing is not in direct competition. Our focus on world models for the physical world is very different from their focus on generative AI and LLMs. You were working on AI long before LLMs became a mainstream approach. But since ChatGPT broke out, LLMs have become almost synonymous with AI. Yes, and we are going to change that. The public face of AI, perhaps, is mostly LLMs and chatbots of various types. But the latest ones of those are not pure LLMs. They are LLM plus a lot of things, like perception systems and code that solves particular problems. So we are going to see LLMs as kind of the orchestrator in systems, a little bit. Beyond LLMs, there is a lot of AI that is behind the scenes that runs a big chunk of our society. There are assistance driving programs in a car, quick-turn MRI images, algorithms that drive social media—that’s all AI.  You have been vocal in arguing that LLMs can only get us so far. Do you think LLMs are overhyped these days? Can you summarize to our readers why you believe that LLMs are not enough? There is a sense

arXiv:2510.17795v2 Announce Type: replace Abstract: Replicating AI research is a crucial yet challenging task for large language model (LLM) agents. Existing approaches often struggle to generate executable code, primarily due to insufficient background knowledge and the limitations of retrieval-augmented generation (RAG) methods, which fail to capture latent technical details hidden in referenced papers. Furthermore, previous approaches tend to overlook valuable implementation-level code signals and lack structured knowledge representations that support multi-granular retrieval and reuse. To overcome these challenges, we propose Executable Knowledge Graphs (xKG), a pluggable, paper-centric knowledge base that automatically integrates code snippets and technical insights extracted from scientific literature. When integrated into three agent frameworks with two different LLMs, xKG shows substantial performance gains (10.9% with o3-mini) on PaperBench, demonstrating its effectiveness as a general and extensible solution for automated AI research replication. Code is available at https://github.com/zjunlp/xKG.

In this tutorial, we build a production-grade tabular machine learning pipeline using AutoGluon, taking a real-world mixed-type dataset from raw ingestion through to deployment-ready artifacts. We train high-quality stacked and bagged ensembles, evaluate performance with robust metrics, perform subgroup and feature-level analysis, and then optimize the model for real-time inference using refit-full and distillation. Throughout the workflow, we focus on practical decisions that balance accuracy, latency, and deployability. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser !pip -q install -U “autogluon==1.5.0” “scikit-learn>=1.3” “pandas>=2.0” “numpy>=1.24” import os, time, json, warnings warnings.filterwarnings(“ignore”) import numpy as np import pandas as pd from sklearn.model_selection import train_test_split from sklearn.metrics import roc_auc_score, log_loss, accuracy_score, classification_report, confusion_matrix from autogluon.tabular import TabularPredictor We set up the environment by installing the required libraries and importing all core dependencies used throughout the pipeline. We configure warnings to keep outputs clean and ensure numerical, tabular, and evaluation utilities are ready. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser from sklearn.datasets import fetch_openml df = fetch_openml(data_id=40945, as_frame=True).frame target = “survived” df[target] = df[target].astype(int) drop_cols = [c for c in [“boat”, “body”, “home.dest”] if c in df.columns] df = df.drop(columns=drop_cols, errors=”ignore”) df = df.replace({None: np.nan}) print(“Shape:”, df.shape) print(“Target positive rate:”, df[target].mean().round(4)) print(“Columns:”, list(df.columns)) train_df, test_df = train_test_split( df, test_size=0.2, random_state=42, stratify=df[target], ) We load a real-world mixed-type dataset and perform light preprocessing to prepare a clean training signal. We define the target, remove highly leaky columns, and validate the dataset structure. We then create a stratified train–test split to preserve class balance. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def has_gpu(): try: import torch return torch.cuda.is_available() except Exception: return False presets = “extreme” if has_gpu() else “best_quality” save_path = “/content/autogluon_titanic_advanced” os.makedirs(save_path, exist_ok=True) predictor = TabularPredictor( label=target, eval_metric=”roc_auc”, path=save_path, verbosity=2 ) We detect hardware availability to dynamically select the most suitable AutoGluon training preset. We configure a persistent model directory and initialize the tabular predictor with an appropriate evaluation metric. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser start = time.time() predictor.fit( train_data=train_df, presets=presets, time_limit=7 * 60, num_bag_folds=5, num_stack_levels=2, refit_full=False ) train_time = time.time() – start print(f”nTraining done in {train_time:.1f}s with presets='{presets}'”) We train a high-quality ensemble using bagging and stacking within a controlled time budget. We rely on AutoGluon’s automated model search to efficiently explore strong architectures. We also record training time to understand computational cost. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser lb = predictor.leaderboard(test_df, silent=True) print(“n=== Leaderboard (top 15) ===”) display(lb.head(15)) proba = predictor.predict_proba(test_df) pred = predictor.predict(test_df) y_true = test_df[target].values if isinstance(proba, pd.DataFrame) and 1 in proba.columns: y_proba = proba[1].values else: y_proba = np.asarray(proba).reshape(-1) print(“n=== Test Metrics ===”) print(“ROC-AUC:”, roc_auc_score(y_true, y_proba).round(5)) print(“LogLoss:”, log_loss(y_true, np.clip(y_proba, 1e-6, 1 – 1e-6)).round(5)) print(“Accuracy:”, accuracy_score(y_true, pred).round(5)) print(“nClassification report:n”, classification_report(y_true, pred)) We evaluate the trained models using a held-out test set and inspect the leaderboard to compare performance. We compute probabilistic and discrete predictions and derive key classification metrics. It gives us a comprehensive view of model accuracy and calibration. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser if “pclass” in test_df.columns: print(“n=== Slice AUC by pclass ===”) for grp, part in test_df.groupby(“pclass”): part_proba = predictor.predict_proba(part) part_proba = part_proba[1].values if isinstance(part_proba, pd.DataFrame) and 1 in part_proba.columns else np.asarray(part_proba).reshape(-1) auc = roc_auc_score(part[target].values, part_proba) print(f”pclass={grp}: AUC={auc:.4f} (n={len(part)})”) fi = predictor.feature_importance(test_df, silent=True) print(“n=== Feature importance (top 20) ===”) display(fi.head(20)) We analyze model behavior through subgroup performance slicing and permutation-based feature importance. We identify how performance varies across meaningful segments of the data. It helps us assess robustness and interpretability before deployment. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser t0 = time.time() refit_map = predictor.refit_full() t_refit = time.time() – t0 print(f”nrefit_full completed in {t_refit:.1f}s”) print(“Refit mapping (sample):”, dict(list(refit_map.items())[:5])) lb_full = predictor.leaderboard(test_df, silent=True) print(“n=== Leaderboard after refit_full (top 15) ===”) display(lb_full.head(15)) best_model = predictor.get_model_best() full_candidates = [m for m in predictor.get_model_names() if m.endswith(“_FULL”)] def bench_infer(model_name, df_in, repeats=3): times = [] for _ in range(repeats): t1 = time.time() _ = predictor.predict(df_in, model=model_name) times.append(time.time() – t1) return float(np.median(times)) small_batch = test_df.drop(columns=[target]).head(256) lat_best = bench_infer(best_model, small_batch) print(f”nBest model: {best_model} | median predict() latency on 256 rows: {lat_best:.4f}s”) if full_candidates: lb_full_sorted = lb_full.sort_values(by=”score_test”, ascending=False) best_full = lb_full_sorted[lb_full_sorted[“model”].str.endswith(“_FULL”)].iloc[0][“model”] lat_full = bench_infer(best_full, small_batch) print(f”Best FULL model: {best_full} | median predict() latency on 256 rows: {lat_full:.4f}s”) print(f”Speedup factor (best / full): {lat_best / max(lat_full, 1e-9):.2f}x”) try: t0 = time.time() distill_result = predictor.distill( train_data=train_df, time_limit=4 * 60, augment_method=”spunge”, ) t_distill = time.time() – t0 print(f”nDistillation completed in {t_distill:.1f}s”) except Exception as e: print(“nDistillation step failed”) print(“Error:”, repr(e)) lb2 = predictor.leaderboard(test_df, silent=True) print(“n=== Leaderboard after distillation attempt (top 20) ===”) display(lb2.head(20)) predictor.save() reloaded = TabularPredictor.load(save_path) sample = test_df.drop(columns=[target]).sample(8, random_state=0) sample_pred = reloaded.predict(sample) sample_proba = reloaded.predict_proba(sample) print(“n=== Reloaded predictor sanity-check ===”) print(sample.assign(pred=sample_pred).head()) print(“nProbabilities (head):”) display(sample_proba.head()) artifacts = { “path”: save_path, “presets”: presets, “best_model”: reloaded.get_model_best(), “model_names”: reloaded.get_model_names(), “leaderboard_top10″: lb2.head(10).to_dict(orient=”records”), } with open(os.path.join(save_path, “run_summary.json”), “w”) as f: json.dump(artifacts, f, indent=2) print(“nSaved summary to:”, os.path.join(save_path, “run_summary.json”)) print(“Done.”) We optimize the trained ensemble for inference by collapsing bagged models and benchmarking latency improvements. We optionally distill the ensemble into faster models and validate persistence through save-reload checks. Also, we export structured artifacts required for production handoff. In conclusion, we implemented an end-to-end workflow with AutoGluon that transforms raw tabular data into production-ready models with minimal manual intervention, while maintaining strong control over accuracy, robustness, and inference efficiency. We performed systematic error analysis and feature importance evaluation, optimized large ensembles through refitting and distillation, and validated deployment readiness using latency benchmarking and artifact packaging. This workflow enables the deployment of high-performing, scalable, interpretable, and well-suited tabular models for real-world production environments. Check out the FULL CODES here. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post How AutoGluon Enables Modern AutoML Pipelines for Production-Grade Tabular Models with Ensembling and Distillation appeared first on MarkTechPost.

arXiv:2601.12960v1 Announce Type: new Abstract: Integrating deep learning into healthcare enables personalized care but raises trust issues due to model opacity. To improve transparency, we propose a system for dental age estimation from panoramic images that combines an opaque and a transparent method within a natural language generation (NLG) module. This module produces clinician-friendly textual explanations about the age estimations, designed with dental experts through a rule-based approach. Following the best practices in the field, the quality of the generated explanations was manually validated by dental experts using a questionnaire. The results showed a strong performance, since the experts rated 4.77+/-0.12 (out of 5) on average across the five dimensions considered. We also performed a trustworthy self-assessment procedure following the ALTAI checklist, in which it scored 4.40+/-0.27 (out of 5) across seven dimensions of the AI Trustworthiness Assessment List.

arXiv:2509.05309v2 Announce Type: replace-cross Abstract: Sparse Autoencoder (SAE) has emerged as a powerful tool for mechanistic interpretability of large language models. Recent works apply SAE to protein language models (PLMs), aiming to extract and analyze biologically meaningful features from their latent spaces. However, SAE suffers from semantic entanglement, where individual neurons often mix multiple nonlinear concepts, making it difficult to reliably interpret or manipulate model behaviors. In this paper, we propose a semantically-guided SAE, called ProtSAE. Unlike existing SAE which requires annotation datasets to filter and interpret activations, we guide semantic disentanglement during training using both annotation datasets and domain knowledge to mitigate the effects of entangled attributes. We design interpretability experiments showing that ProtSAE learns more biologically relevant and interpretable hidden features compared to previous methods. Performance analyses further demonstrate that ProtSAE maintains high reconstruction fidelity while achieving better results in interpretable probing. We also show the potential of ProtSAE in steering PLMs for downstream generation tasks.

arXiv:2601.12973v1 Announce Type: new Abstract: Large Audio-Language Models (LALMs) have demonstrated strong performance in spoken question answering (QA), with existing evaluations primarily focusing on answer accuracy and robustness to acoustic perturbations. However, such evaluations implicitly assume that spoken inputs remain semantically answerable, an assumption that often fails in real-world interaction when essential information is missing. In this work, we introduce a repair-aware evaluation setting that explicitly distinguishes between answerable and unanswerable audio inputs. We define answerability as a property of the input itself and construct paired evaluation conditions using a semantic-acoustic masking protocol. Based on this setting, we propose the Evaluability Awareness and Repair (EAR) score, a non-compensatory metric that jointly evaluates task competence under answerable conditions and repair behavior under unanswerable conditions. Experiments on two spoken QA benchmarks across diverse LALMs reveal a consistent gap between answer accuracy and conversational reliability: while many models perform well when inputs are answerable, most fail to recognize semantic unanswerability and initiate appropriate conversational repair. These findings expose a limitation of prevailing accuracy-centric evaluation practices and motivate reliability assessments that treat unanswerable inputs as cues for repair and continued interaction.