Who wants to crowdsource LLM scans of articles submitted to Lobste.rs?
Like many of us who value the human side of the web, I am looking for ways to keep slop at bay. It seems like LLM detection technology works reasonably well nowadays, with Pangram as the main provider. It is expensive, though!
Assuming pangram scans are trustworthy, and it seems they are, we could create a centralized index of pangram scans of articles. I have already set up a prototype where I publish results of my own pangram scans. I could create more users, each tied to its own API key, so others can contribute with scans as well. This is way more resource efficient than everyone running their own scans.
What do you think?
Update: since this is receiving quite some attention, let me clarify one thing. I'm not proposing to change Lobste.rs itself. I'm wondering if there are enough people who'd like to join forces to maintain an independent index of pangram scans, for our own use, not intending to impose it on anyone (e.g., maybe we could have a browser extension that automatically shows the scan results for articles when browsing Lobste.rs or the orange site).
Locally trained VLA model with minimal attention based vision encoder. [p]
| Hi y’all. Thought Id share the progress on my current local VLA agent project! using agent and language somewhat loosely here. Technically it is an agent, and technically it does adhere to text prompts. However very minimally. Video Link: https://www.reddit.com/r/learnmachinelearning/comments/1xq23zi/local_rnn_style_vla_model_project/ Video Description: The leftmost display shows what the models sees, The yellow triangle marker on screen shows which shape is NOT the target shape on that run (counter intuitive, I know). Importantly, the model does not see it, it is only to make it easier to see if the model is performing correctly. The upper right display shows the models visual attention, in which I discuss later. And the bottom right is the per step state matrix cell values. A small 128x128 view of the whole 768x768 matrix. Preamble: Recently, I have been extremely fascinated by machine learning and AI, for obvious reasons. Originally, I was intrigued by LLMs, that is, until I learnt how they work (RNN gang stand up), their dis-continuity to me isn’t as elegant as the carried state in RNNs (this is my opinion, in which I don’t really have any objective reasoning for). And what better way to lean than to do? Architecture: So I thought why not just make the recurrent state massive? What I have here is an attention based neural network that maintains a 768x768 matrix, with a per cell LSTM like gate. Similarish to a state space model if you will. However, 12,976,128 of those parameters are dedicated to a legacy 49k vocabulary output decoder. Originally, this started in language modelling, but it didn’t work very well. It got to a CE loss of around 4.5 on a reasonably diverse data set across an 80 token rollout average, having seen 80 tokens of context first. This was trained for about ~150k steps with a batch count of 8 across 160 total tokens per episode. So about 200m total tokens seen. Perhaps not enough for how diverse the data set was (600m total tokens across wiki articles, science papers, online text forums, etc), but the loss seemed to indicate a long lasting plateau, decreasing only around 0.05 to 0.1 nats across the last 50k steps. Side note: around 10% of the total training data was from 4chan (don’t hate), and must have all been collected from a very political board, specially around the 2016 us elections. The model was very much not PC lmao. But atleast now I know where NOT to collect “quality” data from… The shown model is a continuation from the a legacy language checkpoint that was transitioned into VLA orientated tasks. My thinking was that having a basic understanding of language might help if the task involved text. However I did no comparison against a fresh checkpoint at the Vision/action switch over to compare bootstrapping speed, so I guess we’ll never know. And the model no longer retains any text output ability. When queried through the legacy text input, it defaults to repeating a single token or two indefinitely. The model processes vision through learned, state-directed attention across raw pixel RGB values at a 128x128 resolution, without a separate pretrained vision encoder. Any visual recognition and spatial understanding is learned within the same recurrent architecture that produces the action outputs. I did try doing the pretrained CNN route, however because compute is heavily restricted in my case (I got that 12gb 3060 on me), and I don’t like spending money renting gpus, I count afford to locally train the model at any resonable speed with the added separate vision encoder. The attention based vision used here added very little extra compute, and seems to work well enough. An interesting side effect of this vision encoder is that the relative, per pixel attention values can be easily displayed (the top right display from the video), which proved useful for trouble shooting training. It can accept variable resolution sizes on inference without requiring pretraining. Although, it can usually only accept larger than the trained 128x128, as any smaller looses what little detail there already is. Training: The target task took inspiration from the Leaning to Reinforcement Learn (2016) paper. Rather than training the model to memorise fixed object identities, the objective is to develop a “general” ability to recognise and associate unfamiliar visual patterns with arbitrary names during inference, without updating its learned parameters. Importantly, the model received ZERO proprioception, only visual and text inputs. The model is introduced to 2 randomly generated shapes ranging from a minimum of 3 cubes to a max of 10. There is, however, a minimum separation between the 2 shape cube counts on any 3 room task, set at around 5 The other 2 room and 1 room environments have no such minimum separation value. Each of the shapes are randomly assigned a name from a pool of 5 names (Dax, Mip, Kiv, Fep and Tav). The introduction lasts 3 steps per shape, as it is directly tied to the text introduction, which is always “this is [shape name]”. After introduction, the model then spawns into a simple 3d enviroment, and given the command “Go to [shape name]” with some random variance in how the command is said. Initially, the model needed a the chronological order of the shape introduced before it was able to make the name to shape distinction, for example; “go to the first seen shape, [shape name]”. The 3D environment in the 2 and 3 room episodes are randomly generated with a doorway/s connecting the rooms at random point. Although the possable range in which they occupy is small, and in 3 room environments, the 2 attaching rooms are always on opposing sides of the spawn room. The wall colour and texture have remained fixed throughout all of VLA training, and the model performs noticeable worse on inference if the wall texture or colour is changes without pretraining. Even though the training enviroment logic was inspired by the L2RL paper, kinda ironically, this model is not trained through RL. Instead I had to create increasingly convoluted trainers that match the complexity of the current curriculum. The training policy is technically imitation learning, however The trainer uses supervised action targets generated from the environment's observed state. For ambiguous decisions, such as choosing between doorways, some earlier losses are retrospectively adjusted according to the path the model actually took. Each episode, the models state is split in to two different trajectories just after introduction, with each one requesting a different shape, then combining the gradients from both. I stuck with SL mostly because of compute limitations. Though RL, which I did try at the end, could only get at most one 4 branch run at a max rollout length of ~80 steps before I ran out of VRAM. Vs the batch 4 160 rollout length I was able to get through SL, which proved to be painfully slow, especially when i hadn’t optimised the reward signal/s yet meaning it would be like a 2 or 3 day wait just to find out that the step penalty was slightly t |
I merged attention and MLP processing into a single gated Transformer block. GAP [R]
Hi everyone!
I've been experimenting with an alternative Transformer architecture called GAP (Gated Attention Projection).
The main idea is to combine attention and MLP-style processing into a single gated block, instead of using the standard separate attention and feed-forward sublayers.
I tested it against a standard Transformer using 100 million scored training tokens per model from WikiText-103.
Some results:
GAP20 used 19.91% fewer parameters than the standard Transformer.
A smaller configuration can reduce parameters by 34.31%, although that version did not fair as well as the current model against the regular transformer, so i ended up giving 14% of my perameters savings to the GAP model for extra width, leaving the model at about 20% fewer perameters, which is why i called it in testing GAP20
The standard Transformer performed better on final language-model accuracy.
Compiling GAP20 with torch.compile improved training throughput by approximately 19.9% in one CPU benchmark compared with running GAP20 without compilation.
I've included the architecture code, configurable model sizes, speed benchmark and research paper.
This is an experimental architecture, not a claim that it outperforms Transformers overall. I'd be interested in feedback on the design, mathematics and possible improvements.
GitHub:
[link] [comments]
Model-Agnostic FDR Control via Group Gaussian Mirror and Permutation SHAP
Backdoor Channels Hidden in Latent Space: Extending Cryptographic Undetectability to Modern Neural Networks
Spectrum-Adaptive Generalization Bounds for Trained Deep Transformers
Sparse Network Inference under Imperfect Detection and its Application to Ecological Networks
Optimal In-context Adaptivity and Distributional Robustness of Transformers
Intention Driven Identification of In-Possession Match Phases in Association Football through Temporal Graph Learning
Tyche: One Step Flow for Efficient Probabilistic Weather Forecasting
Distinct mechanisms underlying in-context learning in transformers
Revisiting the Generic Transformer: Deconstructing a Strong Baseline for Time Series Foundation Models
What Does a Sparse Autoencoder Feature Do? A Weight-Based Account
Concordance-Optimal Continuous Music Emotion Estimation: Variance Decomposition, Dual-Branch Temporal Fusion, and Conformal Prediction Intervals
Enabling Retraining-Free Accurate Inference in Analog Compute in Memory Accelerators
Just CaloCHILL: fast hadronic shower generation in a learned latent space
Fifty-Two Shades of Pig: What the UCR Archive Really Asks Classifiers to Do