Hi everyone, I have a quick question about typical timelines for TMLR. I submitted a paper to TMLR, received reviews, and then submitted the rebuttal. It’s now been about 3 weeks since the rebuttal, and there hasn’t been any update yet. I understand TMLR is a journal with rolling submissions and no hard deadlines, so delays are expected. I’ve seen some mentions that the discussion/rebuttal phase is designed to last ~2–4 weeks, and that Action Editors may wait during this period for possible reviewer responses or official recommendations before making a decision. For those who’ve submitted to TMLR before: Is 3–4 weeks after rebuttal still considered normal? How long did it take for you to receive a decision after rebuttal? Just trying to calibrate expectations — not complaining. Thanks in advance! submitted by /u/SynagogueLog [link] [comments]

I am currently at risk of redundancy and was looking for jobs when I found these options within the UK government. Looks like they are working on some great projects and the salaries are better than what I’d expect from a Civil Services role. The selection process looks daunting. A 4-hour long take-home project, followed by a presentation and panel interviews. Has anyone gone through the whole process and can share insights? submitted by /u/siberthrow [link] [comments]

TL;DR: We collected 87,871 observations showing AI epistemic self-assessment produces consistent, calibratable measurements. No consciousness claims required. The Conflation Problem When people hear "AI assesses its uncertainty," they assume it requires consciousness or introspection. It doesn't. Functional Measurement Phenomenological Introspection "Rate your knowledge 0-1" "Are you aware of your states?" Evaluating context window Accessing inner experience Thermometer measuring temp Thermometer feeling hot A thermometer doesn't need to feel hot. An LLM evaluating knowledge state is doing the same thing - measuring information density, coherence, domain coverage. Properties of the context window, not reports about inner life. The Evidence: 87,871 Observations 852 sessions, 308 clean learning pairs: 91.3% showed knowledge improvement Mean KNOW delta: +0.172 (0.685 → 0.857) Calibration variance drops 62× as evidence accumulates Evidence Level Variance Reduction Low (5) 0.0366 baseline High (175+) 0.0006 62× tighter That's Bayesian convergence. More data → tighter calibration → reliable measurements. For the Skeptics Don't trust self-report. Trust the protocol: Consistent across similar contexts? ✓ Correlates with outcomes? ✓ Systematic biases correctable? ✓ Improves with data? ✓ (62× variance reduction) The question isn't "does AI truly know what it knows?" It's "are measurements consistent, correctable, and useful?" That's empirically testable. We tested it. Paper + dataset: Empirica: Epistemic Self-Assessment for AI Systems Code: github.com/Nubaeon/empirica Independent researcher here. If anyone has arXiv endorsement for cs.AI and is willing to help, I'd appreciate it. The endorsement system is... gatekeepy. submitted by /u/entheosoul [link] [comments]

I've been compiling papers on Physical AI — the intersection of foundation models and robotics. This covers Vision-Language-Action (VLA) models like RT-2 and π₀, world models (DreamerV3, Genie 2, JEPA), diffusion policies, real-world deployment and latency problems, cross-embodiment transfer, scaling laws, and safety/alignment for robots. The field has exploded in the past 18 months. We went from "lets try llms on robotics" to having so many dimensions to optimize for. so felt right to maintain a running list of resources. Organized by: foundations → architectures → action representations → world models → learning paradigms → deployment → applications. Contributions welcome — especially corrections and missing papers. https://github.com/keon/awesome-physical-ai submitted by /u/kwk236 [link] [comments]

In this post, we explore the security considerations and best practices for implementing Amazon Bedrock cross-Region inference profiles. Whether you're building a generative AI application or need to meet specific regional compliance requirements, this guide will help you understand the secure architecture of Amazon Bedrock CRIS and how to properly configure your implementation.

Work at Bifrost and wanted to share how we built semantic caching into the gateway. Architecture: Dual-layer: exact hash matching + vector similarity search Use text-embedding-3-small for request embeddings Weaviate for vector storage (sub-millisecond retrieval) Configurable similarity threshold per use case Key implementation decisions: Conversation-aware bypass - Skip caching when conversation history exceeds threshold. Long contexts drift topics and cause false positives. Model/provider isolation - Separate cache namespaces per model and provider. GPT-4 responses shouldn't serve from Claude cache. Per-request overrides - Support custom TTL and threshold via headers. Some queries need strict matching, others benefit from loose thresholds. Streaming support - Cache complete streamed responses with proper chunk ordering. Trickier than it sounds. Performance constraints: Had to keep overhead under 10µs. Embedding generation happens async after serving the first request, doesn't block response. The trickiest part was handling edge cases - empty messages, system prompt changes, cache invalidation timing. Those details matter more than the happy path. Code is open source if anyone wants to dig into the implementation: https://github.com/maximhq/bifrost Happy to answer technical questions about the approach. submitted by /u/dinkinflika0 [link] [comments]

This really irks me for some reason but there's like 10,000 explanations for mHC online while the only instance of someone actually trying to explore mHC in code is a single github repo (props to the repo). I just want to be able to implement it and plug it into existing projects. I don't need yet another analogy for why a cat won't fall off a cliff the ground isn't tipped over. This reminds me of my physics days when I'd see a constant stream of gurus explain some philosophy behind energy and the universe when they can't even take an eigenvalue. Like stay in your lane buddy. Or I guess multiple lanes... submitted by /u/Affectionate_Use9936 [link] [comments]

So sharing some of our work we published at NeurIPS 2025 as a Spotlight. Weights and code are public (see ArXiv). TL;DR: Vision Transformers typically have artifacts in their dense features. While the exact reason is unknown, there is consensus that adding so called "register" tokens mitigates this issue. These tokens participate in the self-attention process, but are not used for the output. When introduced with DINOv2 models in ICLR 2024, this requires vision transformers to be trained from scratch -- which obviously most people cannot afford. We show that you can actually get the benefits of registers pretty cheaply with existing pre-trained models without ANY labeled images. You can leverage the semantic invariance of images under shift & left-right flip (most natural images, obviously don't flip images that contain text). We simply randomly augment the image multiple times, pad the borders with white, and un-shift/un-flip the dense features, and average over augmentations to use as a distillation target. Surprisingly this extremely simple approach (Post Hoc Registers, PH-Reg) improves dense features for segmentation and depth across all datasets compared to both the student and the non-augmented teacher. Our results are better than traditional attention modifications (MaskCLIP -- ECCV 22, SCLIP -- ECCV 24, ClearCLIP -- ECCV 24, NACLIP -- WACV 25), and much cheaper than Denoising Vision Transformers since we don't need to utilize neural fields. Our results introduce minimal additional parameters compared to the original model. submitted by /u/44seconds [link] [comments]

GitHub: Engram: https://github.com/deepseek-ai/Engram arXiv:2601.07372 [cs.CL]: https://arxiv.org/abs/2601.07372 "While Mixture-of-Experts (MoE) scales capacity via conditional computation, Transformers lack a native primitive for knowledge lookup, forcing them to inefficiently simulate retrieval through computation. To address this, we introduce conditional memory as a complementary sparsity axis, instantiated via Engram, a module that modernizes classic N-gram embedding for O(1) lookup. By formulating the Sparsity Allocation problem, we uncover a U-shaped scaling law that optimizes the trade-off between neural computation (MoE) and static memory (Engram). Guided by this law, we scale Engram to 27B parameters, achieving superior performance over a strictly iso-parameter and iso-FLOPs MoE baseline. Most notably, while the memory module is expected to aid knowledge retrieval (e.g., MMLU +3.4; CMMLU +4.0), we observe even larger gains in general reasoning (e.g., BBH +5.0; ARC-Challenge +3.7) and code/math domains~(HumanEval +3.0; MATH +2.4). Mechanistic analyses reveal that Engram relieves the backbone's early layers from static reconstruction, effectively deepening the network for complex reasoning. Furthermore, by delegating local dependencies to lookups, it frees up attention capacity for global context, substantially boosting long-context retrieval (e.g., Multi-Query NIAH: 84.2 to 97.0). Finally, Engram establishes infrastructure-aware efficiency: its deterministic addressing enables runtime prefetching from host memory, incurring negligible overhead. We envision conditional memory as an indispensable modeling primitive for next-generation sparse models." submitted by /u/Nunki08 [link] [comments]

I’ve been watching how companies procure AI infrastructure lately, and it’s honestly a bit of a train wreck. Most procurement teams and CFOs are making decisions based on one single metric: $/GPU/hour. The problem? The sticker price on a cloud pricing sheet is almost never the real cost. I’m considering offering a specialized TCO (Total Cost of Ownership) Consulting Service for AI compute, and I want to see if there’s a real market for it. Based on my experience and some recent industry data, here is why a "cheap" cluster can end up costing $500k+ more than a "premium" one: 1. The "Performance-Adjusted" Trap (MFU & TFLOPS) Most people assume a H100 is a H100 regardless of the provider. It’s not. The MFU Gap: Industry average Model FLOPs Utilization (MFU) is around 35-45%. A "true" AI cloud can push this significantly higher. The Math: If Provider A has 20% higher delivered TFLOPS than Provider B at the same hourly rate, Provider B would have to cut their price by ~20% just to match the value. Real-World Impact: In a 30B parameter model training scenario (1,000 GPUs), higher efficiency can save you thousands of dollars and hours of time on a single run. 2. The "Hidden" Support Infrastructure This is where the CFOs get blindsided. They approve the GPU budget but forget the plumbing. Egress & Storage: Moving 20PB of data on a legacy hyperscaler can cost between $250k and $500k in hidden fees (write/read requests, data retrieval, and egress). Networking at Scale: If the network isn't purpose-built for AI, you hit bottlenecks that leave your expensive GPUs sitting idle. Operational Drag: If your team spends a week just setting up the cluster instead of running workloads on "Day 1," you’ve already lost the ROI battle. 3. The Intangibles (Speed to Market) In AI, being first is a competitive advantage. Reliability = fewer interruptions. Better tooling = higher researcher productivity. Faster training = shorter development cycles. My Pitch: I want to help companies stop looking at "sticker prices" and start looking at "Performance-Adjusted Cost." I’d provide a full report comparing vendors (CoreWeave, Lambda, AWS, GCP, etc.) specifically for their workload, covering everything from MFU expectations to hidden data movement fees. My questions for the community: Is your procurement team actually looking at MFU/Goodput, or just the hourly rate? Have you ever been burned by "hidden" egress/storage fees after signing a contract? Would you (or your boss) pay for a third-party audit/report to save 20-30% on a multi-million dollar compute buy? Curious to hear your thoughts. submitted by /u/New_Friendship9113 [link] [comments]

After 8 years building production ML systems (in data quality, entity resolution, diagnostics), I keep running into the same problem: Models with great offline metrics fail in production because they learn correlations, not causal mechanisms. I just started a 5-part series on building causal ML systems on the NeoForge Labs research blog. Part 1 covers: Why correlation fails - The ice cream/drowning example, but with real production failures Pearl's Ladder of Causation - Association, Intervention, Counterfactuals Practical implications - When does this actually matter? Case study - Plant disease diagnosis (correlation vs. causal approach) Key insight: Your model can predict disease with 90% accuracy but still give recommendations that make things worse. Because prediction ≠ intervention. The series builds up to implementing a full causal inference system using DoWhy, with counterfactual reasoning and intervention optimization. Link (free to read): https://blog.neoforgelabs.tech/why-causality-matters-for-ai (Also available on Medium for members) Next parts: - Part 2 (Wed): Building Causal DAGs - Part 3 (Fri): Counterfactual Reasoning - Parts 4-5 (next week): Interventions + Distributed Systems Would love to hear your thoughts, especially if you've dealt with distribution shift, confounding, or intervention prediction in production. Questions I'm exploring: - When is causal inference overkill vs. essential? - What's the practical overhead of DAG construction? - How do you validate causal assumptions? Happy to discuss in the comments! submitted by /u/KelynPaul [link] [comments]

Abstract-style summary We introduce a closed-loop method for guiding LLM-based agents using explicit game-theoretic feedback. Agent interaction logs are transformed into structured graphs, a zero-sum attacker–defender game is solved on the graph (Nash equilibrium), and the resulting equilibrium statistics are injected back into the agent’s system prompt as a strategic control signal. Method • Automatic graph extraction from agent logs • Effort-based scoring replacing static probabilities • Nash equilibrium computation on dynamically inferred graphs • Periodic feedback into the agent’s planning loop Results • Success rate: 20.0% → 42.9% (44-run benchmark) • Tool-use variance: −5.2× • Expected time-to-success: −2.7× Paper (PDF): https://arxiv.org/pdf/2601.05887 Code: https://github.com/aliasrobotics/cai submitted by /u/Obvious-Language4462 [link] [comments]

Hi all, With the MLSys 2026 rebuttal phase currently ongoing, I thought it might be useful to start a constructive discussion about experiences with the reviews so far. A few optional prompts, if helpful: Do the reviews seem to reflect strong domain familiarity with your work? How consistent are the scores and written feedback across reviewers? Are the main concerns clear and addressable in a rebuttal? Any advice or strategies for writing an effective MLSys rebuttal? The goal here isn’t to complain or speculate about outcomes, but to share patterns and practical insights that might help authors navigate the rebuttal process more effectively. Feel free to keep things high-level and anonymous. Looking forward to hearing others’ perspectives. submitted by /u/TheUltimateAnswer_42 [link] [comments]

I’ve been experimenting with a hybrid setup where a traditional actuarial model provides a baseline mortality prediction, and a small neural network learns a residual correction on top of it. The idea is to test whether ML can add value after a strong domain model is already in place. Setup: - 10 random seeds - 10‑fold CV per seed - deterministic initialization - isotonic calibration - held‑out external validation file - hybrid = weighted blend of actuarial + NN residual (weights learned per‑sample) Cross‑validated AUC lift (hybrid – actuarial): Lift by seed: 0 0.0421 1 0.0421 2 0.0413 3 0.0415 4 0.0404 5 0.0430 6 0.0419 7 0.0421 8 0.0421 9 0.0406 Folds where hybrid > actuarial: seed 0 10 1 10 2 10 3 10 4 9 5 9 6 10 7 9 8 9 9 9 Overall averages: Pure AUC: 0.7001 Hybrid AUC: 0.7418 Net lift: 0.0417 Avg weight: 0.983 External validation (held‑out file): Brier (Actuarial): 0.011871 Brier (Hybrid): 0.011638 The actuarial model is already strong, so the NN seems to be making small bias corrections rather than large structural changes. The lift is consistent but modest. My question: For those who have worked with hybrid domain‑model + NN systems, how do you evaluate whether the NN is providing meaningful value? I’m especially interested in: - interpreting small but consistent AUC/Brier gains - tests you’d run to confirm the NN isn’t just overfitting noise - any pitfalls you’ve seen when combining deterministic models with learned components Happy to share more details if useful. submitted by /u/richtnyc [link] [comments]

This post is co-written with Sunaina Kavi, AI/ML Product Manager at Omada Health. Omada Health, a longtime innovator in virtual healthcare delivery, launched a new nutrition experience in 2025, featuring OmadaSpark, an AI agent trained with robust clinical input that delivers real-time motivational interviewing and nutrition education. It was built on AWS. OmadaSpark was designed

We're releasing FASHN Human Parser, a SegFormer-B4 fine-tuned for human parsing in fashion contexts. Background: Dataset quality issues Before training our own model, we spent time analyzing the commonly used datasets for human parsing: ATR, LIP, and iMaterialist. We found consistent quality issues that affect models trained on them: ATR: Annotation "holes" where background pixels appear inside labeled regions Label spillage where annotations extend beyond object boundaries LIP: Same issues as ATR (same research group) Inconsistent labeling between left/right body parts and clothing Aggressive crops from multi-person images causing artifacts Ethical concerns (significant portion includes minors) iMaterialist: Higher quality images and annotations overall Multi-person images where only one person is labeled (~6% of dataset) No body part labels (clothing only) We documented these findings in detail: Fashion Segmentation Datasets and Their Common Problems What we did We curated our own dataset addressing these issues and fine-tuned a SegFormer-B4. The model outputs 18 semantic classes relevant for fashion applications: Body parts: face, hair, arms, hands, legs, feet, torso Clothing: top, dress, skirt, pants, belt, scarf Accessories: bag, hat, glasses, jewelry Background Technical details Spec Value Architecture SegFormer-B4 (MIT-B4 encoder + MLP decoder) Input size 384 x 576 Output Segmentation mask at input resolution Model size ~244MB Inference ~300ms GPU, 2-3s CPU The PyPI package uses cv2.INTER_AREA for preprocessing (matching training), while the HuggingFace pipeline uses PIL LANCZOS for broader compatibility. Links PyPI: pip install fashn-human-parser HuggingFace: fashn-ai/fashn-human-parser Demo: HuggingFace Space GitHub: fashn-AI/fashn-human-parser Dataset analysis: Blog post Limitations Optimized for fashion/e-commerce images (single person, relatively clean backgrounds) Performance may degrade on crowded scenes or unusual poses 18-class schema is fashion-focused; may not suit all human parsing use cases Happy to discuss the dataset curation process, architecture choices, or answer any questions. submitted by /u/JYP_Scouter [link] [comments]

I’m a graduate student working in machine learning and dynamical systems, and I’m trying to build a solid foundation (and bookshelf!) for deeper study and research. I’d love to hear what books people here consider essential or transformative when it comes to understanding both the theoretical and applied sides of ML. I’m especially interested in recommendations that cover topics like: Neural ODEs/PDEs/SDEs Physics-Informed Neural Networks (PINNs) Dynamical systems modeling and simulations with ML Applied mathematics approaches to deep learning That said, I’d also appreciate more general ML “classics” that every researcher should be familiar with — from theory to implementation. If you’ve gone through a grad or research path in this area, what books (or maybe lecture notes, monographs, or papers) were game-changers for you? Would also love to hear why you’d recommend a particular book — e.g., clarity, depth, or practical usefulness. Thanks in advance! Hoping this thread can help others building a focused reading list too. Edit 1: Thanks a lot everyone, for all these. I shall go through them all gradually, and they all seem amazing resources. (Hopefully I will cite you guys and this post in my thesis :p) submitted by /u/cutie_roasty [link] [comments]

TL;DR A lot of LLM eval pipelines treat “LLM-as-judge” as a rough but usable proxy for quality. I kept running into something that felt off: different judges would give very different scores, yet each judge was weirdly consistent with itself. This paper tries to measure that effect and show it’s not random noise. What I did: I set up a simple multi-judge pipeline and ran the same items through multiple “judge” models, multiple times, using the same rubric and strict JSON output. Dataset 1: YouTube → SEO content packs - 30 YouTube videos, 15 categories - 4 generated “content packs” per video - 120 video×pack pairs - 3 runs × 9 judges = 3,240 total evaluations Judges: Claude-Opus-4.5, Claude-Sonnet-4.5, GPT-5.2, GPT-4.1, Gemini-3-Pro-Preview, Grok-3, DeepSeek-R1, Llama-405B, Mistral-v3-Large Rubric: Five 1–5 dimensions: Intent/Angle, Coverage, Faithfulness + receipts, Readability, and SEO mechanics. Judges also had to include quoted “receipts” from the source. What fell out of it: Across judges, agreement is basically near zero: - Krippendorff’s α (overall) ≈ 0.042 A couple dimensions even go negative (systematic disagreement), especially Readability and SEO mechanics. But many judges are stable with themselves Across three runs, within-judge reliability (ICC(3,1)) ranges from about -0.04 up to 0.87. Several judges are above 0.8. So the same judge will usually make the same call, even when other judges disagree. You can often tell which judge produced the eval If you treat “which judge wrote this evaluation row?” as a classification task: • Scores only: 77.1% accuracy (9-way) • Evidence/disposition features only: 71.5% • Combined: 89.9% Even within a single provider, the signal is strong: • GPT-4.1 vs GPT-5.2: 99.6% This isn’t just “who’s harsher.” The shape of the scores across dimensions and the way receipts are used is informative. Receipts behave differently too: I also looked at whether receipts actually exist in the source text and whether they really support the justification under a conservative entailment-style check. Some judges cite a lot but with weaker linkage, others cite less but more tightly. Second domain (to see if this was a fluke) I repeated the idea on a different setup: • 15 Wikipedia articles • A structured “briefing pack” output format • Controlled variants: clean, hallucination-poisoned, coverage-poisoned, structure-poisoned The fingerprints carry over: • Combined judge ID is about 90% • GPT-4.1 vs GPT-5.2 hits 100% in this regime Also, hallucination detection varies a lot by judge. Some reliably penalize poisoned content, others barely move. I’d love your feedback. My follow up work will be temporal delta and new regimes/domains with diff eval rubrics submitted by /u/PromptOutlaw [link] [comments]

I’ve been exploring the "Inference Paradox"—the performance gap between transcendental-heavy activations (Swish/GELU) and hardware-efficient but jagged approximations (HardSwish). I am sharing SATIN-U (Smoothstep-Activated Trainable Inference Network), which utilizes a cubic polynomial bridge to achieve Swish-like fidelity without the exponential math tax. The Implementation Logic: The goal was to maintain a differentiable path while ensuring an absolute zero floor for hardware-level sparsity (clock gating). The Math: u = clamp(0.5 + 0.5 * (x / b), 0, 1) gate = u * u * (3 - 2 * u) y = x * gate Technical Benefits for Deployment: Zero-Skip Execution: Unlike Swish/GELU, this hits true zero, allowing sparse-aware kernels to skip ~60-70% of calculations in deep layers. Transcendental Tax Removal: By using pure arithmetic (multiplications/additions), it avoids the Transcendental Function Unit (SFU) bottleneck on modern silicon. Learnable Continuity: By setting 'b' as a learnable parameter ($b \approx 3.7$), the network can "sculpt" its own material—retaining smoothness in sensory layers while snapping to jagged logic in deep layers. PyTorch Implementation: import torch import torch.nn as nn class MorphicActivation(nn.Module): def __init__(self, b=3.7): super().__init__() # 'b' can be a fixed constant or a learnable parameter self.b = nn.Parameter(torch.tensor([b])) def forward(self, x): u = torch.clamp(0.5 + 0.5 * (x / self.b), 0, 1) gate = u * u * (3 - 2 * u) return x * gate I’m interested in hearing from anyone working on custom Triton kernels or NPU deployment. How are you currently handling the branch prediction overhead for piecewise approximations compared to smooth polynomials like this? I've found this to be a significant "drop-in" win for mobile-class silicon where power efficiency is the primary constraint. submitted by /u/Acrobatic-Bee8495 [link] [comments]

Sakana AI introduced a new method called DroPE to extend the context length of pretrained LLMs without the massive compute costs usually associated with long-context fine-tuning. The core insight of this work challenges a fundamental assumption in Transformer architecture. They discovered that explicit positional embeddings like RoPE are critical for training convergence, but eventually become the primary bottleneck preventing models from generalizing to longer sequences. submitted by /u/AhmedMostafa16 [link] [comments]

I've tried doing sanity checks and they work great for the most part, but what if there is just a part of the data, or an instance where the model fails? How do you watch out for something like that so that hours of GPU compute just don't go down the drain. I've also heard about saving weights/progress at certain checkpoints, but for other tasks such as model evals how would that work? submitted by /u/Specialist-Pool-6962 [link] [comments]

Hi everyone, I’m part of the team that developed PerpetualBooster, a gradient boosting algorithm designed to solve the "forgetting" and "retraining" bottlenecks in traditional GBDT frameworks like XGBoost or LightGBM. We’ve just launched a serverless cloud platform to operationalize it, but I wanted to share the underlying tech and how we’re handling the ML lifecycle for tabular data. The main challenge with most GBDT implementations is that retraining on new data usually requires O(n^2) complexity over time. We’ve optimized our approach to support Continual Learning with O(n) complexity, allowing models to stay updated without full expensive recomputes. In our internal benchmarks, it is currently outperforming AutoGluon in several tabular datasets regarding both accuracy and training efficiency: https://github.com/perpetual-ml/perpetual?tab=readme-ov-file#perpetualbooster-vs-autogluon We’ve built a managed environment around this to remove the "Infra Tax" for small teams: Reactive Notebooks: We integrated Marimo as the primary IDE. It’s fully serverless, so you aren't paying for idle kernels. Drift-Triggered Learning: We built-in automated data/concept drift monitoring that can natively trigger the O(n) continual learning tasks. Production Endpoints: Native serverless inference that scales to zero. Pipeline: Integrated data quality checks and a model registry that handles the transition from Marimo experiments to production APIs. You can find PerpetualBooster on GitHub https://github.com/perpetual-ml/perpetual and pip. If you want to try the managed environment (we’ve just moved it out of the Snowflake ecosystem to a standalone cloud), you can check it out here:https://app.perpetual-ml.com/signup submitted by /u/mutlu_simsek [link] [comments]

After DeepSeek’s mHC paper, the Sinkhorn–Knopp algorithm has attracted a lot of attention because it turns $$\mathcal{H}^{\mathrm{res}}_{l}$$ at each layer into a doubly stochastic matrix. As a result, the layerwise product remains doubly stochastic, and since the L_2 (spectral) norm of a doubly stochastic matrix is 1, this helps prevent vanishing or exploding gradients. This makes me wonder why such an apparently straightforward idea wasn’t discussed more during the era of recurrent neural networks, where training dynamics also involve products of many matrices. submitted by /u/Delicious_Screen_789 [link] [comments]

Honestly tired of seeing all the top tier labs pushing their papers to arxiv and publicizing it like crazy on X and other platforms. Like the work hasn’t even been reviewed and becomes a “media trial” just because its from a prestigious institution. The academic system needs a serious overhaul. submitted by /u/casualcreak [link] [comments]

I want to find small / mid scale startups that offer roles for undergraduate researcher internships or otherwise. I am currently working in a research lab as an undergraduate research intern and have a paper under review at ACL 2026 . I also have 2 papers in the pipeline but this position is unpaid. and I want to pick a role as maybe ML researcher or ML intern at some startup as a side gig maybe move full focus if I like the research direction and pay. submitted by /u/Correct_Scene143 [link] [comments]

In this post, we explore how Amazon Nova Multimodal Embeddings addresses the challenges of crossmodal search through a practical ecommerce use case. We examine the technical limitations of traditional approaches and demonstrate how Amazon Nova Multimodal Embeddings enables retrieval across text, images, and other modalities. You learn how to implement a crossmodal search system by generating embeddings, handling queries, and measuring performance. We provide working code examples and share how to add these capabilities to your applications.

Quantized models can be seamlessly deployed on Amazon SageMaker AI using a few lines of code. In this post, we explore why quantization matters—how it enables lower-cost inference, supports deployment on resource-constrained hardware, and reduces both the financial and environmental impact of modern LLMs, while preserving most of their original performance. We also take a deep dive into the principles behind PTQ and demonstrate how to quantize the model of your choice and deploy it on Amazon SageMaker.

Beekeeper’s automated leaderboard approach and human feedback loop system for dynamic LLM and prompt pair selection addresses the key challenges organizations face in navigating the rapidly evolving landscape of language models.

This post, developed through a strategic scientific partnership between AWS and the Instituto de Ciência e Tecnologia Itaú (ICTi), P&D hub maintained by Itaú Unibanco, the largest private bank in Latin America, explores the technical aspects of sentiment analysis for both text and audio. We present experiments comparing multiple machine learning (ML) models and services, discuss the trade-offs and pitfalls of each approach, and highlight how AWS services can be orchestrated to build robust, end-to-end solutions. We also offer insights into potential future directions, including more advanced prompt engineering for large language models (LLMs) and expanding the scope of audio-based analysis to capture emotional cues that text data alone might miss.

This post provides a detailed architectural overview of how TrueLook built its AI-powered safety monitoring system using SageMaker AI, highlighting key technical decisions, pipeline design patterns, and MLOps best practices. You will gain valuable insights into designing scalable computer vision solutions on AWS, particularly around model training workflows, automated pipeline creation, and production deployment strategies for real-time inference.

This two-part series explores Flo Health's journey with generative AI for medical content verification. Part 1 examines our proof of concept (PoC), including the initial solution, capabilities, and early results. Part 2 covers focusing on scaling challenges and real-world implementation. Each article stands alone while collectively showing how AI transforms medical content management at scale.

This post shows an automated PII detection and redaction solution using Amazon Bedrock Data Automation and Amazon Bedrock Guardrails through a use case of processing text and image content in high volumes of incoming emails and attachments. The solution features a complete email processing workflow with a React-based user interface for authorized personnel to more securely manage and review redacted email communications and attachments. We walk through the step-by-step solution implementation procedures used to deploy this solution. Finally, we discuss the solution benefits, including operational efficiency, scalability, security and compliance, and adaptability.

Observe.ai developed the One Load Audit Framework (OLAF), which integrates with SageMaker to identify bottlenecks and performance issues in ML services, offering latency and throughput measurements under both static and dynamic data loads. In this blog post, you will learn how to use the OLAF utility to test and validate your SageMaker endpoint.

Please post your personal projects, startups, product placements, collaboration needs, blogs etc. Please mention the payment and pricing requirements for products and services. Please do not post link shorteners, link aggregator websites , or auto-subscribe links. -- Any abuse of trust will lead to bans. Encourage others who create new posts for questions to post here instead! Thread will stay alive until next one so keep posting after the date in the title. -- Meta: This is an experiment. If the community doesnt like this, we will cancel it. This is to encourage those in the community to promote their work by not spamming the main threads. submitted by /u/AutoModerator [link] [comments]

This article is divided into five parts; they are: • An Example of Tensor Parallelism • Setting Up Tensor Parallelism • Preparing Model for Tensor Parallelism • Train a Model with Tensor Parallelism • Combining Tensor Parallelism with FSDP Tensor parallelism originated from the Megatron-LM paper.

For Job Postings please use this template Hiring: [Location], Salary:[], [Remote | Relocation], [Full Time | Contract | Part Time] and [Brief overview, what you're looking for] For Those looking for jobs please use this template Want to be Hired: [Location], Salary Expectation:[], [Remote | Relocation], [Full Time | Contract | Part Time] Resume: [Link to resume] and [Brief overview, what you're looking for] ​ Please remember that this community is geared towards those with experience. submitted by /u/AutoModerator [link] [comments]

This article is divided into five parts; they are: • Introduction to Fully Sharded Data Parallel • Preparing Model for FSDP Training • Training Loop with FSDP • Fine-Tuning FSDP Behavior • Checkpointing FSDP Models Sharding is a term originally used in database management systems, where it refers to dividing a database into smaller units, called shards, to improve performance.

If you've built chatbots or worked with language models, you're already familiar with how AI systems handle memory within a single conversation.

This article is divided into six parts; they are: • Pipeline Parallelism Overview • Model Preparation for Pipeline Parallelism • Stage and Pipeline Schedule • Training Loop • Distributed Checkpointing • Limitations of Pipeline Parallelism Pipeline parallelism means creating the model as a pipeline of stages.

This post shows you how to migrate your self-managed MLflow tracking server to a MLflow App – a serverless tracking server on SageMaker AI that automatically scales resources based on demand while removing server patching and storage management tasks at no cost. Learn how to use the MLflow Export Import tool to transfer your experiments, runs, models, and other MLflow resources, including instructions to validate your migration's success.

This post demonstrates how to solve this challenge by building an AI-powered website assistant using Amazon Bedrock and Amazon Bedrock Knowledge Bases.

Predicting the future has always been the holy grail of analytics.

This article is divided into two parts; they are: • Data Parallelism • Distributed Data Parallelism If you have multiple GPUs, you can combine them to operate as a single GPU with greater memory capacity.

This article is divided into two parts; they are: • Using `torch.

This article is divided into three parts; they are: • Floating-point Numbers • Automatic Mixed Precision Training • Gradient Checkpointing Let's get started! The default data type in PyTorch is the IEEE 754 32-bit floating-point format, also known as single precision.

In this post, we explore how to programmatically create an IDP solution that uses Strands SDK, Amazon Bedrock AgentCore, Amazon Bedrock Knowledge Base, and Bedrock Data Automation (BDA). This solution is provided through a Jupyter notebook that enables users to upload multi-modal business documents and extract insights using BDA as a parser to retrieve relevant chunks and augment a prompt to a foundational model (FM).

Enterprise organizations increasingly rely on web-based applications for critical business processes, yet many workflows remain manually intensive, creating operational inefficiencies and compliance risks. Despite significant technology investments, knowledge workers routinely navigate between eight to twelve different web applications during standard workflows, constantly switching contexts and manually transferring information between systems. Data entry and validation tasks

In this post, we explore how agentic QA automation addresses these challenges and walk through a practical example using Amazon Bedrock AgentCore Browser and Amazon Nova Act to automate testing for a sample retail application.

In this post, we demonstrate how to optimize large language model (LLM) inference on Amazon SageMaker AI using BentoML's LLM-Optimizer to systematically identify the best serving configurations for your workload.

If you have an interest in agentic coding, there's a pretty good chance you've heard of

In this post, we explore how Mantle, Amazon's next-generation inference engine for Amazon Bedrock, implements a zero operator access (ZOA) design that eliminates any technical means for AWS operators to access customer data.

In this post, we explore the new AWS AI League challenges and how they are transforming how organizations approach AI development. The grand finale at AWS re:Invent 2025 was an exciting showcase of their ingenuity and skills.

In this post, we demonstrate how to use Foundation Models (FMs) from Amazon Bedrock and the newly launched Amazon Bedrock AgentCore alongside W&B Weave to help build, evaluate, and monitor enterprise AI solutions. We cover the complete development lifecycle from tracking individual FM calls to monitoring complex agent workflows in production.

In this post, we share how dLocal worked closely with the AWS team to help shape the product roadmap, reinforce its role as an industry innovator, and set new benchmarks for operational excellence in the global fintech landscape.

This article is divided into two parts; they are: • What Is Perplexity and How to Compute It • Evaluate the Perplexity of a Language Model with HellaSwag Dataset Perplexity is a measure of how well a language model predicts a sample of text.