Skip to content

Product1 publisher3 min readPublished

Apple's SimpleDesign drops the tokenizer stage from protein co-design

Apple researchers report that one end-to-end training run on more than 2 million sequence-and-structure pairs competes with the usual tokenizer-then-generator pipelines.

The Product Desk · Product desk

Photograph accompanying Apple's SimpleDesign drops the tokenizer stage from protein co-design
Photo: 9to5mac.com

What happened

  • Apple researchers published a study detailing SimpleDesign, a model that jointly generates protein sequences and structures in one end-to-end training process instead of two stages.
  • The study reports competitive results across protein co-design, structure generation and sequence generation benchmarks despite the simpler training pipeline.
  • The work follows SimpleFold, published last September, which used flow matching to generate a protein's 3D structure directly from its amino acid sequence.

Compiled by The Product DeskSomething wrong?How this is made

Why it matters

  • cost A team refreshing its training data pays for one run under this recipe and two under the tokenizer-then-generator setup, and the autoencoder checkpoint stops being something an engineer has to version and keep in sync.
  • capability One model trained on mixed corruption levels answers folding, inverse folding and co-design requests, so a group does not have to keep three specialist checkpoints to cover the three question types.
  • decision Anyone maintaining a discrete-token stage in front of a generator now has a published counter-hypothesis to test against their own pipeline, and has to say what the tokens buy beyond feeding the generator.
  • contradiction The simple-architecture-beats-heavy-specialist reading rests on SimpleFold's flow matching, while the SimpleDesign account argues only against multi-stage latent training, so the two should not be treated as one claim.

Somebody on the team owns the tokenizer. Under the usual co-design recipe, that person trains an autoencoder to turn protein structures into discrete tokens, keeps the checkpoint, and reruns it before the generative model sitting on top can be retrained [4]. Apple's paper skips that step and produces amino acid sequences and continuous 3D coordinates from a single end-to-end training process [3].

"We hypothesize that this multi-stage training is not necessary to obtain performant co-design models and thus present SimpleDesign, an effective multi-modal protein design model trained directly in the data space," the researchers wrote [5].

The training set was more than 2 million protein sequence-and-structure pairs, taken primarily from the AFESM dataset, which combines predicted structures from the AlphaFold Database with additional samples [6]. Both halves of every pair were corrupted during training: amino acids hidden behind mask tokens, noise added to the coordinates, with the extent of each varied [7]. A mostly intact sequence beside a heavily corrupted structure gives the model a folding problem, and the reverse gives it inverse folding [8]. Corrupt both partway and it is training for co-design [9].

The change a team can count is retraining runs. The two-stage recipe needs the autoencoder finished before the generator starts [4], so a fresh data cut costs two runs; the SimpleDesign recipe costs one [16]. The single-stage run also carries no token vocabulary, so there is nothing to keep aligned with the data [3].

Apple reports the simpler pipeline held up: competitive results across protein co-design, structure generation and sequence generation benchmarks [10], plausible generated structures, and sequences generally as good as or better than those from most competing multimodal models [11]. The 9to5Mac account puts those outcomes in words and does not include figures or name the models compared [17].

The tidy version of this line of work is that plain Transformers plus flow matching can hold their own against heavier specialist stacks. That version is documented for SimpleFold, published last September, which used a flow-matching model with general-purpose Transformer blocks and avoided some of the more computationally expensive techniques used by protein folding models such as DeepMind's AlphaFold [13][14]. For SimpleDesign, the comparison the researchers draw is with multi-stage latent-space training [5], and 9to5Mac attributes flow matching to the folding paper [18]. Diffusion is what that account contrasts flow matching with as a technique [15].

So this is not reading for a group choosing a production protein design model this quarter [17]. It is for teams running a tokenizer in front of a generator for any paired-modality data, and the useful question is what the discrete tokens do for them. If the tokens exist because the generator was built to consume tokens, that is overhead a single-stage run removes [16]. If downstream tooling indexes, searches or edits those tokens, the extra stage is the price of that tooling, and Apple's paper makes its claim about training [5].

What to watch

  • Benchmark tables and named baselines in the SimpleDesign paper itself. Those tables would put figures on the competitive result 9to5Mac describes in words.
  • Whether Apple publishes weights or code for SimpleDesign, which would let outside teams reproduce the single-stage training run.
  • Any validation of SimpleDesign's designed sequences beyond the co-design, structure and sequence generation benchmarks.
Loading claim ledger
Loading source directory links
Loading share composer
Loading topic controls
Loading related stories