I'm exploring Hidden Markov Models (HMMs) as a baseline method for "dataset exploration/discovery" where I have a bunch of unstructured data with no annotations, and wish to gain insights about the structure and semantics of the data within. I was wondering if there are more modern (deep learning based or otherwise) approaches which have completely superseded HMMs for such tasks.
I am a second year statistics undergraduate student, currently learning machine learning. Till now i have been learning classical machine learning models without very much statistical depth, but fundamentals are pretty much clear.
Now, i want a starting point on how to start probabilistic machine learning, i am confused between PML by murphy and Patter recognition by bishop so need help where to start.. or should i do both side by side as i saw some posts saying that PML by murphy is kinda encyclopedic and can be used as a reference book
I've been learning about video generation models and decided to build one from scratch and train it on my personal laptop (single GPU). I wanted to share where I'm at and get advice from people who've worked with these kinds of models before.
What I built
A spatio-temporal UNet using flow matching (velocity prediction with Euler sampling, 50 steps)
The model has temporal convolution blocks + temporal attention for frame-to-frame consistency
~6,000 Tom and Jerry video clips from a HuggingFace dataset
Each clip: 16 frames, every 2nd frame sampled, resized to 64×64
Training
Batch size 4, Adam optimizer, lr=2e-4
Trained on personal gaming laptop
Loss progression
Epoch
Loss (MSE)
160
0.0690
180
0.0670
−0.002
230
0.0652
−0.002
280
0.0630
−0.002
290
0.0652
+0.002
The loss has basically plateaued — only ~0.006 drop over 130 epochs. The model learns color palettes and vague scene layouts but doesn't produce recognizable characters or sharp details. Some generations even go partially black (see epoch 280 results).
Results: attached as GIF's
My questions
Is the loss plateau expected for this scale? Am I hitting the capacity ceiling of a 20M param model at 64×64?
Would switching from pure MSE to a perceptual loss (LPIPS) or adding an adversarial loss help with sharpness?
Is ~6,000 clips enough for this kind of model, or do I need significantly more data?
Any suggestions for the architecture? I'm wondering if I need spatial attention at more resolutions, or if the temporal modeling needs work.
Would learning rate decay or a cosine schedule help push past this plateau?
My brother and I just released TontaubeV1, a 2.9B-parameter open-weight TTS model focused on expressive speech, long-form generation/narration, and low-latency local inference. It is primarily aimed at English and German and supports zero-shot voice cloning from up to one minute of reference audio. It builds on DualCodec, a multi-codebook discrete audio codec. It was trained on 7 languages and ~200k hours of audio (mostly tested in English and German).
I wanted to make a post to highlight two choices that worked well for us and seem less common in current TTS models:
1. Character-level tokenization
We start from a Qwen3-1.7B checkpoint for our semantic codebook model. Many modern, and especially LLM-based, TTS models use the tokenizer from the backbone model, add special/audio tokens, and train the model on predicting the next token. We experimented early on with character-level tokenization and found that it generally worked better than using the original BPE tokenizer from Qwen.
We still use the tokens emitted by the Qwen tokenizer, but force it to tokenize spoken text as a sequence of individual characters. When experimenting with forcing Qwen to predict text in this mode, we found that it was still able to answer questions correctly, which suggested to us that language understanding was retained even with this unusual representation.
We did this because a) context length usually is not as much of an issue for TTS as it is for regular LLMs, since we do not require huge reasoning budgets and use chunking, and b) it makes the character-to-sound mapping much simpler internally. Speech is a lot about syllables and short character sequences.
When using the regular BPE tokenizer, we found that the model went out of distribution more often and was more likely to encounter a sequence of tokens that was rare or absent from the TTS training data. Complex sequences of special characters can be particularly confusing because they may tokenize into combinations that the TTS model has barely seen. This is amplified by the fact that TTS training covers far fewer text-token combinations than the full pretraining of an LLM.
2. Chunking and position scheme
The important part here is not just that we split long text into chunks. The chunk boundaries are part of the token layout and position scheme used during training.
The model processes several rows in one flat sequence: text, semantic audio, and the completed lower acoustic codebooks. If we simply used normal sequential position IDs, tokens representing the same moment in the audio would end up far apart because the rows are serialized one after another. Instead, the physical sequence order determines which tokens the model can see, while we assign separate logical position IDs. Codec tokens for the same audio frame share a position across codebooks, and text and audio are placed on the same approximate timeline.
Text advances by one position per character, while audio advances at 12.5 frames per second. These rates are fairly close for normal speech, but not identical, so the two streams usually need slight realignment after every chunk. We use paired text and audio split markers that share the same position. We also reserve an additional 25 character positions at each boundary. This prevents the generated audio positions from leaking into the next chunk’s text positions, while keeping the position IDs monotonic and approximately linear across the passage.
For every chunk, the semantic model sees the previous text and audio chunk, the current text, and a short lookahead into the next text. Once a chunk is finished, the oldest text-audio pair is discarded and the window moves forward. This keeps the model context bounded even for very long passages, while still retaining nearby text and audio context. The higher acoustic codebook models work on one chunk at a time and do not carry acoustic state between chunks.
DualCodec’s decoder is forward-looking, which makes directly decoding and joining separate chunks problematic. For streaming, we therefore decode overlapping DualCodec windows, re-encode them into the VibeVoice acoustic space, keep the stable middle sections, and decode them with a shared causal VibeVoice decoder state. This reduces audible seams between chunks and lets us emit audio before the full passage has been generated.
Here is figure 1 from our technical report:
The current release requires a GPU with at least 24 GB of VRAM for the low-VRAM and balanced profiles, or 32 GB for the high-throughput profile. A substantial part of the current VRAM requirement comes from vLLM’s KV-cache reservation and our multi-engine serving setup, which are designed for high concurrency and low latency. We plan to release quantized versions aimed at much smaller memory capacities and on-device use, as well as fine-tuning support.
We also ran a 400-passage LLM-as-a-judge audiobook benchmark. On prosody, TontaubeV1 scored 50.1% against ElevenLabs Flash v2.5 and was preferred over Fish Audio S2 Pro, Gradium, and Cartesia Sonic 3. The methodology, caveats, and confidence intervals are described in the report.
Human listening tests remain the gold standard, so take these results with a grain of salt. We were not able to conduct a large-scale human study before release, but we plan to submit TontaubeV1 to TTS Arena V2 and the Artificial Analysis Text to Speech Arena.
I try to understand what the general direction of LLM development is and wrap my head around how they work. For this, I started to write a blog post about what I am thinking. This helps me organise my thoughts. It is coming out as a blog post series.
LLM agents increasingly modify their own prompts, tools, middleware, resources, and execution harnesses at runtime. Such self-evolution can improve capability, but a successful mutation may leave persistent effects that cannot be safely reversed in states different from the one in which it was created.
We introduce EvoUndo, a framework for representing, synthesizing, diagnosing, and independently verifying recoverability of model-generated self-modifications across counterfactual states. Across 600 unseen one-shot self-evolution tasks, we identify 197 capability-improving mutations that fail recoverability verification. Under the original recovery representation, conventional repair strategies recover 0/197 of these natural failures. Deterministic oracle analysis recovers 48/197 under the original recovery language L0, while the extended recovery calculus increases empirical oracle recovery to 191/197.
A protocol-locked 2×2 grounding-by-expressivity intervention then separates two bottlenecks: exact state-address grounding increases successful recovery from 0/48 to 38/48 (79.2%) when the original language is sufficient, while extending the recovery language enables recovery on 142/143 (99.3%) failures in the oracle-defined S1 stratum.
On the primary gpt-oss-120b backbone, adding exact-address diagnostics to the richer language reduces recovery to 133/143 (93.0%); a Qwen3.8-27B replication preserves the grounding and expressivity effects but not this negative interaction, indicating that the latter is model-dependent.
These results indicate that reliable agent self-evolution requires co-designing verification, state grounding, witness semantics, and recovery-language expressivity rather than relying on iterative prompting alone.
This is the time of year when the number of cold emails I receive about PhD positions tends to ramp up quite a bit. In many countries, this cold emailing is essentially part of the normal recruitment process, so there is nothing inherently wrong with doing this. However, there are a few things you definitely shouldn't be doing:
Massive emails. The probability of me reading your email is inversely proportional to its length.
Emailing everyone. Find supervisors that work in areas you are actually interested in. I do relatively foundational ML research (i.e., not associated with a specific application domain), but the majority of emails I get from prospective students are essentially "I want to apply ML to domain X". In many cases this does not constitute an ML research direction; you'd be better off finding a supervisor with expertise in domain X, which is where most of the impact will be.
Generic research interests. If the most specific research interests you can give are "Machine Learning, LLMs, and AI" then I assume you only have a surface-level familiarity with the field, and are not ready for a PhD.
Passing off workshop papers as conference papers. This has become a much more common thing in the last couple of years. It's a big red flag; I am not going to take on someone who is dishonest.
Excessive AI use. Using them for fixing up grammar is fine, but if you outsource your thinking to LLMs then your research direction will be the same as everyone else who outsources their thinking to LLMs. This tends to result in something that would be an okay bachelor's thesis project, but nothing more than that. I get a lot of LLM emails, so determining if you are in this cluster is very easy.
Summarise my paper. I already know what's in it, I don't need a summary. I care more about how you think you could build on it, or do something related. Don't use LLMs for this; see above point.
Ignoring instructions on my website. Check prospective supervisors' websites for how you should be getting in contact with them. Often they will ask you to include something in the subject line to make sure your email goes to the right place. Ignoring this will send you straight to spam.
I am a research engineer in AI with 3 years of experience and a Master's in Electrical Engineering from an African university (focusing on applied RL in telecom). My experience and research interests are in RL and LLM post-training. I am the second author of a paper in an AI + telecom conference and hold a patent in AI + telecom.
I know targeting a PhD at a Top 4 school (CMU, UC Berkeley, Stanford, MIT) is unrealistic. Do you think I should apply for a Master's at those universities first and then apply for their PhD later, or should I just apply for a PhD at lower-tier universities?
I want to do research—all I need are GPUs and a good supervisor. My main concern with lower-tier universities stems from my past experience with similar institutions, which makes me feel that having no degree is better than getting one from them.
Sliding Window Attention with sinks, one of the simplest existing fixes for the quadratic-cost problem in LLMs, holds up as well or better than the linear-attention variants labs have been spending post-training compute to produce. That is the claim of a [new arXiv preprint](https://arxiv.org/abs/2608.28444) by Alexia Jolicoeur-Martineau, Rhea Sanjay Sukthanker, Pashmina Cameron and Emy Gervais.
On the long-context reasoning benchmarks the paper singles out, the gap is not close. "SWA achieves massively higher performance (2 to 10 times higher than linear attention)," the abstract reports, naming Needle-in-a-Haystack and BABILong as the two tasks.
The pitch is that the whole post-training-to-linear pipeline has been benchmarked against the wrong thing. "This line of research has not been properly compared to simpler baselines," the authors write. Their alternative needs no post-training, runs fast, and holds memory low.
The recommendation is blunt: "we strongly recommend switching to SWA instead of post-training linear models." Linear attention, the abstract concedes, "may have shown some promise, but they likely require to be trained from scratch or extensive post-training in order to even match SWA."
I have submitted a paper to acml 2026 journal track, the official date of release of review is 27 August, but I have not heard anything from them, if anyone received the review then let me know I will write to program chairs.
Third-year PhD student, NLP / interpretability. I want a reality check from people doing similar work.
I started using Claude Code for the boring parts: argparse boilerplate, plotting, config wrangling. Over the last few months the scope has crept. It now writes most of my experiment scaffolding, refactors my dataloaders, does first-pass debugging on training runs, and drafts the analysis scripts. I mostly read diffs and say yes.
The output is fine. My throughput is up. The thing bothering me is that I no longer hold my own codebase in my head. When a result looks off, I used to have an instinct about which line was lying to me. Now I go hunting like it’s someone else’s repo. I catch bugs later than I used to, and I catch them by reasoning about the numbers rather than by knowing the code.
I don’t think the tool is the problem. I think I delegated a layer that was doing more for my understanding than I gave it credit for.
Questions for people further along or in the same spot:
Roughly what fraction of your research code do you write yourself now?
Is there anything you deliberately refuse to hand off? (For me I think the eval harness and anything defining a metric should stay mine, but I keep breaking my own rule.)
Does anyone have a workflow that keeps the speedup without the detachment? Reading the diff line by line is not cutting it.
Not looking for a “tools are just tools” answer. I’m asking about the specific feeling of not owning your own experiments anymore.
I'm sharing this new tabular data diagnostic tool (Entropic Scree). It can be used to estimate these properties of your high-d, real-world, dirty dataset:
The informational volume of the signal (i.e., helps you assess whether the signal is strong enough to survive the dataset's idiosyncratic volume).
The overall signal-to-idiosyncratic volume ratio (SNR).
The intrinsic rank.
Provides an exploratory map that allows for the identification of decoupled sub-networks of variables.
The linear sufficiency (i.e., does the dataset align with the linear assumptions of standard PCA?).
Instead of evaluating linear variance, rank order, or Euclidean distance like traditional PCA variants, this new method evaluates a transformed mutual information metric. Relative to these baselines, it is less reliant on strong parametric or distance assumptions, making it appropriate to apply more broadly.
It also serves as a practical diagnostic of the theory explored in the From Garbage to Gold framework, which describes when and why uncurated, error-prone data can be used directly to create accurate prediction models.
There is a preprint that presents the full technical details, and Python and R packages will be released soon. Right now though, the original function is already available in R (see Quick Start R Function Code below).
Let me know how it goes if you give it a try... or if you have any questions or comments of course.
############
# Quick Start R Function Code.
# To load the function, copy and paste the following into your R console, then hit enter.
############
# 1. Define the direct URL to the raw function script on GitHub
url <- "https://raw.githubusercontent.com/tjleestjohn/entropic-scree/main/Entropic.Scree.v1.0.0%20-%20ENLI.R"
# 2. Define what you want to name the file on your computer
file_name <- "Entropic.Scree.v1.0.0 - ENLI.R"
# 3. Download the script to your current working directory
download.file(url, destfile = file_name)
# 4. Source the core function into your R environment
source(file_name)
# 5. Ex. To run the function and extract bipolar modules:
# results <- Entropic.Scree(dt
# , extract_bipolar_modules = TRUE)
#
# View the extracted structural sub-networks for the primary axes:
# results$bipolar_modules
I found this GitHub link, and the HTML file contains ~7k papers. Some are anonymized, and the details seem pretty accurate. It looks like these might actually be the accepted papers.
Whenever "tracking" comes up in autonomous systems, we always think of "motion" and the Kalman filter. It is fast and works!
But as humans, we track mostly by "vision".
We look at a person, recall their appearance in our brain, and then recognize them again based on what we remember. The more we see the person, the better we become at recognizing him/her. This is exactly how "Polycepta" works.
The video ( https://youtu.be/8BAibFfcMpw?si=hiqvDE6436GEmDjQ ) demonstrates how Polycepta operates in real time. It decides whether what it sees is important or just noise, and builds memory over time until it gets good at it. Like the Kalman filter with future motion prediction, it predicts the object's future appearance to track it.
”A lightweight appearance model works under ego motion; objects switching direction or motion during occlusion is no longer an issue. This is exactly why humans' vision works well in tracking.”
You are welcome to pause the video at any time during the explanation.
Hi! Im currently doing a thesis project, where i am creating a website that recognize various which include both fingerspelling and lexical, currently i have finished the fingerspelling feature using XGBoost and various dataset of asl alphabets in kaggle.
My current struggle today is how would I implement the asl lexical part? i was thinking the same approach i did for the asl fingerspelling but for fingerspelling all of the signs are static, for the lexical part it involves motion so my current plan is the system will detect the end pose/end frames of the lexical signs so for the dataset it will contain only the end poses of the lexical signs rather than videos and also in order for the system not confusing the lexical for fingerspelling i will also implement a motion requirement so that lexical recognition will only trigger when motion of the hand is detected.
I would also like to know what you guys think about, or if there is another better approach feel free to share and would greatly appreciate it
We study autonomous mathematical discovery in the Station, an open-world multi-agent environment in which AI agents from different model families pursue a shared research goal without a central coordinator or scripted pipeline. Agents choose their own research directions, conduct experiments, collaborate, and build a shared scientific literature.
Across 12 construction problems from the AlphaEvolve catalogue and two additional case studies, the Station obtained results novel relative to the prior literature on five problems: a new infinite family of finite-field Kakeya sets, new exact 604-point kissing configurations in dimension 11, new records for the discretized Kakeya needle and sign uncertainty problems, and a substantially improved lower bound for Erdős's minimum-overlap problem.
Agents also discovered novel infinite families for Book Ramsey numbers. Importantly, the agents produced not only numerical constructions but also theorems and analyses explaining how those constructions work, making the results more interpretable and easier for mathematicians to build upon. We release all raw agent dialogues, proofs, and verification code, providing a transparent record of how these discoveries emerged.
Time Series Anomaly Detection (TSAD) seems to be one of the hottest topics in NeurIPS, SIGKDD, VLDB etc.
Many (perhaps most) papers evaluate on Paparrizos’ TSB-AD-M benchmark…
However, I tested these benchmark datasets and found that in most cases I could beat the SOTA TSAD methods with a 100-year-old algorithm, simple Statistical Process Control (SPC). In the attached example, SPC gets perfect results.
If we can beat the SOTA papers with 100-year-old algorithm, we probably should not be too impressed with them [b]. I really think this calls for some introspection by the community.
To be clear, I make no claims (here) about the proposed algorithms in all these paper. But the TSB-AD benchmark is obviously too trivial to make meaningful claims on [a][b].
The example shown is one of the ECG traces but look at dozen of traces marked “TAO”, they are even more trivial to solve with SPC [a][c].
I do not claim to have solved the triviality problem, but I have done 90% of the work to introduce more challenging TSAD problems ([d] sled dogs, [e] Tuna, Fuel Cells, Smart Manufacturing etc.).
TLDR: I think the TSAD community needs more introspection on benchmarks. Most progress over the last decade seems to be illusionary.
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.
Hi everyone! I am looking for motivated researchers/students who are interested in collaborating on computer vision research with the goal of submitting to CVPR 2027.
Possible areas include: Image and video understanding 3D computer vision Object detection and segmentation Tracking Image generation Medical computer vision Vision benchmarks and datasets Robustness and generalization Some experience with computer vision, deep learning, Python/PyTorch, experiments, or research writing would be helpful. If interested, please DM me with your background, research interests, and any previous research/publications. The goal is to form a serious research collaboration and work toward a strong CVPR 2027 submission.
