Basically I have a ranking service for b2b SaaS but basically like hotels flights etc The models do well and I can improve accuracy pretty easily to a point But if I want to promote options better for other metrics I'm struggling to change behavior other than people selectng the same thing lower Just hoping for experiences for those in ranking specifically and anything they might have tried other than traditional lighting ranking etc submitted by /u/Xamius [link] [comments]

PhD computational Physics from USA and 3 yrs of Postdoc in the USA. Transitioned to DS in early 2022. Mainly worked with Text data (embedding related word2vec to Transformer based, AI solutions too but Prompt based no agent based solution), Traditional ML & NeuralNets for classification and regression. Python, SQL and PySpark tech stack, AWS & snowflake platforms. Comfortable with either Linux/Unix or windows. How is the job market ? What are the chances of finding Job by end of my 2-3 months of severance ? What should I prepare the most ? How shall I approach the job market? Currently remote at a decent Midwest city. Any suggestions and advice will be appreciated. Thank you submitted by /u/dead_n_alive [link] [comments]

Link: https://arxiv.org/pdf/2604.27883 Hi, Most of use are familiar with the headache of training a neural network using gradient descent where the training error may go to zero but the test error may stay the same as initialization or even increases. My paper treats this phenomena as a consequence of data reuse bias and can be isolated by studying full batch gradient descent on a set of stylize Gaussian mixture models. I turns out that this fundamental issue can be avoided using some clever tricks from high-dimensional statistical theory, specifically approximate message passing (which is beyond the scope of this post but I would be happy to explain more). By doing so I created a training method called Decoupled Descent (DD) which generates a certificate that the training error of the network will asymptotically equal the testing error at each parameter iterate. I think this method gives a cool way to approach how to train networks and I was hoping to get y'alls input on it. It opens up some nice ideas for optimal stopping or hyperparameter tuning and future directions of pushing to something like SGD or more general models. I have attached the train-test curves on a simple model fitting problem to compare the performance of GD with with DD (my algorithm) to give a high-level idea of what the method can guarantee. I stress this is a theory paper so there is a long way to go to get to very large models but I think it is a good first step. 100 simulations of a simple high dimensional XOR model for a bespoke two layer network. Left is training with GD, right its training with my method. The colored bands are 25% to 75% quantile. Happy to answer whatever questions people have, I plan on writing a PyTorch compatible package for this training method one day so any feature suggestions would be welcome as well. submitted by /u/mlovik1 [link] [comments]

Back after ~6 months — rebuilding my spiking language model around CPU-first inference Hey everyone. It’s been around six months since I last posted anything about this project here. Some of you might remember Project NORD, my experimental hybrid spiking / brain-inspired language model architecture. I basicall disappeared for a while 😅, but recently I came back to the project, went through the old architecture again, and realized I didn’t really want to keep stacking fixes on top of it. So instead, I’ve started rebuilding a pretty large part of the system. The new version is called: NORD 5.5 — Flash The main idea this time is pretty simple: What happens if I design the architecture around CPU inference from the beginning, instead of building soething Transformer-like and trying to optimize it later? A lot is changing internally. The current design uses things like: strictly causal processing no standard quadratic attention in the main inference path causal convolution-style token mixing token-time LIF / event dynamics sensory → association → memory → executive processing stages top-1 sparse MoE + a shared expert persistent recurrent memory separate structural, personal and auxiliary memory banks persistent recurrent identity state factorized vocabulary embedding/output streaming token-by-token inference One of the biggest changes is actually something much simpler. Older versions of NORD used an artificial internal spike-time dimension, roughly like this: token -> T0 -> T1 -> T2 -> ... -> T9 I’m mostly getting rid of that. Instead, the actual language sequence becomes the time axis: token0 -> token1 -> token2 -> token3 -> ... That removes a lot of intermediate state and makes the whole architecture considerably cleaner. Going back through the old code also exposed a few things I wasn’t very happy with. Some experimental modules weren’t completely causal, memory was coupled too much to sequence shape, and parts of the STDP system ended up being more disconnected from real training than I originally intended. So NORD 5.5 isn’t really about throwing even more “brain-inspired” components into the model. It’s mostly about simplifying the core and making the things that remain actually work together properly. I’m definitely not claiming this is going to beat Transformers, RWKV-style models, linear attention models, etc. Right now it’s still very much an experiment. The part that actually matters comes next: training and benchmarking it. Things I want to compare: NORD 5.0 vs NORD 5.5 CPU tokens/sec RAM usage perplexity / validation loss long-context behaviour memory on/off MoE on/off spiking components on/off I’m especially curious to hear from anyone working on SNNs, recurrent models, sparse MoE, CPU inference, or weird alternative language-model architectures in general. After not touching the project seriously for about half a year, it feels surprisingly good to be building it again 😅 I’ll post actual numbers once I have something that’s worth benchmarking instead of just architecture diagrams. submitted by /u/zemondza [link] [comments]

I am now reviewing a bunch of papers for AAAI 2027 and it has surprised me the low amount of submissions with no code implementation. I don’t know if it has been only in my batch or it is common, but I was expecting very detailed appendices + code submission since AAAI is very explicit with the topic of reproducibility. I was planning to take this into consideration when assigning my initial scores, but I would like to hear your opinions. I have always submitted my code: it gives a very good impression and after reviewing process finishes we just publish it on ArXiv, so no one “tries to stole the idea” (although I think that this is very very unlikely). So I cannot find any excuse for those submissions that do not have code implementation, specially in today’s times where AI assistants can just write an empirical paper with artificial results within a couple of hours submitted by /u/wontonut [link] [comments]

Lately I've been deep in a personal project by writing chapter summaries of Richard McElreath’s Statistical Rethinking textbook and applying them to wildfire models, and somehow found a way to elegantly (in my opinion) combine the two through storytelling. The tl;dr: I built a whole narrative around a wildfire forensic investigator named Prof. Markov, rolling an eight-sided die to decide which direction to search a burnt forest grid, to explain how the Metropolis-Hastings algorithm (the earliest variant of Markov Chain Monte Carlo (MCMC)) actually works. MCMC sits at the foundation of modern Bayesian computation and probabilistic programming frameworks like PyMC and Stan so it could be genuinely useful to anyone looking to level up in these topics. Roast me, tell me what you liked and didn’t like. Regardless, it was a fun little mini-project! https://pub.towardsai.net/explaining-markov-chain-monte-carlo-using-wildfire-forensics-a334fecaefb3 submitted by /u/vanisle_kahuna [link] [comments]

Hey everyone - we've been building something particularly relevant to ML at large - The Agentic World Cup - a platform where Agents compete in sports. As you know, today's Agents can code, do math, and write - but they aren't nearly as fluent in sports - many of you would know this as the "embodiment gap". Closing the embodiment gap is why we are pursuing this. Sports is both the training and testing ground for true embodied intelligence. Agents will have to actually "think on their feet" to use a colloquial term. In other words, we're pioneering making agents think like athletes, not just nerds. 🙂 How it works: Sign in Select your LLM Coach it (through prompting) Submit it! Your agent will automatically play with other agents, and you will be able to watch it's performance on the site. By Friday, your final rankings come in and be published on the site! Past that though, we also believe that there's a particularly large gap in embodied benchmarking AND a forum for quickly trying out different methods by not just researchers and engineers. Some people are bullish on ViTs, others on onlineRL, and still others on neuro-symbolic systems, etc. So over the long term, we envision anyone be able to quickly test out their latest & greatest insights and algorithms on more publicly facing embodied challenges - which sports is really the apex of. I'd love to hear from the ML community - since this will ultimately be of service to you, so please send us your feedback! submitted by /u/agenticworldcup [link] [comments]

Hello all, I am wondering if a transition from a Ph.D. in electrical engineering (Quantum optics/photonics) to a job in ML is a reasonable aspiration. Personally, I have extensive software development experience competing and winning numerous coding competitions over the years, but most importantly my undergraduate research project was ML based (ML for SiC grating design optimization), I placed third in our universities "Agri-AI" competition which was basically just a big data project for the agriculture department, and I have done several projects in realizing optimal qubit control using ML to bridge the gap between simulation optimization and experimental errors (essentially using an MLP to compensate an unknown system frequency response). I am also generally interested in PINNS and any physical applications of ML. If anyone has made a similar transition I would love to hear how it went for you and what your intended goals were. The more I do projects related to this subject I find myself wanting to make a career out of it more and more. (bonus points if you come from a physics background) 😄 submitted by /u/Plane_Telephone9433 [link] [comments]

I am working on an AI for a small single-player merge puzzle and would appreciate pointers to related algorithms, papers, or existing implementations. It resembles 2048 in its action -> afterstate -> random event structure, but has a larger action space, stack constraints, and a random event that is previewed one move before it is applied. I have an exact simulator. I am not trying to learn the game dynamics from pixels at this stage; the current question is how best to learn values/policies and allocate a limited planning budget. ## Game rules - The board contains 6 vertical stacks, each with a maximum height of 7. The first item in a stack is its top. - An action chooses an ordered pair of different columns: 6 x 5 = 30 possible actions. - The complete contiguous run of equal tiles at the top of the source stack is moved onto the destination stack. An action moves the whole run, not one tile. - If the destination now has at least 3 equal tiles at its top, the complete run merges into one tile of value `n + 1`. Cascades are possible. - A merged 9 disappears and gives one point. Tiles normally present on the board have values 1 through 8. - Merging happens before overflow is checked. The game ends when any stack remains higher than 7. - Every fourth player action is followed by one new random tile being added to every column. - The six upcoming random values are revealed after the third action. The player can therefore choose the fourth action while knowing the exact six tiles that will then be added. - A random tile is in `[1, min(7, highest value merged so far)]`. The real distribution is not yet known. It appears biased toward high values, and human players report runs of "simple" drops (one or two distinct values) alternating with more complex mixed drops. One cycle is therefore: ```text deterministic action 1 deterministic action 2 deterministic action 3 -> reveal a random six-tile preview preview-conditioned action 4 -> apply the known six-tile drop repeat ``` The random preview is the chance event. Applying an already revealed preview is deterministic. ## Objectives There are two related objectives: Maximize the number of 9s in one game. Maximize the total number of 9s in 30 minutes. Death permits a restart, so this is closer to a continuing average-reward/throughput problem than a conventional episodic score problem. The real interface is animation-limited to roughly one player action per second, so 30 minutes is approximately 1,800 actions. Human results in the timed mode are around 115 total 9s on the server I observed. In a separate untimed mode, strong humans can maintain a mature board for 1,000+ 9s, although that mode allows one limited revive. The distinction between cold-start cost and mature-board efficiency seems important. In one of the current AI's best games, the first 9 took 48 actions, while subsequent 9s took 18.7 actions on average. ## Current representation and network The state contains: - a 6 x 7 x 9 one-hot board; - the four-action cycle phase; - the six preview values when known, plus a preview-present flag; - the current random-tile value cap; - the maximum number of empty columns reached in the current cycle and in each of the previous three cycles. The current input has 394 features. The Policy/Value network is column-permutation equivariant: - one shared encoder processes each column; - an ordered source/destination pair head scores the 30 actions; - value heads predict future 9 count over a long horizon, normalized distance to the next 9, and short-term death risk. The history features were motivated by a human rule of thumb: in long games, at least one of the last three drop cycles should have temporarily maintained two empty columns. The history is not required for Markov dynamics under the current IID simulator; it is intended as a strategic summary and may become predictive if real drops have temporal regimes. ## Current planning I use the exact simulator with a stochastic PUCT search. The player action is separated into a deterministic afterstate and an explicit chance node. Current configuration: ```text 128 simulations per real action maximum tree depth: 32 player actions c_puct: 1.5 gamma: 1.0 death-risk penalty: 0.5 maximum 8 fixed chance particles per chance node chance progressive widening exponent: 0.5 minimum 2 visits for every legal root action ``` At the third action, simulations branch over sampled six-tile previews. Below each preview outcome, the tree can choose a different fourth action and applies that preview exactly. After every real action I currently rebuild the tree rather than reusing it. Depth 32 is only a cap. With 30 root actions, 128 simulations, root coverage, and chance branching, most candidates receive only shallow explicit search; the learned Value network estimates most of the long horizon. ## Training process The current process is a form of expert iteration/reanalyse: Generate long games with beam search and then Policy/Value-guided PUCT. Save full episodes, root visit distributions, 9-event positions, death, and optional root action values. Train on column-permutation augmentation. Give extra policy weight to states after the first 9, states containing 7/8 tiles, high-scoring episodes, and states with human-like long-game structure. Generate new PUCT trajectories with the updated network and repeat. I initially used DQN, behavior cloning, demonstration replay, and DAgger-style data aggregation. The Policy/Value + search route has been substantially better for long games. ## Current results These are simulator results under one assumed high-value-biased drop distribution, not results from the real game distribution. - An earlier explicit-chance PUCT model scored 81 total 9s in 16 episodes (mean 5.06, maximum 11, 2,365 actions). - Search distillation later produced a game with 13 total 9s in 272 actions. This remains the single-game maximum. - Adding human-structure weighting improved a small paired evaluation. - Adding the four-cycle empty-column history produced 59 total 9s in 1,675 actions over 12 new episodes, versus 47 in 1,537 actions for its no-history teacher on the same seeds. This is 35.2 versus 30.6 9s per 1,000 actions, but 12 episodes is far too small for a reliable conclusion. - Under the current assumed distribution, even 35.2 per 1,000 actions projects to only about 63 per 1,800 actions, still well below the observed human timed score. I am moving toward paired evaluation on at least 64-128 untouched seeds with bootstrap confidence intervals. I track first-9 cost, subsequent-9 gaps, survival length, per-1,000-action throughput, and fixed-action-budget totals rather than only mean episodic score. ## Things that did not work - A learned action/afterstate Q head achieved low offline MAE but made closed-loop search much worse. Ordinary reanalyse covered too few actions per state, while a full-action root target still suffered from extrapolation/calibration problems. - Jointly fine-tuning the shared encoder for Q degraded the existing policy and value estimates. - Increasing root minimum visits from 2 to 3 reduced performance. - Increasing simulations from 128 to 192 did not improve the paired sample. - Directly adding a handcrafted board-structure score to leaf values changed behavior but reduced overall performance. Using the structure only to weight policy training was better. - Exhaustively maximizing over all preview-conditioned fourth actions at a leaf caused severe maximization bias because the learned Value was not one-step Bellman-consistent. - Restricting search to exactly one four-action cycle had mixed results even after fixing depth-cutoff evaluation. - Repeated policy-only self-distillation quickly saturated. ## Approaches I am considering **2048-style afterstate TD / N-tuple value learning.** The deterministic action followed by a random event seems almost exactly the setting where afterstate TD is useful. I am unsure how best to combine it with the three deterministic actions, the preview chance node, and the preview-conditioned fourth action. **Gumbel MuZero / sequential halving at the root.** With 30 legal actions and only 128 simulations, forcing every root action to receive two visits may waste half the budget. **Persistent tree reuse.** Re-root after each selected action and, when the real preview appears, follow the matching chance outcome or add it if it was not sampled. **Multi-horizon or distributional values.** Predict future 9s over 16/64/256 actions, survival, and perhaps return quantiles instead of one noisy long-horizon mean. **Average-reward training.** Optimize fixed-action-budget throughput including restart/cold-start cost instead of episodic discounted return. **A regime-switching drop model.** Fit an HMM or other conditional sampler if real preview logs confirm alternating simple/complex drop regimes, then condition the policy on recent previews or a distribution belief. **A frozen base network plus residual adapters.** Learn history-dependent corrections to policy/value without damaging the already useful board encoder. ## Questions - Is there an established algorithm or open-source project for a game with this action -> afterstate -> chance -> preview-conditioned action structure? - Would an N-tuple afterstate value network plus expectimax be a better fit than a neural Policy/Value + PUCT system here? - How would you allocate 128 simulations across 30 root actions and stochastic preview outcomes? Is Gumbel sequential halving the obvious next step? - Is tree reuse across deterministic actions and observed chance outcomes likely to matter more than another round of self-play training? - What is a sound way to train an afterstate value without the all-action extrapolation failure I saw with the Q head? - For the 30-minute objective, would you formulate this as an average-reward continuing MDP, a fixed-horizon problem with automatic resets, or something else? - Are there papers on 2048, SameGame, Tetris, stochastic packing/merge puzzles, or inventory-like stack planning that are especially relevant? - Are there standard tests for deciding whether observed random drops are IID or generated by a hidden regime process before building a conditional model? The most relevant work I have found so far is the 2048 N-tuple/afterstate TD literature, Single-Player MCTS for SameGame, Gumbel MuZero, and "Planning in Stochastic Environments with a Learned Model" (Stochastic MuZero). Pointers to stronger baselines, code, or terminology for this problem class would be very helpful. submitted by /u/CaiwenGong [link] [comments]

I recently started working in a data scientist role for the first time, pivoting from mathematical ecology. (It's actually at an environmental organization, so the fit is great.) The job is hybrid, mostly remote. So far, it's been going really well. Last week, they asked me to do a power analysis of a planned study. (Yay!) Of course, this requires a lot of information about measurements, expected values, outliers, what size change would be of interest, etc. I asked the necessary questions on Slack, along with some follow-ups and reminders. They were able to get me much of the information I needed and I found some in the literature, but it felt like I was bugging people (including my boss). Does anyone have communication tips on getting this kind of info from colleagues? submitted by /u/jaiagreen [link] [comments]

Hello, I wanted to share the work my colleague and I have been doing, which has just been published in Software X journal. We developed a Rust-based implementation of Random Forest. It has bindings for both Python and R. Fru is highly optimized, offering competitive runtime performance and better scalability than popular implementations on these platforms. For Python, Fru outperforms the scikit-learn implementation by several factors, and in some scenarios it can be hundreds of times faster. In R, Fru is typically a few dozen percent faster than the ranger package, though the speedup can reach several times faster depending on the use case. The model also includes a novel implementation of permutation importance, which provides an additional performance boost. Thanks to its layered design, we were able to easily create bindings for both Python and R. In Python, we use Arrow PyCapsule, which allows the model to work seamlessly with any compatible library, including pandas, polars, pyarrow, and many others. paper R package Python package submitted by /u/kpiwonski [link] [comments]

Obviously nobody needs a transformer that's good at multiplication. I wanted to know whether a stock transformer could do exact arithmetic if I chose its weights directly. I implemented the grade-school algorithm as a computation graph and compiled it into an ordinary Phi-3 Hugging Face checkpoint using Torchwright, a compiler I wrote. No training. The three-digit calculator gets all 3,000,000 supported expressions right. I've published checkpoints to Hugging Face that support up to 12 digit x 12 digit multiplication. For fun, I also disabled reasoning and tested six frontier models. Accuracy falls off a cliff as the numbers get longer; at seven digits, five scored 0/500. Mine stays at 100%, although it has the considerable advantage that I put the multiplication algorithm directly into its weights. I ended up building four versions: grade-school, hardware-style, scratchpad, and brute-force memorization. They compute the same function while spending layers, width, generated tokens, and parameters very differently. Write-up: https://ood.dev/posts/calculator/ Repo: https://github.com/physicsrob/torchwright Checkpoint: https://huggingface.co/physicsrob/torchwright-calculator-simple-max-digits-3 submitted by /u/notforrob [link] [comments]

Hi, I would like to file a complaint about an accepted and published CVPR 2026 paper that its main contribution is a dataset but it was never released, and honestly I don’t know who to contact. The dataset was never released prior to the conference, or during the conference or after the conference. I personally feel there was a lack of proper checking that the dataset was gonna be available before the conference since this is a requirement. I’ve tried contacting the authors without any success (which tbh I wouldn’t even need to because it has to be released anyways). The authors even point a GitHub link in the paper but the repo is empty (and it was always empty). submitted by /u/ElPelana [link] [comments]

Today the most important factor in AI is cost. My idea is to split ML models inference (closed ones, proprietary) across server and edge computing on clients, and I would like to hear what do you think about this thing. For example some of model weights/modules would be on client, and some on the server side (where user has no access to them). This could potentially un-load some processing from datacenters, moving part of the cost to the client hardware. Probbably the most important question here will be how to achieve this - and I believe one hypothetical option will be to train like two separate models - client model and server model, and they will communicate through tensors/latent representations across network protocol. Secondly such split of server side and client side model ends, can provide later some beneficial outcomes I hope (because in between "talk" protocol can be maybe kind of standarized one in some future development, but this is only more like brainstorm now). Such split might not only be one-to-one, but one-to-many, many-to-many etc. What do you think about this idea? submitted by /u/komorra [link] [comments]

Say you want to swap out your embedding models, for instance from ADA to Titan. Are these embedding models comparable? How do similarity score ranges compare? Where to put a threshold for minimum match when doing retrieval? Or more from a research point of view how can we relate and fundamentally understand these embedding spaces better? This is what we aim to solve with Synthetic Query Probing, a fancy name for essentially (and intentionally) a very simple approach: embedding spaces are not directly comparable by definition, so compare similarity spaces instead, similarity match scores for pairs of content (synthetic question, chunk for instance) across multiple embedding models. For example, similarity scores of Titan models of different dimensionalities are semilinearly related, whereas the relation between Titan and Ada scores is non-linear, with different ranges, see figure. https://preview.redd.it/eauhd4hdyiih1.png?width=4767&format=png&auto=webp&s=e424c836c48962928d9505cf747e7cd9fb0b719f See https://arxiv.org/pdf/2608.05857, Marcin Rozmus and Peter van der Putten. Similarity Spaces across Embedding Models with Synthetic Query Probing. Discovery Science 2026, October 5-9, 2026, Mainz, Germany submitted by /u/pppeer [link] [comments]

Welcome to this week's entering & transitioning thread! This thread is for any questions about getting started, studying, or transitioning into the data science field. Topics include: Learning resources (e.g. books, tutorials, videos) Traditional education (e.g. schools, degrees, electives) Alternative education (e.g. online courses, bootcamps) Job search questions (e.g. resumes, applying, career prospects) Elementary questions (e.g. where to start, what next) While you wait for answers from the community, check out the FAQ and Resources pages on our wiki. You can also search for answers in past weekly threads. submitted by /u/AutoModerator [link] [comments]

submitted by /u/katxwoods [link] [comments]

submitted by /u/ImaginaryRea1ity [link] [comments]

Reasoning alone cannot predict the chaotic physical world. Without a sensory and motor interface to reality, non-physical AI will not deliver the scientific and technological breakthroughs we expect. submitted by /u/dontkry4me [link] [comments]

I've been a data analyst since before the recent AI boom. At my previous company, AI use basically meant pasting SQL into ChatGPT and asking it to fix, join or optimize queries. It wasn't connected to our warehouse, so I still had to do everything myself. I've now moved to a much larger company where Claude/Hex are integrated with our warehouse and semantic layer. The difference is insane. I can describe what I need and it finds the right tables/columns, figures out joins, writes and executes the SQL, explores the output, checks nulls/value distributions and helps validate the result. It's incredibly productive, but it has me wondering: Am I deskilling myself? If AI writes my SQL every day, won't my ability to write complex queries from scratch eventually deteriorate? It sometimes feels almost like cheating What does this mean for data careers? If AI can already write SQL, explore schemas, analyze outputs and perform basic data-quality checks, how much of traditional analytics work remains? Should I automate everything with AI? Should analysts be trying to automate as much of their workflow as possible—SQL, analysis, emails, meetings, Jira, documentation, etc.—because people who don't will simply fall behind? submitted by /u/informatica6 [link] [comments]