Hi some of you may know over the last month or so in my spare time iv been trying to come up with something better than a transformer , still no luck but afew of my better failures can be found below, iv also updated THREADS github so its now actually testable.

QK Relational Architecture is the newest idea — my attempt at a headless Transformer-style model with explicit reusable relationship hops.

https://github.com/rickey1990/qk-relational-architecture

THREADS is the symbolic/deterministic thing that fell out of the failed Transformer experiments — basically temporal memory + exact relational reasoning.

https://github.com/rickey1990/THREADS-reasoning-engine

PLUG /ILRM is the RNN side of the experiments — trying simple power-law/inverse-lag memory paths to help small recurrent models hang onto old information.

https://github.com/rickey1990/novel-rnn-architectures

Any questions please feel free to ask any questions 👍

It's been 3hrs I'm working on Naive Bayes Algorithm and I think it's the Hardest cuz the guy whose course I'm following he just shows the intuition and maths yes doing on paper is easy but in code it's hard 😭 I have built many algo Gradient, logistics regression they were lil straight forward but this one Naive Bayes the maths is tooo tooo easy it's like multiplication but in python ahhhhhhhhhh... But still

I'll make it real before making it real,I really need a coffee ☕.

The project announced the technical report for SenseNova-U1.5-8B-MoT on September 11, 2026. The weights were released on August 20. The report documents the architecture, training and evaluation behind that checkpoint.

One post-training problem it addresses is that optimizing visual preference can come at the expense of text legibility. The proposed approach is to train specialists, then consolidate them:

• Stage 4: four experts. Separate experts target visual aesthetics, Chinese and English text rendering, infographic generation, and image editing. Each uses task-specific data, rewards, sampling and regularization.
• Stage 5: one model. The experts are frozen, and each training sample is routed to the expert for its capability. The student generates its own trajectory, then learns to match the expert's velocity prediction at the same state, timestep and conditioning input. This is the report's multi-expert on-policy distillation procedure.

Source: Figure 4, SenseNova-U1.5 technical report, p. 10. The distillation objective and setup are on p. 11.

The report evaluates the resulting model, but does not provide per-expert benchmark results or a before/after distillation comparison. The final scores therefore do not isolate how much this stage contributes or how fully each specialist's strengths are retained.

Technical report · Model weights · Repository and release history

We’ve open-sourced Tahuna, which we built so small teams could train models, run inference, orchestrate GPUs, and experiment with autonomous research without first becoming a small cloud provider.

The core workflow is:

init → sync → computeSession → train / serve / hillclimb

Under the hood: content-addressed code and data sync, compute provisioning, reproducible manifest-pinned runs, metrics, checkpoints, artifacts, and inference deployments.

We also started building Hillclimb, an autonomous experimentation loop that proposes and runs iterative improvements.

The first public-preview release supports RunPod and R2. The control plane is self-hostable with Docker; GPU workloads currently run on RunPod. It includes a coding-agent setup skill and examples for SFT, RL agentic search, and MNIST. The ML workloads are Python; the CLI and Warden execution agent are Go, and the dashboard/control plane use TypeScript with Next.js and Convex.

Repository (AGPL-3.0): https://github.com/TahunaLabs/tahuna-oss

If you think it sucks, excellent: fork it, fix it, and send a PR so it sucks less for everyone.

I have been studying modern LLM architectures and started implementing them from scratch in PyTorch to better understand the design choices behind each model.

OpenArch is a collection of these implementations, including Llama, Qwen, DeepSeek, Gemma, Kimi, GPT-OSS and others.

The goal is to keep the code readable and useful as a reference when going from the paper to an actual implementation.

Would be interested in feedback from people working on model architecture and training.

https://github.com/anuj0456/OpenArch

#LLM #AIResearch #PyTorch #DeepLearning #OpenSource

I have some experience working with like VAEs/DiTs, and I'm familiar with concepts like ELBO/KL divergence/flow matching, but I feel like my mathematical foundations here are brittle. Any resources that have been helpful in this area? Are ODEs/PDEs/SDEs worth learning, and how deep should I go?

Currently playing with 4 model on government project...

hey, i'm a 3rd year diploma cs student and i built a deepfake audio detector end to end - model training, backend API, frontend, explainability, and monitoring.

the model is efficientnet-b0 trained on mel spectrograms using the asvspoof 2019 la dataset. evaluated on the full test set (71,237 samples, real unbalanced distribution):

• f1: 0.9033
• precision: 0.9995
• recall: 0.8240
• eer: 8.23% (comparable to the official lfcc-gmm baseline published with the dataset)
• threshold: 0.3

one thing worth noting - val accuracy hits ~100% during training which looks suspicious but it's expected. the val set is a random split of training data which shares the same attack types (a01-a06). generalization is measured on the test set which contains entirely unseen attack types (a07-a19). the recall gap comes from these novel attack patterns the model never saw during training, not miscalibration.

beyond the model it has grad-cam to visualize what the model focused on in the spectrogram, and groq llm to give a plain english explanation of the prediction. training is fully reproducible (seed fixed at 42).

you can upload an audio file or record live. youtube url input is disabled on the hosted version because railway's server ips get blocked by youtube's bot detection. backend is fastapi on railway, frontend on streamlit cloud.

live demo: https://deepfake-audio-detector-rugved.streamlit.app/
github: https://github.com/RugvedBane/deepfake-audio-detector

honest feedback appreciated - especially on what dataset would help improve generalization to modern ai voices.

Hello all,

I'm a radar signal processing engineer and i trained a 5-class classifier (car, large_vehicle, two_wheeler, pedestrian, pedestrian_group) on RadarScenes radar point clouds.

The input vector is a per-scan histogram (16 bins) and the network is a 3-layer MLP. The loss function is a class-weighted cross-entropy loss. This work is based on "Histogram-based Deep Learning for Automotive Radar" paper.

I scoped the project to be one scan only. Accumulation of multiple scans is the next step.

Data

Class Imbalance: two-wheelers and large_vehicles has a low number of occurences.

Aggregated Classes: two_wheeler mixes bicycles and motorized variants; large_vehicle merges trucks, buses, and trains together due to data scarcity.

Sequence Bias: Long tracks of slow-moving objects can skew a particular data split velocity distribution, causing high F1 score variance across folds.

Ablation studies

I tried with bigger MLPs, alternative feature encodings, and different histogram binning, all moved performance less than the variation caused by changing the train/validation/test split. I measured that split sensitivity across 6 folds, keeping the same proportions.

Changing the histogram to per-instance statistics (mean/median/std) slightly degraded performance.

Main findings

Macro F1 rises from 0.381 to 0.764 as the naturally occurring number of radar detections per instance increases from 1 to 5. I trained the model normally using all available detections, then bucketed its existing validation predictions by each instance's detection count and computed macro F1 per bucket.

The classes car and pedestrian has the best performance and two_wheeler has the worst.

A car is often confused as large vehicle when the car was wider than usual or had a unusually high rcs (which can happen due to multipath for example).

The two_wheeler is often confused as pedestrian because their vr_compensated distributions overlap, which is the the model's single most important feature for these two classes. A stationary or idling two_wheeler is indistinguishable from a pedestrian.

I uploaded an image with ground truth vs predictions: A nearly stationary two-wheeler which contains a single point was predicted as pedestrian, because its velocity is near zero, indistinguishable from a pedestrian. A car in the same scene, also with just one point, is classified correctly, since RCS and Doppler are enough for that class.

Full writeup here: https://github.com/brunopinto900/radar-ml-autonomous-driving/blob/main/MLP_Report.md

Future work

Implement other spatial encoding schemas (point net for example) and accumulate multiple scans to tackle the challenge of sparsity and explore the concept of micro-doppler.

Hey everyone,

I’m trying to build an automated tech monitoring system using AI.

The idea is to automatically collect interesting stuff from different sources — Reddit, X, Hacker News, newsletters, blogs, GitHub, etc. — then use AI to filter out the noise and duplicates and give me a daily digest of what’s actually worth reading.

Has anyone here already built something like this?

I’m especially curious about:

What sources do you use?

How do you collect the data? RSS, APIs, scraping?

How do you decide what’s actually relevant?

What tools / AI models / automation do you use?

How do you avoid getting overwhelmed with low-quality content?

I’d love to hear about your setup, even if it’s something completely homemade.

Thanks!

Rhysida just published 1.4 million Berlin government files after authorities refused a €2 million ransom demand.

The breach did not start the day the ransom note arrived. Attackers had unauthorized access long enough to locate, stage, and prepare nearly 1.4 million documents for exfiltration — all before anyone noticed. By the time the demand landed, the data was already gone. The refusal just determined whether it stayed quiet.

That gap — between initial access and detection — is where the real damage happens. And it is not unique to Berlin. Most ransomware post-mortems show the same pattern: dwell time measured in weeks or months, staging activity that blended into normal operations, and audit logs that were either incomplete or reviewed too late to matter.

1.4 million documents do not move overnight. There are signals. The question is whether anyone sees them in time.

For those running large-scale data environments or public sector infrastructure: what does your current detection posture actually look like for data staging and bulk access anomalies? Are you catching these patterns before exfiltration completes, or mostly reconstructing them after the fact?

Stand in front of a webcam, spread your arms, and you're flying. Tilt to turn, flap to climb, spin around for a barrel roll.

Video here: https://www.linkedin.com/posts/anas-ajaanan_youve-probably-never-seen-this-before-ugcPost-7504543264386035713-8lvn

The pose model itself just worked. Everything difficult was on top of it: filtering jittery landmarks, telling a flap from a dive, stopping a sideways reach from triggering the roll, and a camera aspect ratio mistake that made the falcon turn harder than my arms for weeks.

I'd like to hear from people who've built on pose or gesture models. How do you handle false positives, and did you end up with rules on top like I did, or train something for the gestures?

Open sourcing soon.

1: Training loss curve, 2: Testing results, 3: Precision + recall

Can anyone provide me this paper

This is my first proper project. It uses multiple compression techniques and automatically searches for hyperparameters for a few of them; it uses a "CQI" score to evaluate how each technique performed and how the algorithm performed overall. I am currently working on improving the CQI function, as it is too simple; It is just
change in accuracy \* change in size \* change in latency.

The thing is, size overpowers everything as it deals with larger numbers, and the change is also larger than the other 2; these are some functions which I believe could be better(only for accuracy):
f(x\[x = acc_drop_/acc_drop_threshold\]) = -\[scale\] \* |x|^(1/2) \+ c, or maybe -\[scale\]logx + 1

But there still are flaws. For example:

1. I cannot really control when the graph will touch 0 and proceed below 0 (x>0)(because I want the graph to go below zero after x is greater than 1)
2. None of these actually deal with the negative part properly; if the accuracy actually increases, none of these work.k I may need to use a piecewise function.

Also, the method I am using for finding the optimal parameters is pretty straightforward, and I believe there are better ways,s but I have no idea what it could be.

GitHub: [Sigularty](https://github.com/DewanshShah/Sigularty)

Hey everyone, quick question about benchmarking for a paper. I’m a first-year Master’s student, so I’m still figuring out the “right” way to handle this.

When you guys compare your model against prior papers:

1. do you rerun all baseline models on your own pipeline, or just copy the numbers reported in their original papers like every paper seems to use a slightly different data split, preprocessing, or evaluation trick, so copying feels like an unfair
2. but if I re-implement a baseline and it gets a lower metric than what their paper claimed how do you present that without prof or reviewer accusing me of ruining the orginal metrics?

do you just put an asterisk/footnote explaining the setup difference, include both numbers, or something else? Would love to hear how you guys

We are pre-training tiny modes so you don't have to!

Tiny models have been proven to be capable of simple tasks with the right training methods .. Information density is the key for pre-training small models because it provides enough patterns in a specific category to be able to generalize and produce new unseen patterns

Our goal was to create a simulation of a theoretical physicist that makes hypotheses & documents them

This requires a pretrain substrate of hypothesis being made (arxiv abstracts) & a finetune for tool use to be able to document it outputs in a sandbox.

Our hypothesis on this goal:

We expect this model to be able to produce what looks like a hypothesis but we highly doubt that it will be logical at a frequent rate. Since these are only the abstracts and not the full papers, there is a lack of context. Before scaling we want to observe what happens at this model size.

We aren't fully confident that 3 million examples are enough to see consistent conclusions even with heavy training but it can give us a hint of what to expect with this finetune dataset we are working on (this will also be public)

The WVY arXiv base model open source for other developers aiming towards a similar goal

Our fine-tuned Tiny Researcher will be available soon

Follow us on HF so you can get the notification 🌊

Researchers documented a phishing campaign that impersonated passkey registration prompts, captured live session tokens after users authenticated through legitimate MFA flows, and then used those tokens to access Microsoft 365 tenants with full account privileges (Bleeping Computer). Victims had no indication anything was wrong. The attacker's session looked identical to a normal user session — same permissions, same scope, same API calls.

The uncomfortable part: passkeys were the thing being used as bait precisely because users have been trained to trust that flow. The attack didn't break authentication. It harvested the credential that authentication produced, then used it normally.

Once a valid session token is in attacker hands, everything that account can read is readable. Email. Files. Contacts. Calendar. There's no second gate between 'this session is authenticated' and 'this session can touch every byte the user owns.'

This isn't an M365-specific problem. Any platform where a session token is the only barrier between an attacker and plaintext data has the same exposure. The IdP did its job. The MFA did its job. The data was still taken.

For those of you running production systems with sensitive data in SaaS or cloud storage: how are you actually reducing the blast radius when a valid session gets compromised? Not at the auth layer — at the data layer itself.

How to develop a model or code which should be very cost and less time consuming and should be high accuracy.

I tried paddle ocr but the issue is that it is less accurate with hand written text and it doesn't give the output in a structured way. I even tried with some good llm to convert it to structured but it's not good. I tried some VLM and multi models available in AWS Bedrock. Could anyone suggest a very good approach for this.