filename
stringlengths 9
127
| text
stringlengths 133
11k
|
|---|---|
2305.13048.pdf | RWKV: Reinventing RNNs for the Transformer Era
Bo Peng1∗Eric Alcaide2,3,4∗Quentin Anthony2,5∗
Alon Albalak2,6Samuel Arcadinho2,7Huanqi Cao8Xin Cheng9Michael Chung10
Matteo Grella11Kranthi Kiran GV12Xuzheng He2Haowen Hou13Przemysław Kazienko14
Jan Koco ´n14Jiaming Kong15Bartłomiej Koptyra14Hayden Lau2Krishna Sri Ipsit Mantri16
Ferdinand Mom17,18Atsushi Saito2,19Xiangru Tang20Bolun Wang27Johan S. Wind21Stanisław Wo´ zniak14
Ruichong Zhang8Zhenyuan Zhang2Qihang Zhao22,23Peng Zhou27Jian Zhu24Rui-Jie Zhu25,26
1RWKV Foundation2EleutherAI3University of Barcelona4Charm Therapeutics5Ohio State University
6University of California, Santa Barbara7Zendesk8Tsinghua University9Peking University
10Storyteller.io11Crisis2412New York University13National University of Singapore
14Wroclaw University of Science and Technology15Databaker Technology Co. Ltd16Purdue University
17Criteo AI Lab18Epita19Nextremer Co. Ltd.20Yale University21University of Oslo
22University of Science and Technology of China23Kuaishou Technology Co. Ltd
24University of British Columbia25University of California, Santa Cruz
26University of Electronic Science and Technology of China27RuoxinTech
Abstract
Transformers have revolutionized almost all
natural language processing (NLP) tasks but
suffer from memory and computational com-
plexity that scales quadratically with sequence
length. In contrast, recurrent neural networks
(RNNs) exhibit linear scaling in memory and
computational requirements but struggle to
match the same performance as Transform-
ers due to limitations in parallelization and
scalability. We propose a novel model ar-
chitecture, Receptance Weighted Key Value
(RWKV), that combines the efficient paral-
lelizable training of Transformers with the effi-
cient inference of RNNs. Our approach lever-
ages a linear attention mechanism and allows
us to formulate the model as either a Trans-
former or an RNN, which parallelizes compu-
tations during training and maintains constant
computational and memory complexity during
inference, leading to the first non-transformer
architecture to be scaled to tens of billions
of parameters. Our experiments reveal that
RWKV performs on par with similarly sized
Transformers, suggesting that future work can
leverage this architecture to create more effi-
cient models. This work presents a signifi-
cant step towards reconciling the trade-offs be-
tween computational efficiency and model per-
formance in sequence processing tasks.1
1 Introduction
Deep learning techniques have made significant
strides in artificial intelligence, playing a pivotal
∗Equal first authorship. Others listed alphabetically.
1Code at: https://github.com/BlinkDL/RWKV-LMrole in various scientific and industrial applica-
tions. These applications often involve complex
sequential data processing tasks that include nat-
ural language understanding, conversational AI,
time-series analysis, and even indirect modalities
that can be reframed as sequences, such as im-
ages and graphs (Brown et al., 2020; Ismail Fawaz
et al., 2019; Wu et al., 2020; Albalak et al., 2022).
Predominant among these techniques are RNNs,
convolutional neural networks (CNNs), and the
Transformer models (Vaswani et al., 2017).
Each of these has distinct drawbacks that restrict
their efficiency in certain scenarios. RNNs suf-
fer from the vanishing gradient problem, making
them difficult to train for long sequences. Addition-
ally, they cannot be parallelized in the time dimen-
sion during training, which restricts their scalability
(Hochreiter, 1998; Le and Zuidema, 2016). CNNs,
on the other hand, are only adept at capturing local
patterns, which limits their capacity to deal with
long-range dependencies, crucial to many sequence
processing tasks (Bai et al., 2018).
Transformer models emerged as a powerful alter-
native due to their ability to handle both local and
long-range dependencies and their capability for
parallelized training (Tay et al., 2022). Recent mod-
els such as GPT-3 (Brown et al., 2020), ChatGPT
(OpenAI, 2022; Koco ´n et al., 2023), GPT-4 (Ope-
nAI, 2023), LLaMA (Touvron et al., 2023), and
Chinchilla (Hoffmann et al., 2022) exemplify the
capability of this architecture, pushing the frontiers
of what’s possible in NLP. Despite these signifi-
cant advancements, the self-attention mechanism
inherent to Transformers poses unique challenges,arXiv:2305.13048v1 [cs.CL] 22 May 2023 |
2023.12.07.570727v1.full.pdf | ProteinGym: Large-Scale Benchmarks for Protein
Design and Fitness Prediction
Pascal Notin†∗
Computer Science,
University of OxfordAaron W. Kollasch†
Systems Biology,
Harvard Medical SchoolDaniel Ritter†
Systems Biology,
Harvard Medical School
Lood van Niekerk†
Systems Biology,
Harvard Medical SchoolSteffanie Paul
Systems Biology,
Harvard Medical SchoolHansen Spinner
Systems Biology,
Harvard Medical School
Nathan Rollins
Seismic TherapeuticAda Shaw
Applied Mathematics,
Harvard UniversityRuben Weitzman
Computer Science,
University of Oxford
Jonathan Frazer
Centre for Genomic Regulation
Universitat Pompeu FabraMafalda Dias
Centre for Genomic Regulation
Universitat Pompeu FabraDinko Franceschi
Systems Biology,
Harvard Medical School
Rose Orenbuch
Systems Biology,
Harvard Medical SchoolYarin Gal
Computer Science,
University of OxfordDebora S. Marks∗
Harvard Medical School
Broad Institute
Abstract
Predicting the effects of mutations in proteins is critical to many applications, from
understanding genetic disease to designing novel proteins that can address our
most pressing challenges in climate, agriculture and healthcare. Despite a surge in
machine learning-based protein models to tackle these questions, an assessment of
their respective benefits is challenging due to the use of distinct, often contrived,
experimental datasets, and the variable performance of models across different
protein families. Addressing these challenges requires scale. To that end we
introduce ProteinGym, a large-scale and holistic set of benchmarks specifically
designed for protein fitness prediction and design. It encompasses both a broad
collection of over 250 standardized deep mutational scanning assays, spanning
millions of mutated sequences, as well as curated clinical datasets providing high-
quality expert annotations about mutation effects. We devise a robust evaluation
framework that combines metrics for both fitness prediction and design, factors
in known limitations of the underlying experimental methods, and covers both
zero-shot and supervised settings. We report the performance of a diverse set
of over 70 high-performing models from various subfields (eg., alignment-based,
inverse folding) into a unified benchmark suite. We open source the corresponding
codebase, datasets, MSAs, structures, model predictions and develop a user-friendly
website that facilitates data access and analysis.
∗Correspondence: pascal.notin@cs.ox.ac.uk, kollasch@g.harvard.edu, danieldritter1@gmail.com,
loodvn@gmail.com, debbie@hms.harvard.edu ; †Equal contribution
37th Conference on Neural Information Processing Systems (NeurIPS 2023) Track on Datasets and Benchmarks.. CC-BY-NC-ND 4.0 International license available under a(which was not certified by peer review) is the author/funder, who has granted bioRxiv a license to display the preprint in perpetuity. It is made The copyright holder for this preprint this version posted December 8, 2023. ; https://doi.org/10.1101/2023.12.07.570727doi: bioRxiv preprint |
1511.06349.pdf | Generating Sentences from a Continuous Space
Samuel R. Bowman∗
NLP Group and Dept. of Linguistics
Stanford University
sbowman@stanford.eduLuke Vilnis∗
CICS
University of Massachusetts Amherst
luke@cs.umass.edu
Oriol Vinyals, Andrew M. Dai, Rafal Jozefowicz & Samy Bengio
Google Brain
{vinyals, adai, rafalj, bengio }@google.com
Abstract
The standard recurrent neural network
language model ( rnnlm ) generates sen-
tences one word at a time and does not
work from an explicit global sentence rep-
resentation. In this work, we introduce
and study an rnn-based variational au-
toencoder generative model that incorpo-
rates distributed latent representations of
entire sentences. This factorization al-
lows it to explicitly model holistic prop-
erties of sentences such as style, topic,
and high-level syntactic features. Samples
from the prior over these sentence repre-
sentations remarkably produce diverse and
well-formed sentences through simple de-
terministic decoding. By examining paths
through this latent space, we are able to
generate coherent novel sentences that in-
terpolate between known sentences. We
present techniques for solving the difficult
learning problem presented by this model,
demonstrate its effectiveness in imputing
missing words, explore many interesting
properties of the model’s latent sentence
space, and present negative results on the
use of the model in language modeling.
1 Introduction
Recurrent neural network language models
(rnnlm s, Mikolov et al., 2011) represent the state
of the art in unsupervised generative modeling
for natural language sentences. In supervised
settings, rnnlm decoders conditioned on task-
specific features are the state of the art in tasks
like machine translation (Sutskever et al., 2014;
Bahdanau et al., 2015) and image captioning
(Vinyals et al., 2015; Mao et al., 2015; Donahue
et al., 2015). The rnnlm generates sentences
word-by-word based on an evolving distributed
state representation, which makes it a proba-
bilistic model with no significant independence
∗First two authors contributed equally. Work was
done when all authors were at Google, Inc.i went to the store to buy some groceries .
i store to buy some groceries .
i were to buy any groceries .
horses are to buy any groceries .
horses are to buy any animal .
horses the favorite any animal .
horses the favorite favorite animal .
horses are my favorite animal .
Table 1: Sentences produced by greedily decoding
from points between two sentence encodings with
a conventional autoencoder. The intermediate sen-
tences are not plausible English.
assumptions, and makes it capable of modeling
complex distributions over sequences, including
those with long-term dependencies. However, by
breaking the model structure down into a series of
next-step predictions, the rnnlm does not expose
an interpretable representation of global features
like topic or of high-level syntactic properties.
We propose an extension of the rnnlm that is
designed to explicitly capture such global features
in a continuous latent variable. Naively, maxi-
mum likelihood learning in such a model presents
an intractable inference problem. Drawing inspi-
ration from recent successes in modeling images
(Gregor et al., 2015), handwriting, and natural
speech (Chung et al., 2015), our model circum-
vents these difficulties using the architecture of a
variational autoencoder and takes advantage of re-
cent advances in variational inference (Kingma and
Welling, 2015; Rezende et al., 2014) that introduce
a practical training technique for powerful neural
network generative models with latent variables.
Our contributions are as follows: We propose a
variational autoencoder architecture for text and
discuss some of the obstacles to training it as well
as our proposed solutions. We find that on a stan-
dard language modeling evaluation where a global
variable is not explicitly needed, this model yields
similar performance to existing rnnlm s. We also
evaluate our model using a larger corpus on the
task of imputing missing words. For this task,
we introduce a novel evaluation strategy using anarXiv:1511.06349v4 [cs.LG] 12 May 2016 |
2402.16819.pdf | Nemotron-4 15B Technical Report
Jupinder Parmar*Shrimai Prabhumoye∗Joseph Jennings∗Mostofa Patwary∗
Sandeep Subramanian†Dan Su Chen Zhu Deepak Narayanan Aastha Jhunjhunwala Ayush
Dattagupta Vibhu Jawa Jiwei Liu Ameya Mahabaleshwarkar Osvald Nitski Annika
Brundyn James Maki Miguel Martinez Jiaxuan You John Kamalu Patrick LeGresley
Denys Fridman Jared Casper Ashwath Aithal Oleksii Kuchaiev Mohammad Shoeybi
Jonathan Cohen Bryan Catanzaro
NVIDIA
Abstract
We introduce Nemotron-4 15B, a 15-billion-parameter large multilingual language model trained
on 8 trillion text tokens. Nemotron-4 15B demonstrates strong performance when assessed on English,
multilingual, and coding tasks: it outperforms all existing similarly-sized open models on 4 out of 7
downstream evaluation areas and achieves competitive performance to the leading open models in the
remaining ones. Specifically, Nemotron-4 15B exhibits the best multilingual capabilities of all similarly-
sized models, even outperforming models over four times larger and those explicitly specialized for
multilingual tasks.
1 Introduction
Recently published efforts (Hoffmann et al., 2022; Touvron et al., 2023a,b; Yang et al., 2023; Jiang et al.,
2023) in language model pre-training have been inspired by Chinchilla scaling laws (Hoffmann et al., 2022),
which argue for scaling data along with model size given a fixed compute budget, compared to past work
that only scaled the size of the model (Kaplan et al., 2020; Brown et al., 2020; Smith et al., 2022; Rae et al.,
2022; Scao et al., 2023). For example, (Hoffmann et al., 2022) shows that given two roughly IsoFLOP
GPT models with a similar data distribution, a 65-billion-parameter model on 1.4 trillion tokens and a 280-
billion-parameter model on 300 billion tokens, the 65B model has better accuracy on downstream tasks.
This trade-off of allocating compute towards training on more data as opposed to increasing model size is
particularly appealing from an inference perspective, reducing latency and the amount of compute needed
to serve models. As a consequence, a major focus of language modeling training efforts has shifted to col-
lecting high-quality multi-trillion token datasets from public sources such as Common Crawl. We continue
this trend by introducing Nemotron-4 15B which was trained on 8 trillion tokens of English, multilingual,
*Equal contribution, corresponding authors: {jupinderp,sprabhumoye,jjennings,mpatwary }@nvidia.com .
†Work done while at NVIDIA.
1arXiv:2402.16819v1 [cs.CL] 26 Feb 2024 |
2203.05482.pdf | Model soups: averaging weights of multiple fine-tuned models
improves accuracy without increasing inference time
Mitchell Wortsman1Gabriel Ilharco1Samir Yitzhak Gadre2Rebecca Roelofs3Raphael Gontijo-Lopes3
Ari S. Morcos4Hongseok Namkoong2Ali Farhadi1Yair Carmon* 5Simon Kornblith* 3Ludwig Schmidt* 1
Abstract
The conventional recipe for maximizing model
accuracy is to (1) train multiple models with var-
ious hyperparameters and (2) pick the individ-
ual model which performs best on a held-out
validation set, discarding the remainder. In this
paper, we revisit the second step of this proce-
dure in the context of fine-tuning large pre-trained
models, where fine-tuned models often appear
to lie in a single low error basin. We show that
averaging the weights of multiple models fine-
tuned with different hyperparameter configura-
tions often improves accuracy and robustness. Un-
like a conventional ensemble, we may average
many models without incurring any additional
inference or memory costs—we call the results
“model soups.” When fine-tuning large pre-trained
models such as CLIP, ALIGN, and a ViT-G pre-
trained on JFT, our soup recipe provides signifi-
cant improvements over the best model in a hy-
perparameter sweep on ImageNet. The result-
ing ViT-G model, which attains 90.94% top-1
accuracy on ImageNet, achieved a new state of
the art. Furthermore, we show that the model
soup approach extends to multiple image clas-
sification and natural language processing tasks,
improves out-of-distribution performance, and im-
proves zero-shot performance on new downstream
tasks. Finally, we analytically relate the perfor-
mance similarity of weight-averaging and logit-
ensembling to flatness of the loss and confidence
of the predictions, and validate this relation em-
pirically. Code is available at https://github.
com/mlfoundations/model-soups .
*Equal contribution1University of Washington2Columbia Uni-
versity3Google Research, Brain Team4Meta AI Research5Tel
Aviv University. Correspondence to: <mitchnw@uw.edu >.
Proceedings of the 39thInternational Conference on Machine
Learning , Baltimore, Maryland, USA, PMLR 162, 2022. Copy-
right 2022 by the author(s).
75 76 77 78 79 80 81
ImageNet Accuracy (top-1, %)3540455055Avg. accuracy on 5 distribution shiftsGreedy Soup
Uniform Soup
Initialization
Various
hyperparametersFigure 1: Model soups improve accuracy over the best individual
model when performing a large, random hyperparameter search
for fine-tuning a CLIP ViT-B/32 model on ImageNet. The uniform
soup (blue circle) averages all fine-tuned models (green diamonds)
in a random hyperparameter search over learning rate, weight-
decay, iterations, data augmentation, mixup, and label smoothing.
The greedy soup adds models sequentially to the model soup,
keeping a model in the soup if accuracy on the held-out validation
set does not decrease.
Method ImageNet acc. Distribution
(top-1, %) shifts
ViT-G (Zhai et al., 2021) 90.45 –
CoAtNet-7 (Dai et al., 2021) 90.88 –
Our models/evaluations based on ViT-G:
ViT-G (reevaluated) 90.47 82.06
Best model in 90.78 84.68
hyperparam search
Greedy soup 90.94 85.02
Table 1: Model soups improve accuracy over the best individual
model when fine-tuning a JFT-3B pre-trained ViT-G/14 model on
ImageNet. Instead of selecting the best model from a hyperparam-
eter sweep during fine-tuning, model soups average the weights
of multiple fine-tuned models. To evaluate performance under
distribution shift we consider average accuracy on ImageNet-V2,
ImageNet-R, ImageNet-Sketch, ObjectNet, and ImageNet-A. Ad-
ditional details are provided by Table 4 and Section 3.3.2, while
analogous results for BASIC (Pham et al., 2021) are in Appendix C.arXiv:2203.05482v3 [cs.LG] 1 Jul 2022 |
noise-contrastive-estimation.pdf | Journalof Machine LearningResearch 13(2012)307-361 Submi tted 12/10;Revised 11/11;Published2/12
Noise-ContrastiveEstimationof UnnormalizedStatistical Models,
with Applications toNatural ImageStatistics
Michael U.Gutmann MICHAEL .GUTMANN @HELSINKI .FI
AapoHyv ¨arinen AAPO.HYVARINEN @HELSINKI .FI
Department of Computer Science
Department of Mathematics and Statistics
Helsinki Institutefor Information Technology HIIT
Universityof Helsinki, Finland
Editor:Yoshua Bengio
Abstract
Weconsiderthetaskofestimating,fromobserveddata,apro babilisticmodelthatisparameterized
by a finite number of parameters. In particular, we are consid ering the situation where the model
probabilitydensityfunctionisunnormalized. Thatis,the modelisonlyspecifieduptothepartition
function. The partition function normalizes a model so that it integrates to one for any choice of
the parameters. However, it is often impossible to obtain it in closed form. Gibbs distributions,
Markov and multi-layer networks are examples of models wher e analytical normalization is often
impossible. Maximum likelihood estimation can then not be u sed without resorting to numerical
approximationswhichareoftencomputationallyexpensive . Weproposehereanewobjectivefunc-
tion for the estimation of both normalized and unnormalized models. The basic idea is to perform
nonlinearlogisticregressiontodiscriminatebetweenthe observeddataandsomeartificiallygener-
ated noise. With this approach, the normalizing partition f unction can be estimated like any other
parameter. We prove that the new estimation method leads to a consistent (convergent) estimator
of the parameters. For large noise sample sizes, the new esti mator is furthermore shown to be-
have like the maximum likelihood estimator. In the estimati on of unnormalized models, there is a
trade-offbetweenstatisticalandcomputationalperforma nce. Weshowthatthenewmethodstrikes
acompetitivetrade-offincomparisontootherestimationm ethodsforunnormalizedmodels. Asan
application to real data, we estimate novel two-layer model s of natural image statistics with spline
nonlinearities.
Keywords: unnormalized models, partition function, computation, es timation, natural image
statistics
1. Introduction
This paper is about parametric density estimation, where the general setup is as follows. A sample
X= (x1,...,xTd)of a random vector x∈Rnis observed which follows an unknown probabil-
ity density function (pdf) pd. The data-pdf pdis modeled by a parameterized family of functions
{pm(.;θ)}θwhere θis a vector of parameters. It is commonly assumed that pdbelongs to this
family. Inotherwords, pd(.) =pm(.;θ⋆)forsomeparameter θ⋆. Theparametricdensityestimation
problemisthenaboutfinding θ⋆fromtheobservedsample X. Anyestimate ˆθmustyieldaproperly
c⃝2012Michael U. GutmannandAapo Hyv ¨arinen. |
1611.03530.pdf | UNDERSTANDING DEEP LEARNING REQUIRES RE -
THINKING GENERALIZATION
Chiyuan Zhang∗
Massachusetts Institute of Technology
chiyuan@mit.eduSamy Bengio
Google Brain
bengio@goog/l.Vare.comMoritz Hardt
Google Brain
mrtz@goog/l.Vare.com
Benjamin Recht†
University of California, Berkeley
brecht@berke/l.Varey.eduOriol Vinyals
Google DeepMind
vinya/l.Vars@goog/l.Vare.com
ABSTRACT
Despite their massive size, successful deep artificial neural networks can exhibit a
remarkably small difference between training and test performance. Conventional
wisdom attributes small generalization error either to properties of the model fam-
ily, or to the regularization techniques used during training.
Through extensive systematic experiments, we show how these traditional ap-
proaches fail to explain why large neural networks generalize well in practice.
Specifically, our experiments establish that state-of-the-art convolutional networks
for image classification trained with stochastic gradient methods easily fit a ran-
dom labeling of the training data. This phenomenon is qualitatively unaffected
by explicit regularization, and occurs even if we replace the true images by com-
pletely unstructured random noise. We corroborate these experimental findings
with a theoretical construction showing that simple depth two neural networks al-
ready have perfect finite sample expressivity as soon as the number of parameters
exceeds the number of data points as it usually does in practice.
We interpret our experimental findings by comparison with traditional models.
1 I NTRODUCTION
Deep artificial neural networks often have far more trainable model parameters than the number of
samples they are trained on. Nonetheless, some of these models exhibit remarkably small gener-
alization error , i.e., difference between “training error” and “test error”. At the same time, it is
certainly easy to come up with natural model architectures that generalize poorly. What is it then
that distinguishes neural networks that generalize well from those that don’t? A satisfying answer
to this question would not only help to make neural networks more interpretable, but it might also
lead to more principled and reliable model architecture design.
To answer such a question, statistical learning theory has proposed a number of different complexity
measures that are capable of controlling generalization error. These include VC dimension (Vapnik,
1998), Rademacher complexity (Bartlett & Mendelson, 2003), and uniform stability (Mukherjee
et al., 2002; Bousquet & Elisseeff, 2002; Poggio et al., 2004). Moreover, when the number of
parameters is large, theory suggests that some form of regularization is needed to ensure small
generalization error. Regularization may also be implicit as is the case with early stopping.
1.1 O UR CONTRIBUTIONS
In this work, we problematize the traditional view of generalization by showing that it is incapable
of distinguishing between different neural networks that have radically different generalization per-
formance.
∗Work performed while interning at Google Brain.
†Work performed at Google Brain.
arXiv:1611.03530v2 [cs.LG] 26 Feb 2017 |
2310.03214.pdf | Preprint
FRESH LLM S:
REFRESHING LARGE LANGUAGE MODELS
WITH SEARCH ENGINE AUGMENTATION
Tu Vu1Mohit Iyyer2Xuezhi Wang1Noah Constant1Jerry Wei1
Jason Wei3∗Chris Tar1Yun-Hsuan Sung1Denny Zhou1Quoc Le1Thang Luong1
Google1University of Massachusetts Amherst2OpenAI3
freshllms@google.com
ABSTRACT
Most large language models ( LLM S) are trained once and never updated; thus,
they lack the ability to dynamically adapt to our ever-changing world. In this
work, we perform a detailed study of the factuality of LLM -generated text in the
context of answering questions that test current world knowledge. Specifically, we
introduce FRESH QA, a novel dynamic QAbenchmark encompassing a diverse range
of question and answer types, including questions that require fast-changing world
knowledge as well as questions with false premises that need to be debunked. We
benchmark a diverse array of both closed and open-source LLM Sunder a two-mode
evaluation procedure that allows us to measure both correctness and hallucination.
Through human evaluations involving more than 50K judgments, we shed light on
limitations of these models and demonstrate significant room for improvement: for
instance, all models (regardless of model size) struggle on questions that involve
fast-changing knowledge and false premises. Motivated by these results, we present
FRESH PROMPT , a simple few-shot prompting method that substantially boosts the
performance of an LLM onFRESH QAby incorporating relevant and up-to-date
information retrieved from a search engine into the prompt. Our experiments
show that FRESH PROMPT outperforms both competing search engine-augmented
prompting methods such as SELF-ASK(Press et al., 2022) as well as commercial
systems such as PERPLEXITY .AI.1Further analysis of FRESH PROMPT reveals that
both the number of retrieved evidences and their order play a key role in influencing
the correctness of LLM -generated answers. Additionally, instructing the LLM
to generate concise and direct answers helps reduce hallucination compared to
encouraging more verbose answers. To facilitate future work, we release FRESH QA
atgithub.com/freshllms/freshqa and commit to updating it at regular intervals.
1 I NTRODUCTION
Recent large language models ( LLM S) such as BARD and CHATGPT/GPT-42are designed to be
versatile open-domain chatbots that can engage in multi-turn conversations on diverse subjects.
Despite their impressive capabilities, these LLM Soften “hallucinate” plausible but factually incorrect
information (Maynez et al., 2020; Liu et al., 2023b), which reduces the trustworthiness of their
responses, especially in settings where accurate and up-to-date information is critical. This behavior
can be partially attributed to the presence of outdated knowledge encoded in their parameters. While
additional training using human feedback (Ouyang et al., 2022) or knowledge-enhanced tasks can
mitigate this issue, it is not easily scalable for real-time knowledge updates (e.g., stock price of a
company). In-context learning (Brown et al., 2020) is an appealing alternative in which real-time
knowledge can be injected into an LLM ’s prompt for conditioning generation. While recent work
has begun to explore augmenting LLM Swith web search results (Lazaridou et al., 2022; Press et al.,
2022), it is unclear how to take full advantage of search engine outputs to increase LLM factuality.
∗Work done while at Google.
1https://www.perplexity.ai
2https://bard.google.com ,https://chat.openai.com
1arXiv:2310.03214v1 [cs.CL] 5 Oct 2023 |
2111.02080v6.pdf | An Explanation of In-context Learning as Implicit
Bayesian Inference
Sang Michael Xie
Stanford University
xie@cs.stanford.eduAditi Raghunathan
Stanford University
aditir@stanford.edu
Percy Liang
Stanford University
pliang@cs.stanford.eduTengyu Ma
Stanford University
tengyuma@cs.stanford.edu
Abstract
Large language models (LMs) such as GPT-3 have the surprising ability to do in-context learning, where
the model learns to do a downstream task simply by conditioning on a prompt consisting of input-output
examples. The LM learns from these examples without being explicitly pretrained to learn . Thus, it is unclear what
enables in-context learning. In this paper, we study how in-context learning can emerge when pretraining
documents have long-range coherence. Here, the LM must infer a latent document-level concept to generate
coherent next tokens during pretraining. At test time, in-context learning occurs when the LM also infers
a shared latent concept between examples in a prompt. We prove when this occurs despite a distribution
mismatch between prompts and pretraining data in a setting where the pretraining distribution is a mixture of
HMMs. In contrast to messy large-scale datasets used to train LMs capable of in-context learning, we generate
a small-scale synthetic dataset (GINC) where Transformers and LSTMs both exhibit in-context learning1.
Beyond the theory, experiments on GINC exhibit large-scale real-world phenomena including improved
in-context performance with model scaling (despite the same pretraining loss), sensitivity to example order,
and instances where zero-shot is better than few-shot in-context learning.
1 Introduction
Large language models (LMs) such as GPT-3 (Brown et al., 2020, Lieber et al., 2021, Radford et al.,
2019, Wang and Komatsuzaki, 2021) are pretrained on massive text corpora to predict the next word
given previous words. They demonstrate the surprising ability to do in-context learning , where an
LM “learns” to do a task simply by conditioning on a prompt containing input-output pairs, achiev-
ing SOTA results on LAMBADA (Paperno et al., 2016) and TriviaQA (Joshi et al., 2017) tasks (18%
and 3% over previous SOTA (Brown et al., 2020)). For example, consider the task of predicting
nationalities from names. A prompt (Figure 1) is constructed by concatenating independent “train-
ing” examples (e.g., “Albert Einstein was German”) followed by a “test example” (“Marie Curie
was”). Conditioning on this prompt, GPT-3 places the largest probability on the correct output
p(“Polish”|“Albert Einstein was German \n Mahatma Gandhi was Indian \n Marie Curie was” )
1The code, data, and experiments are located on GitHub and CodaLab.
1arXiv:2111.02080v6 [cs.CL] 21 Jul 2022 |
2110.04374.pdf | A Few More Examples May Be Worth Billions of Parameters
Yuval Kirstain♠Patrick Lewis†‡Sebastian Riedel†‡Omer Levy♠‡
♠Tel-Aviv University
†University College London
‡Facebook AI Research
{yuval.kirstain,levyomer }@cs.tau.ac.il ,{patrick.lewis,s.riedel }@cs.ucl.ac.uk
Abstract
We investigate the dynamics of increasing the
number of model parameters versus the num-
ber of labeled examples across a wide variety
of tasks. Our exploration reveals that while
scaling parameters consistently yields perfor-
mance improvements, the contribution of addi-
tional examples highly depends on the task’s
format. Specifically, in open question answer-
ing tasks, enlarging the training set does not
improve performance. In contrast, classifica-
tion, extractive question answering, and mul-
tiple choice tasks benefit so much from addi-
tional examples that collecting a few hundred
examples is often “worth” billions of parame-
ters. We hypothesize that unlike open question
answering, which involves recalling specific
information, solving strategies for tasks with
a more restricted output space transfer across
examples, and can therefore be learned with
small amounts of labeled data.1
1 Introduction
Recent work on few-shot learning for natural lan-
guage tasks explores the dynamics of scaling up
either the number of model parameters (Brown
et al., 2020) or labeled examples (Le Scao and
Rush, 2021), while controlling for the other vari-
able by setting it to a constant. For example, Brown
et al. (2020) focus on in-context learning from
roughly 32 to 64 examples, a practice that was
adopted by fine-tuning approaches as well (Schick
and Sch ¨utze, 2021b; Gao et al., 2021b; Tam et al.,
2021); however, there are many practical few-shot
scenarios where hundreds of examples can be col-
lected at a relatively low effort.2Other work experi-
ments with single-size models (Schick and Schutze,
1Our code is publicly available: https://github.
com/yuvalkirstain/lm-evaluation-harness .
2In SQuAD (Rajpurkar et al., 2016), for example, the
average annotation pace is around one minute per question,
producing 480 examples in a single 8-hour workday.
S B L XL
Model Size2048
512
128
32#Examples
4.8 10.3 17.7 26.25.8 9.7 17.4 27.35.8 11.0 18.7 27.55.7 9.6 17.1 25.2TriviaQA (Open)
S B L XL
Model Size2048
512
128
32#Examples
37.2 34.7 39.4 56.440.5 51.1 55.3 73.242.5 49.6 70.5 77.751.1 59.8 78.9 84.8SQuAD 2 (Extractive)Figure 1: Open QA tasks (e.g. TriviaQA) benefit from
additional parameters exclusively, while extractive QA
tasks (e.g. SQuAD 2) benefit from both larger models
and more labeled data.
2020; Ram et al., 2021; Le Scao and Rush, 2021;
Gao et al., 2021b), even though larger (or smaller)
models may exhibit different behavior. Further-
more, much of the literature focuses on classifica-
tion tasks (Schick and Sch ¨utze, 2021a; Gao et al.,
2021b; Le Scao and Rush, 2021), leaving it unclear
whether their conclusions generalize to tasks with
less restricted output spaces.
In this paper, we conduct a systematic explo-
ration of few-shot learning for language tasks,
where we investigate the dynamics of increasing
the number of model parameters (using different
sizes of the self-supervised T5 (Raffel et al., 2020))
versus the number of target-task labeled exam-
ples (from 32 to 2048) across a variety of tasks,
including not only classification, but also extrac-
tive, multiple-choice, and open question answer-
ing. Overall, we evaluate 192 scenarios by training
7,680 models to control for hyperparameters and
random seeds.
Our experiments show that, surprisingly, the con-
tribution of additional parameters versus additional
labeled examples highly depends on the format
of the task. For open QA tasks, such as the open-
domain version of Natural Questions (Kwiatkowski
et al., 2019; Lee et al., 2019), which require the
model to recall specific information seen duringarXiv:2110.04374v1 [cs.CL] 8 Oct 2021 |
10.7554.eLife.50524.001.pdf | *For correspondence:
ronlevy@temple.edu
Competing interests: The
authors declare that no
competing interests exist.
Funding: See page 20
Received: 25 July 2019
Accepted: 09 September 2019
Published: 08 October 2019
Reviewing editor: Patricia J
Wittkopp, University of
Michigan, United States
Copyright Biswas et al. This
article is distributed under the
terms of the Creative Commons
Attribution License, which
permits unrestricted use and
redistribution provided that the
original author and source are
credited.Epistasis and entrenchment of drug
resistance in HIV-1 subtype B
Avik Biswas1,2, Allan Haldane1,2, Eddy Arnold3,4, Ronald M Levy1,2,5*
1Center for Biophysics and Computational Biology, Temple University, Philadelphia,
United States;2Department of Physics, Temple University, Philadelphia, United
States;3Center for Advanced Biotechnology and Medicine, Rutgers University,
Piscataway, United States;4Department of Chemistry and Chemical Biology,
Rutgers University, Piscataway, United States;5Department of Chemistry, Temple
University, Philadelphia, United States
Abstract The development of drug resistance in HIV is the result of primary mutations whose
effects on viral fitness depend on the entire genetic background, a phenomenon called ‘epistasis’.
Based on protein sequences derived from drug-experienced patients in the Stanford HIV database,
we use a co-evolutionary (Potts) Hamiltonian model to provide direct confirmation of epistasis
involving many simultaneous mutations. Building on earlier work, we show that primary mutations
leading to drug resistance can become highly favored (or entrenched) by the complex mutation
patterns arising in response to drug therapy despite being disfavored in the wild-type background,
and provide the first confirmation of entrenchment for all three drug-target proteins: protease,
reverse transcriptase, and integrase; a comparative analysis reveals that NNRTI-induced mutations
behave differently from the others. We further show that the likelihood of resistance mutations can
vary widely in patient populations, and from the population average compared to specific
molecular clones.
DOI: https://doi.org/10.7554/eLife.50524.001
Introduction
HIV mutates rapidly as it jumps from host to host, acquiring resistance to each host’s distinct
immune response and applied drug regimen. Drug-resistance mutations (DRMs) arise when the virus
evolves under selective pressure due to antiretroviral therapy (ART). Primary DRMs often incur a fit-
ness penalty which is then compensated for by accompanying associated mutations ( Heeney et al.,
2006 ;Shafer and Schapiro, 2008 ). With the use of current robust inhibitors in drug therapy, the
drug-resistance mutation patterns in HIV have become increasingly more complex ( Richman et al.,
2004a ;Iyidogan and Anderson, 2014 ) often leading to ART failure in patients. Resistance is esti-
mated to develop in up to 50% of patients undergoing monotherapy ( Richman et al., 2004b ) and
up to 30% of patients receiving current combination antiretroviral therapy (c-ART) ( Gupta et al.,
2008 ). The primary drug targets in treatment of HIV are the enzymes coded by the polgene, reverse
transcriptase (RT), protease (PR), and integrase (IN). A large number of sequences of HIV are avail-
able for RT, PR, and IN for patients who have been treated during the past nearly 30 years, and this
information permits critical sequence-based informatic analysis of drug resistance.
The selective pressure of drug therapy modulates patterns of correlated mutations at residue
positions which are both near and distal from the active site ( Chang and Torbett, 2011 ;Haq et al.,
2012 ;Flynn et al., 2015 ;Yilmaz and Schiffer, 2017 ). A mutation’s impact on the stability or fitness
of a protein however is dependent on the entire genetic background in which it occurs: a phenome-
non known as ’epistasis’. Drug resistance develops as these mutations accumulate, providing the
virus a fitness benefit in the presence of drug pressure, with a complex interplay in the roles of
Biswas et al. eLife 2019;8:e50524. DOI: https://doi.org/10.7554/eLife.50524 1 of 30RESEARCH ARTICLE |
1608.03983v5.pdf | Published as a conference paper at ICLR 2017
SGDR: S TOCHASTIC GRADIENT DESCENT WITH
WARM RESTARTS
Ilya Loshchilov & Frank Hutter
University of Freiburg
Freiburg, Germany,
{ilya,fh}@cs.uni-freiburg.de
ABSTRACT
Restart techniques are common in gradient-free optimization to deal with multi-
modal functions. Partial warm restarts are also gaining popularity in gradient-
based optimization to improve the rate of convergence in accelerated gradient
schemes to deal with ill-conditioned functions. In this paper, we propose a sim-
ple warm restart technique for stochastic gradient descent to improve its anytime
performance when training deep neural networks. We empirically study its per-
formance on the CIFAR-10 and CIFAR-100 datasets, where we demonstrate new
state-of-the-art results at 3.14% and 16.21%, respectively. We also demonstrate
its advantages on a dataset of EEG recordings and on a downsampled version of
the ImageNet dataset. Our source code is available at
https://github.com/loshchil/SGDR
1 I NTRODUCTION
Deep neural networks (DNNs) are currently the best-performing method for many classification
problems, such as object recognition from images (Krizhevsky et al., 2012a; Donahue et al., 2014)
or speech recognition from audio data (Deng et al., 2013). Their training on large datasets (where
DNNs perform particularly well) is the main computational bottleneck: it often requires several
days, even on high-performance GPUs, and any speedups would be of substantial value.
The training of a DNN with nfree parameters can be formulated as the problem of minimizing a
functionf: I Rn→I R. The commonly used procedure to optimize fis to iteratively adjust xt∈I Rn
(the parameter vector at time step t) using gradient information ∇ft(xt)obtained on a relatively
smallt-th batch of bdatapoints. The Stochastic Gradient Descent (SGD) procedure then becomes
an extension of the Gradient Descent (GD) to stochastic optimization of fas follows:
xt+1=xt−ηt∇ft(xt), (1)
whereηtis a learning rate. One would like to consider second-order information
xt+1=xt−ηtH−1
t∇ft(xt), (2)
but this is often infeasible since the computation and storage of the inverse Hessian H−1
tis in-
tractable for large n. The usual way to deal with this problem by using limited-memory quasi-
Newton methods such as L-BFGS (Liu & Nocedal, 1989) is not currently in favor in deep learning,
not the least due to (i) the stochasticity of ∇ft(xt), (ii) ill-conditioning of fand (iii) the presence
of saddle points as a result of the hierarchical geometric structure of the parameter space (Fukumizu
& Amari, 2000). Despite some recent progress in understanding and addressing the latter problems
(Bordes et al., 2009; Dauphin et al., 2014; Choromanska et al., 2014; Dauphin et al., 2015), state-of-
the-art optimization techniques attempt to approximate the inverse Hessian in a reduced way, e.g.,
by considering only its diagonal to achieve adaptive learning rates. AdaDelta (Zeiler, 2012) and
Adam (Kingma & Ba, 2014) are notable examples of such methods.
1arXiv:1608.03983v5 [cs.LG] 3 May 2017 |
2402.05120.pdf | More Agents Is All You Need
Junyou Li* 1Qin Zhang* 1Yangbin Yu1Qiang Fu1Deheng Ye1
Abstract
We find that, simply via a sampling-and-voting
method, the performance of large language mod-
els (LLMs) scales with the number of agents in-
stantiated. Also, this method is orthogonal to
existing complicated methods to further enhance
LLMs, while the degree of enhancement is cor-
related to the task difficulty. We conduct com-
prehensive experiments on a wide range of LLM
benchmarks to verify the presence of our finding,
and to study the properties that can facilitate its
occurrence. Our code is publicly available at: Git.
1. Introduction
Although large language models (LLMs) demonstrate re-
markable capabilities in variety of applications (Zhao et al.,
2023), such as language generation, understanding, and
reasoning, they struggle to provide accurate answers when
faced with complicated tasks. To improve the performance
of LLMs, some of recent studies focus on ensemble meth-
ods (Wang et al., 2023b; Wan et al., 2024) and multiple
LLM-Agents collaboration frameworks (Du et al., 2023;
Wu et al., 2023).
In these works, multiple LLM agents are used to improve
the performance of LLMs. For instance, LLM-Debate (Du
et al., 2023) employs multiple LLM agents in a debate form.
The reasoning performance is improved by creating a frame-
work that allows more than one agent to “debate” the final
answer of arithmetic tasks. They show performance im-
provements compared to using one single agent. Similarly,
CoT-SC (Wang et al., 2023b) generates multiple thought
chains and picks the most self-consistent one as the final an-
swer. The reasoning performance is improved by involving
more thought chains compared to chain-of-thought (CoT)
(Wei et al., 2022) which employs a single thought chain. In-
cidentally, from the data analysis of these works, we can no-
tice the effects of putting multiple agents together, to some
extent, can lead to a performance improvement in certain
problems. For example, in Table 10 of Section 3.3 of LLM-
*Equal contribution1Tencent Inc. Correspondence to: Deheng
Ye<dericye@tencent.com >.
Figure 1. The accuracy increases with ensemble size across
Llama2-13B, Llama2-70B and GPT-3.5-Turbo in GSM8K. When
the ensemble size scales up to 15, Llama2-13B achieves compara-
ble accuracy with Llama2-70B. Similarly, When the ensemble size
scales up to 15and20, Llama2-70B and GPT-3.5-Turbo achieve
comparable accuracy with their more powerful counterparts.
Debate (Du et al., 2023), the authors have reported a prelim-
inary curve: the accuracy of a math problem increases with
the number of debating agents (although the number was
simply increased from 1 to 7). Also, in Wang et al. (2023b),
involving more chains-of-thought pipelines (termed as a
“sample-and-marginalize” decoding procedure), can lead
to a performance gain. We realize that the LLM perfor-
mance may likely be improved by a brute-force scaling
up the number of agents instantiated. However, since the
scaling property of “raw” agents is not the focus of these
works, the scenarios/tasks and experiments considered are
limited. So far, there lacks a dedicated in-depth study on
this phenomenon. Hence, a natural question arises: Does
this phenomenon generally exist?
To answer the research question above, we conduct the first
comprehensive study on the scaling property of LLM agents.
To dig out the potential of multiple agents, we propose to use
a simple(st) sampling-and-voting method, which involves
two phases. First, the query of the task, i.e., the input to
an LLM, is iteratively fed into a single LLM, or a multiple
LLM-Agents collaboration framework, to generate multiple
outputs. Subsequently, majority voting is used to determine
the final result. The procedure is inspired by that of the
CoT-SC, but it does not rely on designing complex CoT
1arXiv:2402.05120v1 [cs.CL] 3 Feb 2024 |
2305.18290.pdf | Direct Preference Optimization:
Your Language Model is Secretly a Reward Model
Rafael Rafailov∗†Archit Sharma∗†Eric Mitchell∗†
Stefano Ermon†‡Christopher D. Manning†Chelsea Finn†
†Stanford University‡CZ Biohub
{rafailov,architsh,eric.mitchell}@cs.stanford.edu
Abstract
While large-scale unsupervised language models (LMs) learn broad world knowl-
edge and some reasoning skills, achieving precise control of their behavior is
difficult due to the completely unsupervised nature of their training. Existing
methods for gaining such steerability collect human labels of the relative quality of
model generations and fine-tune the unsupervised LM to align with these prefer-
ences, often with reinforcement learning from human feedback (RLHF). However,
RLHF is a complex and often unstable procedure, first fitting a reward model that
reflects the human preferences, and then fine-tuning the large unsupervised LM
using reinforcement learning to maximize this estimated reward without drifting
too far from the original model. In this paper, we leverage a mapping between
reward functions and optimal policies to show that this constrained reward maxi-
mization problem can be optimized exactly with a single stage of policy training,
essentially solving a classification problem on the human preference data. The
resulting algorithm, which we call Direct Preference Optimization (DPO), is stable,
performant, and computationally lightweight, eliminating the need for fitting a
reward model, sampling from the LM during fine-tuning, or performing significant
hyperparameter tuning. Our experiments show that DPO can fine-tune LMs to
align with human preferences as well as or better than existing methods. Notably,
fine-tuning with DPO exceeds RLHF’s ability to control sentiment of generations
and improves response quality in summarization and single-turn dialogue while
being substantially simpler to implement and train.
1 Introduction
Large unsupervised language models (LMs) trained on very large datasets acquire surprising capabili-
ties [ 11,7,37,8]. However, these models are trained on data generated by humans with a wide variety
of goals, priorities, and skillsets. Some of these goals and skillsets may not be desirable to imitate; for
example, while we may want our AI coding assistant to understand common programming mistakes
in order to correct them, nevertheless, when generating code, we would like to bias our model toward
the (potentially rare) high-quality coding ability present in its training data. Similarly, we might want
our language model to be aware of a common misconception believed by 50% of people, but we
certainly do not want the model to claim this misconception to be true in 50% of queries about it!
In other words, selecting the model’s desired responses and behavior from its very wide knowledge
and abilities is crucial to building AI systems that are safe, performant, and controllable [ 23]. While
existing methods typically steer LMs to match human preferences using reinforcement learning (RL),
∗Equal contribution; more junior authors listed earlier.
Preprint. Under review.arXiv:2305.18290v1 [cs.LG] 29 May 2023 |
2111.12763.pdf | Sparse is Enough in Scaling Transformers
Sebastian Jaszczur∗
University of WarsawAakanksha Chowdhery
Google ResearchAfroz Mohiuddin
Google ResearchŁukasz Kaiser∗
OpenAI
Wojciech Gajewski
Google ResearchHenryk Michalewski
Google ResearchJonni Kanerva
Google Research
Abstract
Large Transformer models yield impressive results on many tasks, but are expen-
sive to train, or even fine-tune, and so slow at decoding that their use and study
becomes out of reach. We address this problem by leveraging sparsity. We study
sparse variants for all layers in the Transformer and propose Scaling Transformers ,
a family of next generation Transformer models that use sparse layers to scale
efficiently and perform unbatched decoding much faster than the standard Trans-
former as we scale up the model size. Surprisingly, the sparse layers are enough
to obtain the same perplexity as the standard Transformer with the same number
of parameters. We also integrate with prior sparsity approaches to attention and
enable fast inference on long sequences even with limited memory. This results in
performance competitive to the state-of-the-art on long text summarization.
1 Introduction
The field of natural language processing has seen dramatic improvements in recent years due to large
neural networks based on the Transformer architecture. The original Transformer [ 42] significantly
advanced state-of-the-art in machine translation. BERT [ 7] surpassed all previous methods on
question answering, language inference and other NLP tasks and was followed by a line of models
like T5 [ 30] that further improved these results. The GPT line of models [ 29,3] elevated language
generation to the point that GPT-2 was invited to write short passages for the Economist and GPT-3
created whole articles almost indistinguishable from human-written ones.
The benefits of this progress are undercut by the huge costs such models incur. Strubell et al. [36]
estimate that training a single base BERT model costs $4k-$12k and emits as much CO 2as one
passenger’s share of a 4-hour flight and later Patterson et al. [27] estimate that training GPT-3 has
three times as much tCO 2e (metric tons of CO 2equivalent) emissions as a SF-NY round trip flight.
Data and serving costs are also forbidding: a single training run of BERT, for example, processes
128B tokens, and Google Translate reportedly1serves over 143B words per day.
With the growing popularity and size of these models, it is increasingly valuable to make them scale
efficiently. In this work we propose Scaling Transformers with a separate sparse mechanism for the
query, key, value and output layers (QKV layers for short) and combine it with sparse feedforward
blocks to get a fully sparse Transformer architecture.
To quantify the computational complexity of inference in Transformer models, recall the architecture
of a Transformer decoder block. It consists of three parts: a masked self-attention layer, an encoder-
decoder attention layer and a feedforward block. The sizes of these layers are parameterized by dmodel
anddff. The base BERT model sets dmodel = 768 , the large BERT has dmodel = 1024 , the largest
∗Work done while at Google Research.
1https://cutt.ly/skkFJ7a
35th Conference on Neural Information Processing Systems (NeurIPS 2021), Sydney, Australia.arXiv:2111.12763v1 [cs.LG] 24 Nov 2021 |
10.1126.science.aay8015.pdf | STRUCTURAL BIOLOGY
Structural basis for strand-transfer inhibitor binding
to HIV intasomes
Dario Oliveira Passos1*, Min Li2*, Ilona K. Józ ´wik1, Xue Zhi Zhao3, Diogo Santos-Martins4,
Renbin Yang2, Steven J. Smith3, Youngmin Jeon1, Stefano Forli4, Stephen H. Hughes3,
Terrence R. Burke Jr.3, Robert Craigie2, Dmitry Lyumkis1,4†
The HIV intasome is a large nucleoprotein assembly that mediates the integration of a DNA copy of
the viral genome into host chromatin. Intasomes are targeted by the latest generation of antiretroviral
drugs, integrase strand-transfer inhibitors (INSTIs). Challenges associated with lentiviral intasome
biochemistry have hindered high-resolution structural studies of how INSTIs bind to their native drug
target. Here, we present high-resolution cryo –electron microscopy structures of HIV intasomes bound
to the latest generation of INSTIs. These structures highlight how small changes in the integrase active
site can have notable implications for drug binding and design and provide mechanistic insights into
why a leading INSTI retains efficacy against a broad spectrum of drug-resistant variants. The data have
implications for expanding effective treatments available for HIV-infected individuals.
HIV currently infects ~40 million people
worldwide. The virus ’s ability to inte-
grate a viral DNA (vDNA) copy of its
RNA genome into host chromatin, lead-
ing to the establishment of a permanent
and irreversible infection of the target cell(and any progeny cells), is the central chal-
lenge in developing a cure ( 1). Integration, cat-
alyzed by the viral integrase (IN) protein, is
essential for retroviral replication and results
in the covalent linkage of vDNA to the host
genome ( 2,3). Proper integration depends on
the formation of a large oligomeric nucleo-
protein complex containing viral IN assembled
on the ends of vDNA, commonly referred to
as an intasome ( 4–9). All intasomes contain
multimeric IN bound to vDNA ends, but they
are characterized by distinct oligomeric con-
figurations and domain arrangements.
Intasome assembly and catalysis proceed
through a multistep process that involves sev-
eral distinct intermediates (fig. S1). The cat-
alytically competent cle aved synaptic complex
(CSC) intasome, which contains free 3 ′-OH
ends, is the specific target of the IN strand-
transfer inhibitors (INSTIs), a group of drugs
that bind to both the active site of HIV IN
and the ends of vDNA, thereby blocking ca-
talysis. Treatment with INSTIs, which are a key
component of combined antiretroviral thera-
py, leads to a rapid decrease in viral load in
patients. INSTIs are generally well tolerated,
and the second-generation drugs do not read-
ily select for resistance ( 10–13). They are used
in the recommended first-line combinationtherapies for treating HIV-infected patients
and are prime candidates for future develop-
ment ( 14,15).
The prototype foamy virus (PFV) intasome
has been used as a model system to under-
stand INSTI binding ( 6,16–19). However, this
system has limitations. PFV and HIV INs share
only ~25% of sequence identity in the catalytic
core domain (CCD) ( 6), and many of the sites
where drug-resistance mutations occur in HIV
IN are not conserved in PFV IN. Moreover,
minor changes in the structure of an INSTI can
profoundly affect its ability to inhibit mutant
forms of HIV ( 19,20). Thus, understanding
how INSTIs interact with HIV intasomes —
their natural target —at a molecular level is
needed to overcome drug resistance and to
guide development of improved inhibitors.
We established conditions for assembling,
purifying, and structurally characterizing HIV
CSC intasomes. Previously, we have shown
that fusion of the small protein Sso7d to the
N-terminal domain (NTD) of HIV IN improves
its solubility and facilitates assembly and puri-
fication of strand-transfer complex intasomes
(4,21
). We further optimized conditions re-
quired for CSC formation and purification
and showed that these complexes are bio-
chemically active for concerted integration
(fig. S2). We used a tilted cryo –electron mi-
croscopy (cryo-EM) data collection strategy
to alleviate the effects of preferential speci-
men orientation on cryo-EM grids ( 22), which
allowed us to collect data on the apo form
of the HIV CSC intasome. The cryo-EM re-
construction of the HIV CSC intasome reveals
a twofold symmetric dodecameric molecular
assembly of IN. The highest resolution (~2.7 Å)
resides within the core containing the twocatalytic sites and the ends of vDNA (fig. S3
and table S1).
Lentiviral intasomes have a large degree of
heterogeneity and vary in size depending onthe protein and biochemical conditions, form-
ing tetramers, dodecamers, hexadecamers,
and proto-intasome stacks (figs. S4 and S5).
The basic underlying unit, the conserved in-
tasome core (CIC), resembles —but is not iden-
tical to —the tetrameric PFV intasome. The
CIC is composed of two IN dimers, each of
which binds one vDNA end and a C-terminal
domain (CTD) from a neighboring protomer
(23). In the cryo-EM reconstruction, four fully
defined IN protomers, two CTDs from flank-
ing protomers, and two additional CTDs from
distal subunits are clearly resolved (Fig. 1A);
these were used to build an atomic model(Fig. 1B). With the exception of the additional
CTDs from distal subunits, which are not
conserved in other retroviral species, the re-
solved regions constitute the intasome CIC.
Each of the two active sites in an HIV in-
tasome contains the catalytic residues Asp
64,
Asp116, and Glu152, forming the prototypical
DDE motif present in many nucleases, trans-
posases, and other INs ( 24). The regions near
the active sites of the PFV and HIV intasomes
a r es i m i l a rb e c a u s em a n yo ft h er e s i d u e sp a r -
ticipate in substrate binding and catalysis.
However, farther from the active sites, the
structures diverge (Fig. 1C and figs. S6 and S7).
The largest differences reside in the synaptic
CTD from the flanking protomer, specifically
the region around the loop spanning HIV IN
Arg228-Lys236.T h ec o r r e s p o n d i n gl o o pi nP F V
IN has four additional residues and assumes a
distinct configuration. Clinically relevant drug-
resistance mutations occur within regions of
HIV IN where the amino acid sequences be-
tween the two orthologs diverge ( 11,12).
To better understand how INSTIs interact
with HIV intasomes, we assembled the com-
plex with bictegravir ( BIC), a leading second-
generation INSTI and the most broadly potent of
all clinically approved INSTIs ( 25). We also ex-
amined the binding of additional compounds —
named 4f,4d,a n d4c, which contain a distinct
chelating core (Fig. 2A) —whose development
was motivated by the need to further improve
potency against drug-resistant variants ( 19,20).
Currently, 4dis a leading drug candidate that
shows improved efficacy over all clinically used
and developmental compounds against the
known drug-resistant variants ( 25,26)( f i g .S 8 ) .
Intasomes were coassembled and copurified
with INSTIs, and we verified their inhibitory
activity (fig. S9). The cryo-EM structures of
INSTI-bound CSCs extend to a comparable
~2.6 to 2.7 Å resolution near the active site,
which allows the derivation of atomic models
(figs. S10 to S12 and table S1).
INSTIs bind HIV CSCs within a well-defined
pocket, formed by the interface between two
IN protomers and vDNA. Several important
pharmacophores characterize the binding of
all INSTIs (Fig. 2, B and C). First, three cen-
tral electronegative heteroatoms chelate twoRESEARCH
Passos et al.,Science 367, 810 –814 (2020) 14 February 2020 1o f4
1The Salk Institute for Biological Studies, Laboratory of Genetics,
La Jolla, CA 92037, USA.2National Institutes of Health, National
Institute of Diabetes and Digestive Diseases, Bethesda, MD
20892, USA.3Center for Cancer Research, National Cancer
Institute, Frederick, MD 21702, USA.4Department of Integrative
Structural and Computational Biology, The Scripps Research
Institute, La Jolla, CA 92037, USA.
*These authors contributed equally to this work.
†Corresponding author. Email: dlyumkis@salk.edu
Downloaded from https://www.science.org at University of California San Diego on July 04, 2023
|
2404.01413v2.pdf | Is Model Collapse Inevitable? Breaking the Curse of
Recursion by Accumulating Real and Synthetic Data
Matthias Gerstgrasser∗†, Rylan Schaeffer∗, Apratim Dey∗, Rafael Rafailov∗, Dhruv Pai
Stanford University
{mgerst,rschaef,apd1995,rafailov,dhruvpai }@stanford.edu
Henry Sleight‡, John Hughes‡, Tomasz Korbak‡, Rajashree Agrawal‡
Constellation
Andrey Gromov
University of Maryland, College Park
Daniel A. Roberts
MIT & Sequoia Capital
Diyi Yang, David Donoho & Sanmi Koyejo
Stanford University
{diyiy,donoho,sanmi }@stanford.edu
Abstract
The proliferation of generative models, combined with pretraining on web-
scale data, raises a timely question: what happens when these models are
trained on their own generated outputs? Recent investigations into model-
data feedback loops proposed that such loops would lead to a phenomenon
termed model collapse , under which performance progressively degrades
with each model-data feedback iteration until fitted models become useless.
However, those studies largely assumed that new data replace old data over
time, where an arguably more realistic assumption is that data accumulate
over time. In this paper, we ask: what effect does accumulating data have
on model collapse? We empirically study this question by pretraining se-
quences of language models on text corpora. We confirm that replacing
the original real data by each generation’s synthetic data does indeed tend
towards model collapse, then demonstrate that accumulating the successive
generations of synthetic data alongside the original real data avoids model
collapse; these results hold across a range of model sizes, architectures, and
hyperparameters. We obtain similar results for deep generative models on
other types of real data: diffusion models for molecule conformation gener-
ation and variational autoencoders for image generation. To understand
why accumulating data can avoid model collapse, we use an analytically
tractable framework introduced by prior work in which a sequence of linear
models are fit to the previous models’ outputs. Previous work used this
framework to show that if data are replaced, the test error increases with
the number of model-fitting iterations; we extend this argument to prove
that if data instead accumulate, the test error has a finite upper bound
independent of the number of iterations, meaning model collapse no longer
occurs. Our work provides consistent empirical and theoretical evidence
that data accumulation avoids model collapse.
∗Denotes equal authorship.
†Harvard & Stanford University.
‡Denotes equal contribution.
1arXiv:2404.01413v2 [cs.LG] 29 Apr 2024 |
10.1038.s42004-024-01098-2.pdf | ARTICLE
Evolution shapes interaction patterns for epistasis
and speci fic protein binding in a two-component
signaling system
Zhiqiang Yan1& Jin Wang2✉
The elegant design of protein sequence/structure/function relationships arises from the
interaction patterns between amino acid positions. A central question is how evolutionaryforces shape the interaction patterns that encode long-range epistasis and binding speci ficity.
Here, we combined family-wide evolutionary analysis of natural homologous sequences andstructure-oriented evolution simulation for two-component signaling (TCS) system. Themagnitude-frequency relationship of coupling conservation between positions manifests apower-law-like distribution and the positions with highly coupling conservation are sparse butdistributed intensely on the binding surfaces and hydrophobic core. The structure-speci fic
interaction pattern involves further optimization of local frustrations at or near the bindingsurface to adapt the binding partner. The construction of family-wide conserved interactionpatterns and structure-speci fic ones demonstrates that binding speci ficity is modulated by
both direct intermolecular interactions and long-range epistasis across the binding complex.Evolution sculpts the interaction patterns via sequence variations at both family-wide andstructure-speci fic levels for TCS system.https://doi.org/10.1038/s42004-024-01098-2 OPEN
1Center for Theoretical Interdisciplinary Sciences, Wenzhou Institute, University of Chinese Academy of Sciences, Wenzhou, Zhejiang 325001, PR Ch ina.
2Department of Chemistry and Physics, State University of New York at Stony Brook, Stony Brook, NY 11790, USA.✉email: jin.wang.1@stonybrook.edu
COMMUNICATIONS CHEMISTRY | (2024) 7:13 | https://doi.org/10.1038/s42004-024-01098-2 | www.nature.com/commschem 11234567890():,; |
2305.10626.pdf | Language Models Meet World Models:
Embodied Experiences Enhance Language Models
Jiannan Xiang∗♠, Tianhua Tao∗♣, Yi Gu♠, Tianmin Shu♢△,
Zirui Wang♠, Zichao Yang♡, Zhiting Hu♠
♠UC San Diego,♣UIUC,♢MIT,△JHU,♡CMU
Abstract
While large language models (LMs) have shown remarkable capabilities across
numerous tasks, they often struggle with simple reasoning and planning in physical
environments, such as understanding object permanence or planning household ac-
tivities. The limitation arises from the fact that LMs are trained only on written text
and miss essential embodied knowledge and skills. In this paper, we propose a new
paradigm of enhancing LMs by finetuning them with world models , to gain diverse
embodied knowledge while retaining their general language capabilities. Our ap-
proach deploys an embodied agent in a world model, particularly a simulator of the
physical world (VirtualHome), and acquires a diverse set of embodied experiences
through both goal-oriented planning and random exploration. These experiences
are then used to finetune LMs to teach diverse abilities of reasoning and acting in
the physical world, e.g., planning and completing goals, object permanence and
tracking, etc.Moreover, it is desirable to preserve the generality of LMs during
finetuning, which facilitates generalizing the embodied knowledge across tasks
rather than being tied to specific simulations. We thus further introduce the classical
elastic weight consolidation (EWC) for selective weight updates, combined with
low-rank adapters (LoRA) for training efficiency. Extensive experiments show
our approach substantially improves base LMs on 18 downstream tasks by 64.28%
on average. In particular, the small LMs (1.3B, 6B, and 13B) enhanced by our
approach match or even outperform much larger LMs (e.g., ChatGPT).1
1 Introduction
Language Models (LMs) have demonstrated impressive performance on a wide range of natural
language processing tasks [ 34,48,4,7,54]. In particular, recent studies show that LMs can assist
decision-making for embodied tasks [ 1,18,25,45,19], demonstrating a certain level of understanding
of the physical world. However, such understanding is not robust enough for many reasoning and
planning tasks in physical environments. As shown in Figure 1, even the latest large LMs like
ChatGPT2can still make mistakes in seemingly simple inquiries, such as counting objects in a
location. We hypothesize that this is because current LMs trained merely with large-scale text corpora
are devoid of embodied experiences such as navigating in an environment, interacting with objects,
and sensing as well as tracking the world state. Consequently, they lack robust and comprehensive
embodied knowledge necessary for reasoning and planning associated with physical environments.
A related line of research finetunes LMs in order to improve specific embodied tasks, resulting in
task-specialized models [6, 58, 21, 57].
∗Equal contribution.
1The code is available at https://github.com/szxiangjn/world-model-for-language-model .
2Based on GPT-3.5-turbo.
37th Conference on Neural Information Processing Systems (NeurIPS 2023).arXiv:2305.10626v3 [cs.CL] 28 Oct 2023 |
2306.14892.pdf | Supervised Pretraining Can Learn
In-Context Reinforcement Learning
Jonathan N. Lee∗1Annie Xie∗1Aldo Pacchiano2Yash Chandak1
Chelsea Finn1Ofir Nachum3Emma Brunskill1
1Stanford University,2Microsoft Research,3Google DeepMind
Abstract
Large transformer models trained on diverse datasets have shown a remarkable
ability to learn in-context , achieving high few-shot performance on tasks they were
not explicitly trained to solve. In this paper, we study the in-context learning capa-
bilities of transformers in decision-making problems, i.e., reinforcement learning
(RL) for bandits and Markov decision processes. To do so, we introduce and study
Decision-Pretrained Transformer (DPT ), a supervised pretraining method where
the transformer predicts an optimal action given a query state and an in-context
dataset of interactions, across a diverse set of tasks. This procedure, while simple,
produces a model with several surprising capabilities. We find that the pretrained
transformer can be used to solve a range of RL problems in-context, exhibiting both
exploration online and conservatism offline, despite not being explicitly trained to
do so. The model also generalizes beyond the pretraining distribution to new tasks
and automatically adapts its decision-making strategies to unknown structure. The-
oretically, we show DPT can be viewed as an efficient implementation of Bayesian
posterior sampling, a provably sample-efficient RL algorithm. We further leverage
this connection to provide guarantees on the regret of the in-context algorithm
yielded by DPT, and prove that it can learn faster than algorithms used to generate
the pretraining data. These results suggest a promising yet simple path towards
instilling strong in-context decision-making abilities in transformers.
1 Introduction
For supervised learning, transformer-based models trained at scale have shown impressive abilities
to perform tasks given an input context, often referred to as few-shot prompting or in-context
learning [ 1]. In this setting, a pretrained model is presented with a small number of supervised input-
output examples in its context, and is then asked to predict the most likely completion (i.e. output)
of an unpaired input, without parameter updates. Over the last few years in-context learning has
been applied to solve a range of tasks [ 2] and a growing number works are beginning to understand
and analyze in-context learning for supervised learning [ 3,4,5,6]. In this work, our focus is to
study and understand in-context learning applied to sequential decision-making, specifically in the
context of reinforcement learning (RL) settings. Decision-making (e.g. RL) is considerably more
dynamic and complex than supervised learning. Understanding and leveraging in-context learning
here could potentially unlock significant improvements in an agent’s ability to adapt and make
few-shot decisions in response to observations from the world. Such capabilities are instrumental for
practical applications ranging from robotics to recommendation systems.
For in-context decision-making [ 7,8,9], rather than input-output tuples, the context takes the form
of state-action-reward tuples representing a dataset of interactions with an unknown environments.
∗Equal contribution.arXiv:2306.14892v1 [cs.LG] 26 Jun 2023 |
2405.03651v1.pdf | Published as a conference paper at ICLR 2024
ADAPTIVE RETRIEVAL AND SCALABLE INDEXING FOR
k-NN S EARCH WITH CROSS -ENCODERS
Nishant Yadav1∗, Nicholas Monath2, Manzil Zaheer2, Rob Fergus2, Andrew McCallum1
1University of Massachusetts Amherst,2Google DeepMind
ABSTRACT
Cross-encoder (CE) models which compute similarity by jointly encoding a
query-item pair perform better than using dot-product with embedding-based
models (dual-encoders) at estimating query-item relevance. Existing approaches
perform k-NN search with cross-encoders by approximating the CE similarity
with a vector embedding space fit either with dual-encoders (DE) or CUR matrix
factorization. DE-based retrieve-and-rerank approaches suffer from poor recall as
DE generalizes poorly to new domains and the test-time retrieval with DE is de-
coupled from the CE. While CUR-based approaches can be more accurate than the
DE-based retrieve-and-rerank approach, such approaches require a prohibitively
large number of CE calls to compute item embeddings, thus making it imprac-
tical for deployment at scale. In this paper, we address these shortcomings with
our proposed sparse-matrix factorization based method that efficiently computes
latent query and item representations to approximate CE scores and performs k-
NN search with the approximate CE similarity. In an offline indexing stage, we
compute item embeddings by factorizing a sparse matrix containing query-item
CE scores for a set of train queries. Our method produces a high-quality ap-
proximation while requiring only a fraction of CE similarity calls as compared to
CUR-based methods, and allows for leveraging DE models to initialize the em-
bedding space while avoiding compute- and resource-intensive finetuning of DE
via distillation. At test time, we keep item embeddings fixed and perform retrieval
over multiple rounds, alternating between a) estimating the test query embedding
by minimizing error in approximating CE scores of items retrieved thus far, and
b) using the updated test query embedding for retrieving more items in the next
round. Our proposed k-NN search method can achieve up to 5% and 54% im-
provement in k-NN recall for k= 1 and 100 respectively over the widely-used
DE-based retrieve-and-rerank approach. Furthermore, our proposed approach to
index the items by aligning item embeddings with the CE achieves up to 100 ×
and 5×speedup over CUR-based and dual-encoder distillation based approaches
respectively while matching or improving k-NN search recall over baselines.
1 I NTRODUCTION
Efficient and accurate nearest neighbor search is paramount for retrieval (Menon et al., 2022; Rosa
et al., 2022; Qu et al., 2021), classification in large output spaces (e.g., entity linking (Ayoola et al.,
2022; Logeswaran et al., 2019; Wu et al., 2020)), non-parametric models (Das et al., 2022; Wang
et al., 2022), and many other such applications in machine learning (Goyal et al., 2022; Izacard
et al., 2023; Bahri et al., 2020). The accuracy and efficiency of nearest neighbor search depends
on a combination of factors (1) the computational cost of pairwise distance comparisons between
datapoints, (2) preprocessing time for constructing a nearest neighbor index (e.g., dimensionality
reduction (Indyk, 2000), quantization (Ge et al., 2013; Guo et al., 2020), data structure construc-
tion (Beygelzimer et al., 2006; Malkov & Yashunin, 2018; Zaheer et al., 2019)), and (3) the time
taken to query the index to retrieve the nearest neighbor(s).
Similarity functions such as cross-encoders which take a pair of data points as inputs and directly
output a scalar score, have achieved state-of-the-art results on numerous tasks (e.g., QA (Qu et al.,
∗Now at Google DeepMind
1arXiv:2405.03651v1 [cs.IR] 6 May 2024 |
1907.05600.pdf | Generative Modeling by Estimating Gradients of the
Data Distribution
Yang Song
Stanford University
yangsong@cs.stanford.eduStefano Ermon
Stanford University
ermon@cs.stanford.edu
Abstract
We introduce a new generative model where samples are produced via Langevin
dynamics using gradients of the data distribution estimated with score matching.
Because gradients can be ill-defined and hard to estimate when the data resides on
low-dimensional manifolds, we perturb the data with different levels of Gaussian
noise, and jointly estimate the corresponding scores, i.e., the vector fields of
gradients of the perturbed data distribution for all noise levels. For sampling, we
propose an annealed Langevin dynamics where we use gradients corresponding to
gradually decreasing noise levels as the sampling process gets closer to the data
manifold. Our framework allows flexible model architectures, requires no sampling
during training or the use of adversarial methods, and provides a learning objective
that can be used for principled model comparisons. Our models produce samples
comparable to GANs on MNIST, CelebA and CIFAR-10 datasets, achieving a new
state-of-the-art inception score of 8.87 on CIFAR-10. Additionally, we demonstrate
that our models learn effective representations via image inpainting experiments.
1 Introduction
Generative models have many applications in machine learning. To list a few, they have been
used to generate high-fidelity images [ 26,6], synthesize realistic speech and music fragments [ 58],
improve the performance of semi-supervised learning [ 28,10], detect adversarial examples and
other anomalous data [ 54], imitation learning [ 22], and explore promising states in reinforcement
learning [ 41]. Recent progress is mainly driven by two approaches: likelihood-based methods [ 17,
29,11,60] and generative adversarial networks (GAN [ 15]). The former uses log-likelihood (or a
suitable surrogate) as the training objective, while the latter uses adversarial training to minimize
f-divergences [40] or integral probability metrics [2, 55] between model and data distributions.
Although likelihood-based models and GANs have achieved great success, they have some intrinsic
limitations. For example, likelihood-based models either have to use specialized architectures to
build a normalized probability model ( e.g., autoregressive models, flow models), or use surrogate
losses ( e.g., the evidence lower bound used in variational auto-encoders [ 29], contrastive divergence
in energy-based models [ 21]) for training. GANs avoid some of the limitations of likelihood-based
models, but their training can be unstable due to the adversarial training procedure. In addition, the
GAN objective is not suitable for evaluating and comparing different GAN models. While other
objectives exist for generative modeling, such as noise contrastive estimation [ 19] and minimum
probability flow [50], these methods typically only work well for low-dimensional data.
In this paper, we explore a new principle for generative modeling based on estimating and sampling
from the (Stein) score [33] of the logarithmic data density, which is the gradient of the log-density
function at the input data point. This is a vector field pointing in the direction where the log data
density grows the most. We use a neural network trained with score matching [ 24] to learn this
vector field from data. We then produce samples using Langevin dynamics, which approximately
33rd Conference on Neural Information Processing Systems (NeurIPS 2019), Vancouver, Canada.arXiv:1907.05600v3 [cs.LG] 10 Oct 2020 |
2301.13196.pdf | Looped Transformers as Programmable Computers
Angeliki Giannouw*, Shashank Rajputw∗, Jy-yong Sohnw,
Kangwook Leew, Jason D. Leep, Dimitris Papailiopoulosw
pPrinceton University
wUniversity of Wisconsin-Madison
January 31, 2023
Abstract
We present a framework for using transformer networks as universal computers by program-
ming them with specific weights and placing them in a loop. Our input sequence acts as a
punchcard, consisting of instructions and memory for data read/writes. We demonstrate that
a constant number of encoder layers can emulate basic computing blocks, including embed-
ding edit operations, non-linear functions, function calls, program counters, and conditional
branches. Using these building blocks, we emulate a small instruction-set computer. This
allows us to map iterative algorithms to programs that can be executed by a looped, 13-layer
transformer. We show how this transformer, instructed by its input, can emulate a basic
calculator, a basic linear algebra library, and in-context learning algorithms that employ back-
propagation. Our work highlights the versatility of the attention mechanism, and demonstrates
that even shallow transformers can execute full-fledged, general-purpose programs.
1 Introduction
Transformers (TFs) have become a popular choice for a wide range of machine learning tasks,
achieving state-of-the-art results in fields such as natural language processing and computer
vision [Vaswani et al., 2017, Khan et al., 2022, Yuan et al., 2021, Dosovitskiy et al., 2020]. One
key reason for their success is their ability to capture higher-order relationships and long-range
dependencies across tokens, through attention. This allows TFs to model contextual information
and makes them effective in tasks such as machine translation and language modeling, where
they have consistently outperformed other methods [Vaswani et al., 2017, Kenton and Toutanova,
2019].
Language models with billions of parameters, such as GPT-3 (175B parameters Brown et al.
[2020]) and PaLM (540B parameters Chowdhery et al. [2022]), have achieved state-of-the-art
*Equal contribution. The title of this paper was not created by a transformer, but we can’t guarantee the same for
this footnote.
1arXiv:2301.13196v1 [cs.LG] 30 Jan 2023 |
1109.2146.pdf | Journal of Artificial Intelligence Research 24 (2005) 1-48 S ubmitted 11/04; published 07/05
CIXL2: A Crossover Operator for Evolutionary Algorithms
Based on Population Features
Domingo Ortiz-Boyer dortiz@uco.es
C´ esar Herv´ as-Mart´ ınez chervas@uco.es
Nicol´ as Garc´ ıa-Pedrajas npedrajas@uco.es
Department of Computing and Numerical Analysis
University of C´ ordoba, Spain
Abstract
In this paper we propose a crossover operator for evolutiona ry algorithms with real
values that is based on the statistical theory of population distributions. The operator is
based on the theoretical distribution of the values of the ge nes of the best individuals in
the population. The proposed operator takes into account th e localization and dispersion
features of the best individuals of the population with the o bjective that these features
would be inherited by the offspring. Our aim is the optimizati on of the balance between
exploration and exploitation in the search process.
In order to test the efficiency and robustness of this crossove r, we have used a set of
functions to be optimized with regard to different criteria, such as, multimodality, sep-
arability, regularity and epistasis. With this set of funct ions we can extract conclusions
in function of the problem at hand. We analyze the results usi ng ANOVA and multiple
comparison statistical tests.
As an example of how our crossover can be used to solve artifici al intelligence problems,
we have applied the proposed model to the problem of obtainin g the weight of each network
in a ensemble of neural networks. The results obtained are ab ove the performance of
standard methods.
1. Introduction
Evolutionary algorithms (EAs) are general purpose searchi ng methods. The selection pro-
cess and the crossover and mutation operators establish a ba lance between the exploration
and exploitation of the search space which is very adequate f or a wide variety of problems
whose solution presents difficulties that are insolvable usi ng classical methods. Most of
these problems are defined in continuous domains, so the evol utionary algorithms applied
use real values, namely, evolution strategies (EPs), real- coded genetic algorithms (RCGAs),
and evolutionary programming (EP). For these paradigms the precision of the solution does
not depend on the coding system, as in binary coded genetic al gorithms, but on the precision
of the computer system where the algorithms are run.
The selection process drives the searching towards the regi ons of the best individuals.
The mutation operator randomly modifies, with a given probab ility, one or more genes of a
chromosome, thus increasing the structural diversity of th e population. As we can see, it is
clearly an exploration operator, that helps to recover the g enetic diversity lost during the
selection phase and to explore new solutions avoiding prema ture convergence. In this way,
the probability of reaching a given point in the search space is never zero. This operator,
c⃝2005 AI Access Foundation. All rights reserved. |
1804.00746v4.pdf | The Simple Essence of Automatic Differentiation
Extended version∗
Conal Elliott
Target
conal@conal.net
March, 2018
Abstract
Automatic differentiation (AD) in reverse mode (RAD) is a central component of deep learning and
other uses of large-scale optimization. Commonly used RAD algorithms such as backpropagation, however,
are complex and stateful, hindering deep understanding, improvement, and parallel execution. This paper
develops a simple, generalized AD algorithm calculated from a simple, natural specification. The general
algorithm is then specialized by varying the representation of derivatives. In particular, applying well-known
constructions to a naive representation yields two RAD algorithms that are far simpler than previously known.
In contrast to commonly used RAD implementations, the algorithms defined here involve no graphs, tapes,
variables, partial derivatives, or mutation. They are inherently parallel-friendly, correct by construction, and
usable directly from an existing programming language with no need for new data types or programming
style, thanks to use of an AD-agnostic compiler plugin.
1 Introduction
Accurate, efficient, and reliable computation of derivatives has become increasingly important over the last several
years, thanks in large part to the successful use of backpropagation in machine learning, including multi-layer
neural networks, also known as “deep learning” [Lecun et al., 2015; Goodfellow et al., 2016]. Backpropagation
is a specialization and independent invention of the reverse mode of automatic differentiation (AD) and is
used to tune a parametric model to closely match observed data, using gradient descent (orstochastic gradient
descent). Machine learning and other gradient-based optimization problems typically rely on derivatives of
functions with very high dimensional domains and a scalar codomain—exactly the conditions under which reverse-
mode AD is much more efficient than forward-mode AD (by a factor proportional to the domain dimension).
Unfortunately, while forward-mode AD (FAD) is easily understood and implemented, reverse-mode AD (RAD)
and backpropagation have had much more complicated explanations and implementations, involving mutation,
graph construction and traversal, and “tapes” (sequences of reified, interpretable assignments, also called “traces”
or “Wengert lists”). Mutation, while motivated by efficiency concerns, makes parallel execution difficult and
so undermines efficiency as well. Construction and interpretation (or compilation) of graphs and tapes also
add execution overhead. The importance of RAD makes its current complicated and bulky implementations
especially problematic. The increasingly large machine learning (and other optimization) problems being solved
with RAD (usually via backpropagation) suggest the need to find more streamlined, efficient implementations,
especially with the massive hardware parallelism now readily and inexpensively available in the form of graphics
processors (GPUs) and FPGAs.
Another difficulty in the practical application of AD in machine learning (ML) comes from the nature of many
currently popular ML frameworks, including Caffe [Jia et al., 2014], TensorFlow [Abadi et al., 2016], and Keras
[Chollet, 2016]. These frameworks are designed around the notion of a “graph” (or “network”) of interconnected
nodes, each of which represents a mathematical operation—a sort of data flow graph. Application programs
∗The appendices of this extended version include proofs omitted in the conference article [Elliott, 2018].
1arXiv:1804.00746v4 [cs.PL] 2 Oct 2018 |
2302.08582.pdf | Pretraining Language Models with Human Preferences
Tomasz Korbak1 2 3Kejian Shi2Angelica Chen2Rasika Bhalerao4Christopher L. Buckley1Jason Phang2
Samuel R. Bowman2 5Ethan Perez2 3 5
Abstract
Language models (LMs) are pretrained to imitate
internet text, including content that would vio-
late human preferences if generated by an LM:
falsehoods, offensive comments, personally iden-
tifiable information, low-quality or buggy code,
and more. Here, we explore alternative objectives
for pretraining LMs in a way that also guides them
to generate text aligned with human preferences.
We benchmark five objectives for pretraining with
human feedback across three tasks and study how
they affect the trade-off between alignment and
capabilities of pretrained LMs. We find a Pareto-
optimal and simple approach among those we ex-
plored: conditional training, or learning distribu-
tion over tokens conditional on their human prefer-
ence scores given by a reward model. Conditional
training reduces the rate of undesirable content by
up to an order of magnitude, both when generat-
ing without a prompt and with an adversarially-
chosen prompt. Moreover, conditional training
maintains the downstream task performance of
standard LM pretraining, both before and after
task-specific finetuning. Pretraining with human
feedback results in much better preference sat-
isfaction than standard LM pretraining followed
by finetuning with feedback, i.e., learning and
then unlearning undesirable behavior. Our results
suggest that we should move beyond imitation
learning when pretraining LMs and incorporate
human preferences from the start of training.
1. Introduction
Language models (LMs) are trained to imitate text from
large and diverse datasets. These datasets often contain
1University of Sussex2New York University3FAR AI
4Northeastern University5Anthropic. Correspondence to:
Tomasz Korbak <tomasz.korbak@gmail.com >, Ethan Perez
<ethan@anthropic.com >.
Proceedings of the 40thInternational Conference on Machine
Learning , Honolulu, Hawaii, USA. PMLR 202, 2023. Copyright
2023 by the author(s).
0 1.6B 3.3B
Tokens seen0.0010.010.1Toxicity scoreConventional LM pretraining
Pretraining with feedback
Finetuning with feedback for 1.6B tokens
Finetuning with feedback for 330M tokens
Figure 1: Toxicity score (lower is better) of LMs pretrained
with the standard objective (solid blue), using conditional
training (solid orange) and LMs finetuned using conditional
training for 1.6B (orange dashed) and 330M tokens (orange
dotted). Pretraining with Human Feedback (PHF) reduces
the amount of offensive content much more effectively than
finetuning with human feedback.
content that violates human preferences, e.g., falsehoods
(Lin et al., 2022), offensive comments (Gehman et al., 2020),
personally identifiable information (PII; Carlini et al., 2020)
or low-quality code (Chen et al., 2021b). Imitating such
data stands in stark contrast with the behavior people desire
from language models, e.g., to generate text that is helpful,
honest and harmless (Askell et al., 2021). In this paper, we
explore alternative objectives for pretraining LMs on large
amounts of diverse data that guide them to generate text
aligned with human preferences.
Prior work on aligning LMs with human preferences almost
exclusively focused on making adjustments to pretrained
LMs. A widely adopted strategy of adding safety filters on
top of pretrained LMs (Xu et al., 2020) works only to an ex-
tent: even the most effective safety filters fail to catch a large
amount of undesirable content (Gehman et al., 2020; Welbl
et al., 2021; Ziegler et al., 2022). Another approach involves
finetuning LMs using either supervised learning on curated
data (Solaiman & Dennison, 2021; Scheurer et al., 2023)
or reinforcement learning from human feedback (RLHF;
Ziegler et al., 2019; Ouyang et al., 2022; Bai et al., 2022;
Menick et al., 2022), but this strategy is also limited by the
fact that large LMs are quite resistant to forgetting their train-
ing data (an effect that increases with model size; Carlini
et al., 2022; Vu et al., 2022; Ramasesh et al., 2022). While
1arXiv:2302.08582v2 [cs.CL] 14 Jun 2023 |
10.1101.2024.02.06.579080.pdf | Direct Coupling Analysis and the Attention Mechanism 1
Francesco Caredda1†and Andrea Pagnani1,2,3†
2
1DISAT, Politecnico di Torino, Corso Duca degli Abruzzi, 24, I-10129, Torino, Italy 3
2Italian Institute for Genomic Medicine, IRCCS Candiolo, SP-142, I-10060, 4
Candiolo, Italy 5
3INFN, Sezione di Torino, Torino, Via Pietro Giuria, 1 10125 Torino Italy 6
Abstract 7
Proteins serve as the foundation for nearly all biological functions within cells, encompassing 8
roles in transport, signaling, enzymatic activity, and more. Their functionalities hinge signifi- 9
cantly on their intricate three-dimensional structures, often posing challenges in terms of diffi- 10
culty, time, and expense for accurate determination. The introduction of AlphaFold 2 marked 11
a groundbreaking solution to the enduring challenge of predicting a protein’s tertiary structure 12
from its amino acid sequence. However, the inherent complexity of AlphaFold’s architecture 13
presents obstacles in deciphering its learning process and understanding the decision-making 14
that ultimately shapes the protein’s final structure. 15
In this study, we introduce a shallow, unsupervised model designed to understand the self- 16
attention layer within the Evoformer block of AlphaFold. We establish a method based on Direct 17
Coupling Analysis (DCA), wherein the interaction tensor undergoes decomposition, leveraging 18
the same structure employed in Transformer architectures. The model’s parameters, notably 19
fewer than those in standard DCA, are interpretable through an examination of the resulting 20
attention matrices. These matrices enable the extraction of contact information, subsequently 21
utilized for constructing the contact map of a protein family. Additionally, the self-attention 22
decomposition in the DCA Hamiltonian form adopted here facilitates the definition of multi- 23
family learning architecture, enabling the inference of parameter sets shared across diverse 24
protein families. Finally, an autoregressive generative version of the model is implemented, 25
capable of efficiently generating new proteins in silico. This generative model reproduces the 26
summary statistics of the original protein family while concurrently inferring direct contacts in 27
the tertiary structure of the protein. The effectiveness of our Attention-Based DCA architecture 28
is evaluated using Multiple Sequence Alignments (MSAs) of varying lengths and depths, with 29
structural data sourced from the Pfam database. 30
1 Introduction 31
Proteins constitute a diverse category of biological compounds constructed from a set of 20 amino 32
acids. Within an organism, they serve various functions, including structural support, mobility, 33
1. CC-BY 4.0 International license available under a(which was not certified by peer review) is the author/funder, who has granted bioRxiv a license to display the preprint in perpetuity. It is made The copyright holder for this preprint this version posted February 8, 2024. ; https://doi.org/10.1101/2024.02.06.579080doi: bioRxiv preprint |
IN-Tetramer-manuscript-merged-with-figures-bioRxiv.pdf | 1 Oligomeric HIV-1 Integrase Structures Reveal Functional Plasticity for Intasome Assembly and RNA Binding Tao Jing1‡, Zelin Shan1‡, Tung Dinh4, Avik Biswas1, Sooin Jang5,6, Juliet Greenwood5, Min Li7, Zeyuan Zhang1, Gennavieve Gray1, Hye Jeong Shin1, Bo Zhou1, Dario Passos1, Sriram Aiyer1, Zhen Li5, Robert Craigie7, Alan N. Engelman5,6, Mamuka Kvaratskhelia4, Dmitry Lyumkis1,2,3,* 1. The Salk Institute for Biological Studies, La Jolla, CA, 92037, USA. 2. Department of Integrative Structural and Computational Biology, The Scripps Research Institute, La Jolla, CA, 92037, USA. 3. Graduate School of Biological Sciences, Section of Molecular Biology, University of California San Diego, La Jolla, CA 92093, USA. 4. Division of Infectious Diseases, Anschutz Medical Campus, University of Colorado School of Medicine, Aurora, CO 80045, USA 5. Department of Cancer Immunology and Virology, Dana-Farber Cancer Institute, Boston, MA 02215, USA 6. Department of Medicine, Harvard Medical School, Boston, MA 02115, USA 7. National Institutes of Health, National Institute of Diabetes and Digestive Diseases, Bethesda, MD, 20892, USA ‡ These authors contributed equally to this work * Correspondence: Dmitry Lyumkis (dlyumkis@salk.edu) |
2402.07871.pdf | SCALING LAWS FOR FINE-GRAINED
MIXTURE OF EXPERTS
Jakub Krajewski∗
University of Warsaw
IDEAS NCBRJan Ludziejewski∗
University of Warsaw
IDEAS NCBRKamil Adamczewski
IDEAS NCBRMaciej Pi ´oro
IPPT PAN
IDEAS NCBR
Michał Krutul
University of Warsaw
IDEAS NCBRSzymon Antoniak
University of Warsaw
IDEAS NCBRKamil Ciebiera
University of Warsaw
IDEAS NCBRKrystian Kr ´ol
University of Warsaw
IDEAS NCBR
Tomasz Odrzyg ´o´zd´z
TradeLinkPiotr Sankowski
University of Warsaw
IDEAS NCBRMarek Cygan
University of Warsaw
NomagicSebastian Jaszczur∗
University of Warsaw
IDEAS NCBR
ABSTRACT
Mixture of Experts (MoE) models have emerged as a primary solution for reducing
the computational cost of Large Language Models. In this work, we analyze their
scaling properties, incorporating an expanded range of variables. Specifically, we
introduce a new hyperparameter, granularity, whose adjustment enables precise
control over the size of the experts. Building on this, we establish scaling laws for
fine-grained MoE, taking into account the number of training tokens, model size,
and granularity. Leveraging these laws, we derive the optimal training configuration
for a given computational budget. Our findings not only show that MoE models
consistently outperform dense Transformers but also highlight that the efficiency
gap between dense and MoE models widens as we scale up the model size and
training budget. Furthermore, we demonstrate that the common practice of setting
the size of experts in MoE to mirror the feed-forward layer is not optimal at almost
any computational budget.
1 I NTRODUCTION
In recent years, we have witnessed Large Language Models (LLMs) achieve exceptional performance
in tasks across numerous domains (Chowdhery et al., 2022; Yin et al., 2023; Agostinelli et al., 2023).
However, training those massive models incurs high computational costs, measured in millions
of GPU-hours (Touvron et al., 2023b), enabled only by enormous budgets (Scao et al., 2023) and
leading to non-negligible carbon footprints (Faiz et al., 2024). To combat these obstacles, the research
community has been striving to increase the efficiency of LLMs. One promising approach that has
lately been gaining visibility is the use of Mixture of Experts (MoE) methods. Models such as Switch
(Fedus et al., 2022) and Mixtral (Jiang et al., 2024) have already demonstrated that it is possible to
achieve comparable effectiveness with significantly lower computational costs.
In the context of the current trend of increasing budgets for training language models, a question
arises: will MoE models continue to be attractive in the future? This is an important issue, as other
studies have stated that the gap in efficiency between MoE and standard Transformers narrows at
Contributions: Jakub implemented fine-grained MoE, ran experiments, and oversaw the course of the project.
Jan designed and implemented the scaling laws, also optimized and tuned the fine-grained MoE implementation.
Kamil A. provided significant advice on many aspects of the project. Maciej experimented with the block design
and, with Michał, provided considerable technical support. Szymon, Kamil C., Krystian, and Tomasz contributed
to the project and the engineering in various ways. Marek, along with Piotr, provided high-level scientific advice.
Sebastian came up with the initial idea, started the project, and supervised it while setting the research direction
and leading experiments and analyses. Correspondence to <s.jaszczur@uw.edu.pl >.∗Equal contribution.
1arXiv:2402.07871v1 [cs.LG] 12 Feb 2024 |
2105.14111.pdf | Goal Misgeneralization in Deep Reinforcement Learning
Lauro Langosco* 1Jack Koch*Lee Sharkey* 2Jacob Pfau3Laurent Orseau4David Krueger1
Abstract
We study goal misgeneralization , a type of out-
of-distribution generalization failure in reinforce-
ment learning (RL). Goal misgeneralization oc-
curs when an RL agent retains its capabilities out-
of-distribution yet pursues the wrong goal. For
instance, an agent might continue to competently
avoid obstacles, but navigate to the wrong place.
In contrast, previous works have typically focused
on capability generalization failures, where an
agent fails to do anything sensible at test time.
We formalize this distinction between capability
and goal generalization, provide the first empiri-
cal demonstrations of goal misgeneralization, and
present a partial characterization of its causes.
1. Introduction
Out-of-distribution (OOD) generalization, performing well
on test data that is not distributed identically to the training
set, is a fundamental problem in machine learning (Arjovsky,
2021). OOD generalization is crucial since in many applica-
tions it is not feasible to collect data distributed identically
to that which the model will encounter in deployment.
In this work, we focus on a particularly concerning type of
generalization failure that can occur in RL. When an RL
agent is deployed out of distribution, it may simply fail to
take useful actions. However, there exists an alternative
failure mode in which the agent pursues a goal other than
the training reward while retaining the capabilities it had on
the training distribution. For example, an agent trained to
pursue a fixed coin might not recognize the coin when it is
positioned elsewhere, and instead competently navigate to
the wrong position (Figure 1). We call this kind of failure
goal misgeneralization1and distinguish it from capabil-
*Equal contribution1University of Cambridge2University of
T¨ubingen3University of Edinburgh4DeepMind, London. Corre-
spondence to: Lauro Langosco <langosco.lauro@gmail.com >.
Proceedings of the 39thInternational Conference on Machine
Learning , Baltimore, Maryland, USA, PMLR 162, 2022. Copy-
right 2022 by the author(s).
1We adopt this term from Shah et al. (2022). A previous version
of our work used the term ‘objective robustness failure’ instead. We
(a) Goal position fixed (b) Goal position randomizedFigure 1. (a)At training time, the agent learns to reliably reach the
coin which is always located at the end of the level. (b)However,
when the coin position is randomized at test time, the agent still
goes towards the end of the level and often skips the coin. The
agent’s capability for solving the levels generalizes, but its goal of
collecting coins does not.
ity generalization failures. We provide the first empirical
demonstrations of goal misgeneralization to highlight and
illustrate this phenomenon.
While it is well-known that the true reward function can
be unidentifiable in inverse reinforcement learning (Amin
& Singh, 2016), our work shows that a similar problem
can also occur in reinforcement learning when features of
the environment are correlated and predictive of the reward
on the training distribution but not OOD. In this way, goal
misgeneralization can also resemble problems that arise in
supervised learning when models use unreliable features:
both problems are a form of competent misgeneralization
that works in-distribution but fails OOD. Disentangling ca-
pability and goal generalization failures is difficult in su-
pervised learning; for instance, are adversarial examples
bugs or features (Ilyas et al., 2019)? In contrast, studying
RL allows us to formally distinguish capabilities and goals,
which roughly correspond to understanding the environment
dynamics and the reward function, respectively.
Goal misgeneralization might be more dangerous than ca-
pability generalization failures, since an agent that capably
pursues an incorrect goal can leverage its capabilities to visit
arbitrarily bad states (Zhuang & Hadfield-Menell, 2021). In
contrast, the only risks from capability generalization fail-
ures are those of accidents due to incompetence.
use the term ‘goal’ to refer to goal-directed (optimizing) behavior,
notjust goal-states in MDPs.arXiv:2105.14111v7 [cs.LG] 9 Jan 2023 |
2402.09727.pdf | 2024-02-14
A Human-Inspired Reading Agent with Gist
Memory of Very Long Contexts
Kuang-Huei Lee1, Xinyun Chen1, Hiroki Furuta1, John Canny1and Ian Fischer2
1Google DeepMind,2Google Research
Correspond to: {leekh, iansf}@google.com; Author contributions are stated in Appendix J.
Website: read-agent.github.io
Current Large Language Models (LLMs) are not only limited to some maximum context length, but also
are not able to robustly consume long inputs. To address these limitations, we propose ReadAgent,
an LLM agent system that increases effective context length up to 20×in our experiments. Inspired
by how humans interactively read long documents, we implement ReadAgent as a simple prompting
system that uses the advanced language capabilities of LLMs to (1) decide what content to store together
in a memory episode, (2) compress those memory episodes into short episodic memories called gist
memories , and (3) take actions to look up passages in the original text if ReadAgent needs to remind
itself of relevant details to complete a task. We evaluate ReadAgent against baselines using retrieval
methods, using the original long contexts, and using the gist memories. These evaluations are performed
on three long-document reading comprehension tasks: QuALITY, NarrativeQA, and QMSum. ReadAgent
outperforms the baselines on all three tasks while extending the effective context window by 3−20×.
1. Introduction
Transformer-based Large Language Models (LLMs)
are highly capable of language understanding, but the
amount of text that LLMs are able to read at one time
is constrained. Not only is there an explicit context
length limitation, but it has also been found that per-
formance of LLMs tends to decline with increasingly
long inputs even when they don’t actually exceed the
explicit context window [ 25,37]. In contrast, humans
can read, understand, and reason over very long texts,
such as a series of interrelated books.
Wepositthatanunderlyingreasonforthisgapisinher-
ent in the differences in reading approaches. Typically,
weuseLLMstoconsumetheexactgivencontentword-
by-word and the process is relatively passive. On the
other hand, humans read and reason over long text
differently. First, the exact information tends to be
forgottenquickly, whereasthefuzziergistinformation,
i.e. the substance irrespective of exact words, from
past readings lasts much longer [ 34,31,33]1. Second,
human reading is an interactive process. When we
need to remind ourselves of relevant details in order
to complete a task, such as answering a question, we
look them up in the original text.
1Fuzzy-trace theory [ 34] posits that people form two types of
memory representations about a past event – verbatim and gist
memories. Gist memories, often episodic, are fuzzy memories of
past events, whereas verbatim memories contain details of past
events. People prefer to reason with gists rather than with verbatim
memories [32].
A very very long
text ……
…………………
…………………
…………………
…………………
…………………
…………………
…………………
………………… 1. Episode
Pagination page 1
page 2
page 3
page N
[page 1] gist
[page 2] gist (Episodic) Gist Memory
[page N] gist 2. Gisting
Q: Why did John … ?
3. Lookup
Figure 1|ReadAgent workflow.
We think that using the fuzzy gist memory to capture
global context and attending to local details together
enables humans to reason over very long context effi-
ciently, in terms of how much information to process
at once, and is also important for comprehension. For
example, if we were to infer the intention of a fictional
character’s specific action described on a page in a
novel, besides focusing on the surrounding pages, we
likely also need to understand the overall story and
©2024 Google DeepMind. All rights reservedarXiv:2402.09727v1 [cs.CL] 15 Feb 2024 |
2402.09900.pdf | Revisiting Recurrent Reinforcement Learning with Memory Monoids
Steven Morad1Chris Lu2Ryan Kortvelesy1Stephan Liwicki3Jakob Foerster2Amanda Prorok1
Abstract
Memory models such as Recurrent Neural Net-
works (RNNs) and Transformers address Par-
tially Observable Markov Decision Processes
(POMDPs) by mapping trajectories to latent
Markov states. Neither model scales particularly
well to long sequences, especially compared to
an emerging class of memory models sometimes
called linear recurrent models. We discover that
we can model the recurrent update of these mod-
els using a monoid , leading us to reformulate
existing models using a novel memory monoid
framework. We revisit the traditional approach
to batching in recurrent RL, highlighting both
theoretical and empirical deficiencies. We lever-
age the properties of memory monoids to pro-
pose a batching method that improves sample ef-
ficiency, increases the return, and simplifies the
implementation of recurrent loss functions in RL.
1. Introduction
Reinforcement learning (RL) focuses on solving Markov
Decision Processes (MDPs), although in many interesting
problems we cannot access the Markov state directly. Out-
side of simulators, we instead receive noisy or ambiguous
observations , resulting in Partially Observable MDPs. The
standard approach to RL under partial observability is to
summarize a sequence of observations into a latent Markov
state using a memory model (sometimes called a sequence
model). Often, these memory models are either RNNs or
Transformers.
Unfortunately, it is expensive to train Transformers or
RNNs over long sequences. Instead, prior work often
truncates then zero-pads observation sequences into fixed
length segments , keeping the maximum sequence length
short. Using segments adds implementation complexity,
1Department of Computer Science and Technology, University
of Cambridge2Department of Engineering Science, University of
Oxford3Toshiba Europe Ltd.. Correspondence to: Steven Morad
<sm2558@cam.ac.uk >.
Code available at https://github.com/proroklab/
memory-monoids . Copyright 2024 by the author(s).reduces efficiency, and introduces theoretical issues. That
said, most prior work and virtually all existing RL libraries
follow this segment-based approach.
A new class of sequence models, sometimes called Linear
Recurrent Models or Linear Transformers, is much more
efficient over long sequences. These models can be paral-
lelized over the sequence dimension while retaining sub-
quadratic space complexity. We find that many such mod-
els can be rewritten as a memory monoid , a unifying frame-
work for efficient memory models that we define in this
paper. Since these efficient models do not share sequence
length limitations with past models, we question whether
the use of segments is still necessary .
Contributions In this work, we propose a unifying
framework for efficient memory modeling, then propose an
alternative batching method reliant on our framework. Our
method improves sample efficiency across various tasks
and memory models, while generally simplifying imple-
mentation.
1. We propose the memory monoid , a unifying frame-
work for efficient sequence models. In particular, we
• Reformulate existing sequence models as mem-
ory monoids
• Derive memory monoids for the discounted re-
turn and advantage, leveraging GPU parallelism
• Discover a method for inline resets, enabling any
memory monoid to span multiple episodes
2. We investigate the impact that segments have on rein-
forcement learning. Specifically, we
• Highlight theoretical shortcomings of sequence
truncation and padding, then demonstrate their
empirical impact
• Propose a batching method that improves sam-
ple efficiency across all tested models and tasks,
while also simplifying recurrent loss functions
2. Preliminaries and Background
Consider an MDP (S, A, R, T, γ), where at each timestep
t, an agent produces a transition T= (s, a, r, s′)from in-
teraction with the environment. We let s, s′∈Sdenote
1arXiv:2402.09900v2 [cs.LG] 17 Mar 2024 |
2305.11841.pdf | How Does Generative Retrieval Scale to Millions of Passages?
Ronak Pradeep∗†§, Kai Hui∗, Jai Gupta, Adam D. Lelkes, Honglei Zhuang
Jimmy Lin§, Donald Metzler, Vinh Q. Tran∗
Google Research,§University of Waterloo
rpradeep@uwaterloo.ca ,{kaihuibj,vqtran}@google.com
Abstract
Popularized by the Differentiable Search In-
dex, the emerging paradigm of generative re-
trieval re-frames the classic information re-
trieval problem into a sequence-to-sequence
modeling task, forgoing external indices and
encoding an entire document corpus within
a single Transformer. Although many differ-
ent approaches have been proposed to improve
the effectiveness of generative retrieval, they
have only been evaluated on document cor-
pora on the order of 100k in size. We conduct
the first empirical study of generative retrieval
techniques across various corpus scales, ulti-
mately scaling up to the entire MS MARCO
passage ranking task with a corpus of 8.8M
passages and evaluating model sizes up to 11B
parameters. We uncover several findings about
scaling generative retrieval to millions of pas-
sages; notably, the central importance of using
synthetic queries as document representations
during indexing, the ineffectiveness of existing
proposed architecture modifications when ac-
counting for compute cost, and the limits of
naively scaling model parameters with respect
to retrieval performance. While we find that
generative retrieval is competitive with state-
of-the-art dual encoders on small corpora, scal-
ing to millions of passages remains an impor-
tant and unsolved challenge. We believe these
findings will be valuable for the community to
clarify the current state of generative retrieval,
highlight the unique challenges, and inspire
new research directions.
1 Introduction
For the last several years, dual encoders (Gillick
et al., 2018; Karpukhin et al ., 2020; Ni et al ., 2022b;
Chen et al ., 2022) have dominated the landscape
for first-stage information retrieval. They model
relevance by mapping queries and documents into
the same embedding space, optimized via con-
trastive learning (Hadsell et al ., 2006; Gao et al .,
∗Equal Contribution.
†Work completed while a Student Researcher at Google.2021). Dense embeddings are pre-computed for
all documents in a corpus and stored in an external
index. This allows for fast approximate nearest
neighbor search (Vanderkam et al ., 2013; John-
son et al ., 2021) to retrieve relevant documents.
Cross-encoders based on large Transformer mod-
els (Nogueira et al ., 2019b, 2020; Pradeep et al .,
2021b) often function on top of these retrieved doc-
uments to further refine the top results.
Recently, the emerging paradigm of genera-
tive retrieval (De Cao et al ., 2020; Tay et al .,
2022) sought to replace this entire process
with a single sequence-to-sequence Transformer
model (Sutskever et al ., 2014; Vaswani et al ., 2017),
showing promising results against dual encoders
given a sufficiently small corpus size. Since then,
various techniques, such as (Zhuang et al ., 2022b;
Bevilacqua et al ., 2022; Zhou et al ., 2022; Wang
et al ., 2022; Chen et al ., 2023), have aimed to
improve the effectiveness of generative retrieval
models, either with alternative document identifier
formulations, architecture changes, or training ob-
jectives. Such work, however, has only evaluated
generative retrieval over relatively small corpora on
the order of 100k documents, such as Natural Ques-
tions (Kwiatkowski et al ., 2019), TriviaQA (Joshi
et al., 2017), or small subsets of the MS MARCO
document ranking task (Nguyen et al ., 2016). De-
spite these research contributions, a number of
open questions remain unanswered, including how
well current generative retrieval techniques work
on larger corpora and which aspects of generative
retrieval models proposed so far are vital at scale.
In this paper, we conduct the first empirical
study of generative retrieval techniques over the
entire MS MARCO passage-level corpus, evaluat-
ing its effectiveness over 8.8M passages. We select
popular approaches in recent works and evaluate
them first on Natural Questions and TriviaQA to
establish a definitive ablation of techniques in a
controlled setup. Our experiments mainly focus
1arXiv:2305.11841v1 [cs.IR] 19 May 2023 |
10.1016.j.bpj.2017.10.028.pdf | Article
Coevolutionary Landscape of Kinase Family
Proteins: Sequence Probabilities and FunctionalMotifs
Allan Haldane,1William F. Flynn,1,2Peng He,1and Ronald M. Levy1,*
1Center for Biophysics and Computational Biology, Department of Chemistry, and Institute for Computational Molecular Science, Temple
University, Philadelphia, Pennsylvania and2Department of Physics and Astronomy, Rutgers, The State University of New Jersey, Piscataway,
New Jersey
ABSTRACT The protein kinase catalytic domain is one of the most abundant domains across all branches of life. Although
kinases share a common core function of phosphoryl-transfer, they also have wide functional diversity and play varied rolesin cell signaling networks, and for this reason are implicated in a number of human diseases. This functional diversity is primarily
achieved through sequence variation, and uncovering the sequence-function relationships for the kinase family is a major chal-
lenge. In this study we use a statistical inference technique inspired by statistical physics, which builds a coevolutionary ‘‘Potts’’Hamiltonian model of sequence variation in a protein family. We show how this model has sufficient power to predict the prob-
ability of specific subsequences in the highly diverged kinase family, which we verify by comparing the model’s predictions with
experimental observations in the Uniprot database. We show that the pairwise (residue-residue) interaction terms of the statis-tical model are necessary and sufficient to capture higher-than-pairwise mutation patterns of natural kinase sequences. Weobserve that previously identified functional sets of residues have much stronger correlated interaction scores than are typical.
INTRODUCTION
About 2% of the human genome belongs to the protein
kinase family and over 105different kinases have been
sequenced from many species ( 1). Protein kinases’ common
catalytic role in protein phosphorylation is carried out by aconserved catalytic structural motif, but individual kinasesare specialized to phosphorylate particular substrates andare bound by different regulatory partners as part of cell
signaling networks. Kinases are implicated in many human
diseases, and understanding how a particular kinase’ssequence determines its individual function has clinicalapplications. The ability to predict the sequence-dependenteffect of specific mutations is relevant for the treatment ofkinase-related cancers ( 2), and understanding the differ-
ences in functionality between kinases can aid in selectivedrug design ( 3).
One approach to understanding the effects of particular
kinase sequence variations has been by structural analysis,based on thousands of observed kinase crystal structuresand comparison of their sequences. Patterns of structuralvariation and conservation within and between protein
kinase subfamilies has led to the identification of variousfunctional motifs such as the HRD and DFG motifs neces-sary for catalysis, networks of stabilizing interactionsformed in the kinase active catalytic state known as theC-spine and R-spine, and the importance of the C and Fhelices in acting as rigid foundations on which the catalytic
core rests ( 4–10 ). Two conformational states, the catalyti-
cally active ‘‘DFG-in’’ and the inactive ‘‘DFG-out’’ stateshave been discovered to be important in controlling kinaseactivation and regulation ( 11). An important goal of these
studies is to understand the sequence-dependent ligand-binding properties of different kinases for therapeuticpurposes; however, ligand binding affinities are still difficultto predict ( 12–15 ), and crystal structures only give a partial
view of kinase function.
Another way to extract information about function from
kinase sequence variation is to construct a statistical (Potts)model from a multiple sequence alignment (MSA) ofsequences collected from many organisms. The idea of us-ing sequence statistics to understand protein structure andfunction has been motivated and justified by the observationthat strongly covarying positions in an MSA correspond
well to contacts in structure, a fact used for protein contact
Submitted March 20, 2017, and accepted for publication October 17, 2017.
*Correspondence: ronlevy@temple.edu
Editor: Nathan Baker.
Biophysical Journal 114, 21–31, January 9, 2018 21https://doi.org/10.1016/j.bpj.2017.10.028
/C2112017 Biophysical Society. |
2024.04.22.590591v1.full.pdf | Design of highly functional genome editors by
modeling the universe of CRISPR-Cas sequences
Jeffrey A. Ruffolo1,*, Stephen Nayfach1,*, Joseph Gallagher1,*, Aadyot Bhatnagar1,*, Joel Beazer1, Riffat Hussain1, Jordan
Russ1, Jennifer Yip1, Emily Hill1, Martin Pacesa1,2, Alexander J. Meeske1,3, Peter Cameron1, and Ali Madani1,†
1Profluent Bio, Berkeley, CA, USA;2Laboratory of Protein Design and Immunoengineering, École Polytechnique Fédérale de Lausanne and Swiss Institute of Bioinformatics,
Lausanne, Switzerland;3Department of Microbiology, University of Washington, Seattle, WA, USA
Gene editing has the potential to solve fundamental challenges in agriculture, biotechnology, and human health. CRISPR-based gene editors
derived from microbes, while powerful, often show significant functional tradeoffs when ported into non-native environments, such as human
cells. Artificial intelligence (AI) enabled design provides a powerful alternative with potential to bypass evolutionary constraints and generate
editors with optimal properties. Here, using large language models (LLMs) trained on biological diversity at scale, we demonstrate the first
successful precision editing of the human genome with a programmable gene editor designed with AI. To achieve this goal, we curated a
dataset of over one million CRISPR operons through systematic mining of 26 terabases of assembled genomes and meta-genomes. We
demonstrate the capacity of our models by generating 4.8x the number of protein clusters across CRISPR-Cas families found in nature and
tailoring single-guide RNA sequences for Cas9-like effector proteins. Several of the generated gene editors show comparable or improved
activity and specificity relative to SpCas9, the prototypical gene editing effector, while being 400 mutations away in sequence. Finally, we
demonstrate an AI-generated gene editor, denoted as OpenCRISPR-1, exhibits compatibility with base editing. We release OpenCRISPR-1
publicly to facilitate broad, ethical usage across research and commercial applications.
genome editing |large language models |protein design
Introduction
Genome editing technologies, including those derived from prokaryotic CRISPR-Cas systems, have rev-
olutionized life science research and are poised to transform medicine and agriculture. Single-protein
CRISPR-Cas effectors, including the widely-adopted Cas9 nuclease from Streptococcus pyogenes (SpCas9),
have been utilized in biotechnology owing to their simplicity, robustness, and compact form. In order to
diversify the CRISPR toolbox and expand editing capabilities, new systems have been mined across diverse
microbial and viral genomes. While these novel systems have been sought for specific properties, such
as small size or extended protein stability in biofluids ( 1,2), they typically exhibit trade-offs in critical
attributes such as basal activity in target cells, PAM selectivity, thermal optima, or in vitro biochemical
properties, ultimately limiting their reach (2–5).
Repurposed CRISPR systems have been optimized for biotechnology using a range of protein engineering
approaches, including directed evolution and structure-guided mutagenesis. Directed evolution of Cas
proteins has proven extremely powerful yet can be limited by the rugged and non-convex nature of the
fitness landscapes ( 6–9), along with the difficulty of implementing selection-based screening in human cells.
Structure-guided rational mutagenesis offers an alternative or synergistic approach that has proven successful
for improving Cas9 basal activity and specificity in human cells ( 10–13). Similar results may be achievable
with structure-conditioned protein sequence design models ( 14,15), which learn the mapping from structure
to sequence from data. However, both of these approaches are dependent on explicit structural hypotheses,
either in the form of mechanistic understanding for rational mutagenesis or solved structures representing
key functional states for computational design, which are difficult to obtain for functions more complex
than simple binding interactions.
Protein language models eschew explicit structural hypotheses and instead learn the co-evolutionary
*These authors contributed equally to this work
†To whom correspondence should be addressed. E-mail: ali@profluent.bio
April 21, 2024 |1–S17. CC-BY-NC-ND 4.0 International license available under awas not certified by peer review) is the author/funder, who has granted bioRxiv a license to display the preprint in perpetuity. It is made The copyright holder for this preprint (which this version posted April 22, 2024. ; https://doi.org/10.1101/2024.04.22.590591doi: bioRxiv preprint |
2208.11970.pdf | Understanding Diffusion Models: A Unified Perspective
Calvin Luo
Google Research, Brain Team
calvinluo@google.com
August 26, 2022
Contents
Introduction: Generative Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Background: ELBO, VAE, and Hierarchical VAE . . . . . . . . . . . . . . . . . . . . . . . . 2
Evidence Lower Bound . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Variational Autoencoders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Hierarchical Variational Autoencoders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Variational Diffusion Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Learning Diffusion Noise Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Three Equivalent Interpretations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Score-based Generative Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Guidance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Classifier Guidance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Classifier-Free Guidance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Closing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Introduction: Generative Models
Given observed samples xfrom a distribution of interest, the goal of a generative model is to learn to
modelits true data distribution p(x). Once learned, we can generate new samples from our approximate
model at will. Furthermore, under some formulations, we are able to use the learned model to evaluate the
likelihood of observed or sampled data as well.
Thereareseveralwell-knowndirectionsincurrentliterature, thatwewillonlyintroducebrieflyatahighlevel.
Generative Adversarial Networks (GANs) model the sampling procedure of a complex distribution, which
is learned in an adversarial manner. Another class of generative models, termed "likelihood-based", seeks
to learn a model that assigns a high likelihood to the observed data samples. This includes autoregressive
models, normalizing flows, and Variational Autoencoders (VAEs). Another similar approach is energy-based
modeling, in which a distribution is learned as an arbitrarily flexible energy function that is then normalized.
1arXiv:2208.11970v1 [cs.LG] 25 Aug 2022 |
2303.06296.pdf | STABILIZING TRANSFORMER TRAINING BY PREVENTING
ATTENTION ENTROPY COLLAPSE
A P REPRINT
Shuangfei Zhai∗, Tatiana Likhomanenko∗, Etai Littwin∗, Dan Busbridge∗, Jason Ramapuram∗,
Yizhe Zhang, Jiatao Gu, Josh Susskind
Apple
{szhai,antares,elittwin,dbusbridge,jramapuram,yizzhang,jgu32,jsusskind}@apple.com
March 14, 2023
ABSTRACT
Training stability is of great importance to Transformers. In this work, we investigate the training
dynamics of Transformers by examining the evolution of the attention layers. In particular, we track
the attention entropy for each attention head during the course of training, which is a proxy for
model sharpness. We identify a common pattern across different architectures and tasks, where low
attention entropy is accompanied by high training instability, which can take the form of oscillating
loss or divergence. We denote the pathologically low attention entropy, corresponding to highly
concentrated attention scores, as entropy collapse . As a remedy, we propose σReparam, a simple
and efficient solution where we reparametrize all linear layers with spectral normalization and an
additional learned scalar. We demonstrate that the proposed reparameterization successfully prevents
entropy collapse in the attention layers, promoting more stable training. Additionally, we prove a tight
lower bound of the attention entropy, which decreases exponentially fast with the spectral norm of
the attention logits, providing additional motivation for our approach. We conduct experiments with
σReparam on image classification, image self-supervised learning, machine translation, automatic
speech recognition, and language modeling tasks, across Transformer architectures. We show that
σReparam provides stability and robustness with respect to the choice of hyperparameters, going so
far as enabling training (a) a Vision Transformer to competitive performance without warmup, weight
decay, layer normalization or adaptive optimizers; (b) deep architectures in machine translation and
(c) speech recognition to competitive performance without warmup and adaptive optimizers.
Keywords Transformer, SSL, vision, NLP, MT, ASR, stability, attention
1 Introduction 3
2 Related Works 4
3 Method 5
3.1 Attention Entropy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.2σReparam . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
4 Experiments 6
4.1 Supervised Image Classification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
∗Equal contributionarXiv:2303.06296v1 [cs.LG] 11 Mar 2023 |
2005.12320.pdf | SCAN: Learning to Classify Images without
Labels
Wouter Van Gansbeke1⋆Simon Vandenhende1⋆Stamatios Georgoulis2
Marc Proesmans1Luc Van Gool1,2
1KU Leuven/ESAT-PSI2ETH Zurich/CVL, TRACE
Abstract. Can we automatically group images into semantically mean-
ingful clusters when ground-truth annotations are absent? The task of
unsupervised image classification remains an important, and open chal-
lenge in computer vision. Several recent approaches have tried to tackle
this problem in an end-to-end fashion. In this paper, we deviate from
recent works, and advocate a two-step approach where feature learning
and clustering are decoupled. First, a self-supervised task from represen-
tation learning is employed to obtain semantically meaningful features.
Second, we use the obtained features as a prior in a learnable cluster-
ing approach. In doing so, we remove the ability for cluster learning
to depend on low-level features, which is present in current end-to-end
learning approaches. Experimental evaluation shows that we outperform
state-of-the-art methods by large margins, in particular +26 .6% on CI-
FAR10, +25 .0% on CIFAR100-20 and +21 .3% on STL10 in terms of clas-
sification accuracy. Furthermore, our method is the first to perform well
on a large-scale dataset for image classification. In particular, we obtain
promising results on ImageNet, and outperform several semi-supervised
learning methods in the low-data regime without the use of any ground-
truth annotations. The code is made publicly available here .
Keywords: Unsupervised Learning, Self-Supervised Learning, Image
Classification, Clustering.
1 Introduction and prior work
Image classification is the task of assigning a semantic label from a predefined set
of classes to an image. For example, an image depicts a cat, a dog, a car, an air-
plane, etc., or abstracting further an animal, a machine, etc. Nowadays, this task
is typically tackled by training convolutional neural networks [28,44,19,53,47] on
large-scale datasets [11,30] that contain annotated images, i.e. images with their
corresponding semantic label. Under this supervised setup, the networks excel
at learning discriminative feature representations that can subsequently be clus-
tered into the predetermined classes. What happens, however, when there is no
access to ground-truth semantic labels at training time? Or going further, the
semantic classes, or even their total number, are not a priori known? The desired
⋆Authors contributed equallyarXiv:2005.12320v2 [cs.CV] 3 Jul 2020 |
2212.05339.pdf | Elixir: Train a Large Language Model on a Small
GPU Cluster
Haichen Huang
HPC-AI Technology Inc.
hhc@hpcaitech.comJiarui Fang∗
HPC-AI Technology Inc.
fangjr@hpcaitech.comHongxin Liu
HPC-AI Technology Inc.
liuhongxin@hpcaitech.com
Shenggui Li
HPC-AI Technology Inc.
lisg@hpcaitech.comYang You†
National University of Singapore
youy@comp.nus.edu.sg
Abstract
In recent years, large language models have achieved great success due to their
unprecedented size. However, training these models poses a challenge for most
researchers as it requires a substantial number of GPUs. To reduce GPU memory
usage, memory partitioning and memory offloading have been proposed. These
approaches eliminate memory redundancies and offload memory usage to the CPU
and NVMe memory, respectively, enabling training on small GPU clusters. How-
ever, directly deploying these solutions often leads to suboptimal efficiency. Only
experienced experts can unleash the full potential of hardware by carefully tuning
the distributed configuration. Thus, we present a novel solution, Elixir, which auto-
mates efficient large model training based on pre-runtime model profiling. Elixir
aims to identify the optimal combination of partitioning and offloading techniques
to maximize training throughput. In our experiments, Elixir significantly outper-
forms the current state-of-the-art baseline. Our optimal configuration achieves up
to a 3.4 ×speedup on GPT-2 models compared with SOTA solutions. We hope
that our work will benefit individuals who lack computing resources and expertise,
granting them access to large models1.
1 Introduction
The current success of deep learning (DL) is attributed to the rise of pre-trained large language
models (LLMs) [ 1,2,3,4,5,6,7,8]. LLMs are widely used not only in NLP applications such
as conversation, Q&A, and text generation, but also in multimodal tasks such as image generation
[9,10], and speech synthesis [ 11]. However, training LLMs remains challenging due to the growing
size of models and limited GPU memory. In the past five years, the largest dense models have
significantly increased in size, from 340 million parameters in BERT [ 1] to 540 billion parameters in
PaLM [ 7]. Exerting the power of the mixture-of-experts architecture [ 12], the number of parameters
in the largest sparse model [ 13] has exceeded 1 trillion. Meanwhile, GPU memory has only increased
to 80GB [14, 15].
To address the memory bottleneck, researchers have proposed distributed training techniques. Dis-
tributed data parallelism (DDP) divides input data and assigns each device to compute its partition
∗This work was done when Jiarui worked at HPC-AI Technology Inc.
†Dr. You is a faculty member at NUS. This work was done at HPC-AI Technology Inc.
1The beta version of Elixir is now available at https://github.com/hpcaitech/ColossalAI/tree/
feature/elixir
Preprint. Under review.arXiv:2212.05339v3 [cs.DC] 31 May 2023 |
2310.12442.pdf | Efficient Long-Range Transformers: You Need to Attend More,
but Not Necessarily at Every Layer
Qingru Zhang†∗, Dhananjay Ram⋄, Cole Hawkins⋄, Sheng Zha⋄, Tuo Zhao†
†Georgia Institute of Technology⋄Amazon Web Service
{qingru.zhang,tourzhao}@gatech.edu
{radhna,colehawk,zhasheng}@amazon.com
Abstract
Pretrained transformer models have demon-
strated remarkable performance across vari-
ous natural language processing tasks. These
models leverage the attention mechanism to
capture long- and short-range dependencies in
the sequence. However, the (full) attention
mechanism incurs high computational cost –
quadratic in the sequence length, which is not
affordable in tasks with long sequences, e.g.,
inputs with 8k tokens. Although sparse at-
tention can be used to improve computational
efficiency, as suggested in existing work, it
has limited modeling capacity and often fails
to capture complicated dependencies in long
sequences. To tackle this challenge, we pro-
pose MASFormer, an easy-to-implement trans-
former variant with Mixed Attention Spans.
Specifically, MASFormer is equipped with full
attention to capture long-range dependencies,
but only at a small number of layers. For the
remaining layers, MASformer only employs
sparse attention to capture short-range depen-
dencies. Our experiments on natural language
modeling and generation tasks show that a
decoder-only MASFormer model of 1.3B pa-
rameters can achieve competitive performance
to vanilla transformers with full attention while
significantly reducing computational cost (up
to 75%). Additionally, we investigate the ef-
fectiveness of continual training with long se-
quence data and how sequence length impacts
downstream generation performance, which
may be of independent interest.
1 Introduction
Pre-trained transformer models have manifested
superior performance in various natural language
processing tasks such as natural language modeling
(NLM) (Dai et al., 2019; Radford et al., 2019), natu-
ral language generation (NLG) (Brown et al., 2020)
and natural language understanding (NLU) (De-
vlin et al., 2019; Liu et al., 2019; He et al., 2021b).
∗Work was done during Qingru Zhang’s internship at
Amazon Web Service.These models leverage the attention mechanism
(Vaswani et al., 2017) to compute the dependency
score for each pair of tokens in an input sequence.
Some practical tasks require these transformer
models to handle long-sequence inputs like 8k to-
kens. For example, chatbot systems gather long-
term contexts of user interactions to generate infor-
mative texts (Roller et al., 2021). Summarization
for news, government reports, and academic papers
request models to take inputs of long sequences to
generate comprehensive summaries (Shaham et al.,
2022), otherwise models often miss important in-
formation. Note that typical transformer models
apply full attention to capture token dependencies
pair-wise. It leads to a quadratic time and space
complexity w.r.t. input length. However, such a
complexity is prohibitive for long sequences. In
particular, it incurs massive memory consumption
during the back propagation. For example, a trans-
former model with 250M parameters consumes
over 80G GPU memory when sequence length is
8k (Zuo et al., 2022).
To address this scalability issue, various ap-
proaches have been proposed to reduce the com-
plexity. One approach is sparse attention , which
restricts each token to attend a subset of tokens
based on predefined sparsity patterns (Beltagy et al.,
2020; Zaheer et al., 2020; Ainslie et al., 2020). For
instance, block sparse attention (Kitaev et al., 2020;
Ma et al., 2023) divides the input sequence into sev-
eral blocks, and only intra-block attention is per-
formed. Besides, sliding-window attention (Belt-
agy et al., 2020; Zaheer et al., 2020; Ainslie et al.,
2020) allows each token to attend to its neighboring
tokens within a sliding window. These methods,
though reducing the complexity of full attention,
cannot sufficiently capture long-range dependen-
cies. Other variants, such as kernel approximation
(Peng et al., 2021) and low-rank approximation
(Wang et al., 2020; Chen et al., 2021) methods,
share the similar spirit and drawbacks. To com-arXiv:2310.12442v1 [cs.CL] 19 Oct 2023 |
1703.03400.pdf | Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks
Chelsea Finn1Pieter Abbeel1 2Sergey Levine1
Abstract
We propose an algorithm for meta-learning that
is model-agnostic, in the sense that it is com-
patible with any model trained with gradient de-
scent and applicable to a variety of different
learning problems, including classification, re-
gression, and reinforcement learning. The goal
of meta-learning is to train a model on a vari-
ety of learning tasks, such that it can solve new
learning tasks using only a small number of train-
ing samples. In our approach, the parameters of
the model are explicitly trained such that a small
number of gradient steps with a small amount
of training data from a new task will produce
good generalization performance on that task. In
effect, our method trains the model to be easy
to fine-tune. We demonstrate that this approach
leads to state-of-the-art performance on two few-
shot image classification benchmarks, produces
good results on few-shot regression, and acceler-
ates fine-tuning for policy gradient reinforcement
learning with neural network policies.
1. Introduction
Learning quickly is a hallmark of human intelligence,
whether it involves recognizing objects from a few exam-
ples or quickly learning new skills after just minutes of
experience. Our artificial agents should be able to do the
same, learning and adapting quickly from only a few exam-
ples, and continuing to adapt as more data becomes avail-
able. This kind of fast and flexible learning is challenging,
since the agent must integrate its prior experience with a
small amount of new information, while avoiding overfit-
ting to the new data. Furthermore, the form of prior ex-
perience and new data will depend on the task. As such,
for the greatest applicability, the mechanism for learning to
learn (or meta-learning) should be general to the task and
1University of California, Berkeley2OpenAI. Correspondence
to: Chelsea Finn <cbfinn@eecs.berkeley.edu >.
Proceedings of the 34thInternational Conference on Machine
Learning , Sydney, Australia, PMLR 70, 2017. Copyright 2017
by the author(s).the form of computation required to complete the task.
In this work, we propose a meta-learning algorithm that
is general and model-agnostic, in the sense that it can be
directly applied to any learning problem and model that
is trained with a gradient descent procedure. Our focus
is on deep neural network models, but we illustrate how
our approach can easily handle different architectures and
different problem settings, including classification, regres-
sion, and policy gradient reinforcement learning, with min-
imal modification. In meta-learning, the goal of the trained
model is to quickly learn a new task from a small amount
of new data, and the model is trained by the meta-learner
to be able to learn on a large number of different tasks.
The key idea underlying our method is to train the model’s
initial parameters such that the model has maximal perfor-
mance on a new task after the parameters have been up-
dated through one or more gradient steps computed with
a small amount of data from that new task. Unlike prior
meta-learning methods that learn an update function or
learning rule (Schmidhuber, 1987; Bengio et al., 1992;
Andrychowicz et al., 2016; Ravi & Larochelle, 2017), our
algorithm does not expand the number of learned param-
eters nor place constraints on the model architecture (e.g.
by requiring a recurrent model (Santoro et al., 2016) or a
Siamese network (Koch, 2015)), and it can be readily com-
bined with fully connected, convolutional, or recurrent neu-
ral networks. It can also be used with a variety of loss func-
tions, including differentiable supervised losses and non-
differentiable reinforcement learning objectives.
The process of training a model’s parameters such that a
few gradient steps, or even a single gradient step, can pro-
duce good results on a new task can be viewed from a fea-
ture learning standpoint as building an internal representa-
tion that is broadly suitable for many tasks. If the internal
representation is suitable to many tasks, simply fine-tuning
the parameters slightly (e.g. by primarily modifying the top
layer weights in a feedforward model) can produce good
results. In effect, our procedure optimizes for models that
are easy and fast to fine-tune, allowing the adaptation to
happen in the right space for fast learning. From a dynami-
cal systems standpoint, our learning process can be viewed
as maximizing the sensitivity of the loss functions of new
tasks with respect to the parameters: when the sensitivity
is high, small local changes to the parameters can lead toarXiv:1703.03400v3 [cs.LG] 18 Jul 2017 |
Evolutionary-Principles-in-Self-Referential-Learning.pdf | Evolutionary Principles inSelf—Referential Learning
(Diploma Thesis)
Jargen Schmidhube:
Technische Universitat Miinchen
May 14, 1987
|
2211.03540.pdf | Measuring Progress on Scalable Oversight
for Large Language Models
Samuel R. Bowman∗, Jeeyoon Hyun, Ethan Perez,
Edwin Chen,†Craig Pettit,†Scott Heiner,†Kamil ˙e Lukoši ¯ut˙e,‡
Amanda Askell, Andy Jones, Anna Chen, Anna Goldie, Azalia Mirhoseini, Cameron McKinnon,
Christopher Olah, Daniela Amodei, Dario Amodei, Dawn Drain, Dustin Li, Eli Tran-Johnson,
Jack Clark, Jackson Kernion, Jamie Kerr, Jared Mueller, Jeffrey Ladish, Joshua Landau,
Kamal Ndousse, Liane Lovitt, Nelson Elhage, Nicholas Schiefer, Nicholas Joseph, Noemí Mercado,
Nova DasSarma, Robin Larson, Sam McCandlish, Sandipan Kundu, Scott Johnston,
Shauna Kravec, Sheer El Showk, Stanislav Fort, Timothy Telleen-Lawton, Tom Brown,
Tom Henighan, Tristan Hume, Yuntao Bai, Zac Hatfield-Dodds,
Ben Mann, and Jared Kaplan∗
Anthropic,†Surge AI,‡Independent Researcher
Abstract
Developing safe and useful general-purpose AI systems will require us to make progress
onscalable oversight : the problem of supervising systems that potentially outperform us
on most skills relevant to the task at hand. Empirical work on this problem is not straight-
forward, since we do not yet have systems that broadly exceed our abilities. This paper
discusses one of the major ways we think about this problem, with a focus on ways it can
be studied empirically. We first present an experimental design centered on tasks for which
human specialists succeed but unaided humans andcurrent general AI systems fail. We
then present a proof-of-concept experiment meant to demonstrate a key feature of this ex-
perimental design and show its viability with two question-answering tasks: MMLU and
time-limited QuALITY . On these tasks, we find that human participants who interact with
an unreliable large-language-model dialog assistant through chat—a trivial baseline strat-
egy for scalable oversight—substantially outperform both the model alone andtheir own
unaided performance. These results are an encouraging sign that scalable oversight will
be tractable to study with present models and bolster recent findings that large language
models can productively assist humans with difficult tasks.
1 Introduction
To build and deploy powerful AI responsibly, we will need to develop robust techniques for scalable over-
sight : the ability to provide reliable supervision—in the form of labels, reward signals, or critiques—to
models in a way that will remain effective past the point that models start to achieve broadly human-level
performance (Amodei et al., 2016). These techniques are likely to build on the methods we use today for
steering large models (like RLHF; Christiano et al., 2017; Stiennon et al., 2020), but will need to be further
developed to continue behaving as expected in regimes where models have important knowledge or capa-
∗Correspondence to: {sambowman,jared}@anthropic.com
The first and third blocks of authors are core contributors. Author contributions are detailed in §6. All authors conducted
this work while at Anthropic except where noted.arXiv:2211.03540v2 [cs.HC] 11 Nov 2022 |
2310.05869.pdf | HyperAttention: Long-context Attention in Near-Linear Time
Insu Han
Yale University
insu.han@yale.eduRajesh Jayaram
Google Research
rkjayaram@google.comAmin Karbasi
Yale University, Google Research
amin.karbasi@yale.edu
Vahab Mirrokni
Google Research
mirrokni@google.comDavid P. Woodruff
CMU, Google Research
dwoodruf@cs.cmu.eduAmir Zandieh
Independent Researcher
amir.zed512@gmail.com
Abstract
We present an approximate attention mechanism named “HyperAttention” to address the
computational challenges posed by the growing complexity of long contexts used in Large Lan-
guage Models (LLMs). Recent work suggests that in the worst-case scenario, quadratic time is
necessary unless the entries of the attention matrix are bounded or the matrix has low stable
rank. We introduce two parameters which measure: (1) the max column norm in the normalized
attention matrix, and (2) the ratio of row norms in the unnormalized attention matrix after de-
tecting and removing large entries. We use these fine-grained parameters to capture the hardness
of the problem. Despite previous lower bounds, we are able to achieve a linear time sampling
algorithm even when the matrix has unbounded entries or a large stable rank, provided the above
parameters are small. HyperAttention features a modular design that easily accommodates in-
tegration of other fast low-level implementations, particularly FlashAttention. Empirically, em-
ploying Locality Sensitive Hashing (LSH) to identify large entries, HyperAttention outperforms
existing methods, giving significant speed improvements compared to state-of-the-art solutions
like FlashAttention. We validate the empirical performance of HyperAttention on a variety of
different long-context length datasets. For example, HyperAttention makes the inference time
of ChatGLM2 50% faster on 32k context length while perplexity increases from 5.6 to 6.3. On
larger context length, e.g., 131k, with causal masking, HyperAttention offers 5-fold speedup on
a single attention layer.
1 Introduction
Transformers [29] have been successfully applied to a wide variety of learning tasks in areas such
as natural language processing [13, 30, 3, 26], computer vision [4, 15], and time series forecast-
ing [34]. Despite their success, these models face serious scalability limitations because na¨ ıve exact
computation of their attention layers incurs quadratic (in the sequence length) runtime and mem-
ory complexities. This presents a fundamental challenge for scaling transformer models to longer
context lengths.
1Empirical studies are conducted by I. Han and A. Zandieh.
2Codes are available at https://github.com/insuhan/hyper-attn .
1arXiv:2310.05869v3 [cs.LG] 1 Dec 2023 |
2310.13548.pdf | TOWARDS UNDERSTANDING
SYCOPHANCY IN LANGUAGE MODELS
Mrinank Sharma∗, Meg Tong∗, Tomasz Korbak, David Duvenaud
Amanda Askell, Samuel R. Bowman, Newton Cheng, Esin Durmus, Zac Hatfield-Dodds,
Scott R. Johnston, Shauna Kravec, Timothy Maxwell, Sam McCandlish, Kamal Ndousse,
Oliver Rausch, Nicholas Schiefer, Da Yan, Miranda Zhang ,
Ethan Perez
ABSTRACT
Reinforcement learning from human feedback (RLHF) is a popular technique for
training high-quality AI assistants. However, RLHF may also encourage model re-
sponses that match user beliefs over truthful responses, a behavior known as syco-
phancy. We investigate the prevalence of sycophancy in RLHF-trained models
and whether human preference judgments are responsible. We first demonstrate
that five state-of-the-art AI assistants consistently exhibit sycophancy behavior
across four varied free-form text-generation tasks. To understand if human prefer-
ences drive this broadly observed behavior of RLHF models, we analyze existing
human preference data. We find that when a response matches a user’s views,
it is more likely to be preferred. Moreover, both humans and preference mod-
els (PMs) prefer convincingly-written sycophantic responses over correct ones a
non-negligible fraction of the time. Optimizing model outputs against PMs also
sometimes sacrifices truthfulness in favor of sycophancy. Overall, our results in-
dicate that sycophancy is a general behavior of RLHF models, likely driven in part
by human preference judgments favoring sycophantic responses.
1 I NTRODUCTION
AI assistants such as GPT-4 (OpenAI, 2023) are typically trained to produce outputs that humans
rate highly, e.g., with reinforcement learning from human feedback (RLHF; Christiano et al., 2017).
Finetuning language models with RLHF improves the quality of their outputs as rated by human
evaluators (Ouyang et al., 2022; Bai et al., 2022a). However, some have hypothesized that training
schemes based on human preference judgments are liable to exploit human judgments in undesirable
ways, e.g., encouraging AI systems to produce outputs that appeal to human evaluators but are
actually flawed or incorrect (Cotra, 2021). In parallel, recent work has shown that RLHF-trained
models tend to provide answers that are in line with the user they are responding to, in proof-of-
concept evaluations where users state themselves as having a certain view (Perez et al., 2022; Wei
et al., 2023b; Turpin et al., 2023). However, it is unclear whether such failures occur in more varied
and realistic settings with production models, as well as whether such failures are indeed driven by
flaws in human preferences, as Cotra (2021) and Perez et al. (2022) hypothesize.
We therefore first investigate whether state-of-the-art AI assistants provide sycophantic model re-
sponses in a wide variety of realistic settings (§3). We identify consistent patterns of sycophancy
across five state-of-the-art RLHF-trained AI assistants in free-form text-generation tasks. Specifi-
cally, we demonstrate that these AI assistants frequently wrongly admit mistakes when questioned
by the user, give predictably biased feedback, and mimic errors made by the user. The consistency
of these empirical findings suggests sycophancy may indeed be a property of the way RLHF models
are trained, rather than an idiosyncratic detail of a particular system.
*Equal contribution. All authors are at Anthropic. Mrinank Sharma is also at the University of Oxford.
Meg Tong conducted this work as an independent researcher. Tomasz Korbak conducted this work while at
the University of Sussex and FAR AI. First and last author blocks are core contributors. Correspondence to
{mrinank,meg,ethan}@anthropic.com
1arXiv:2310.13548v1 [cs.CL] 20 Oct 2023 |
2005.11401.pdf | Retrieval-Augmented Generation for
Knowledge-Intensive NLP Tasks
Patrick Lewis†‡, Ethan Perez⋆,
Aleksandra Piktus†, Fabio Petroni†, Vladimir Karpukhin†, Naman Goyal†, Heinrich Küttler†,
Mike Lewis†, Wen-tau Yih†, Tim Rocktäschel†‡, Sebastian Riedel†‡, Douwe Kiela†
†Facebook AI Research;‡University College London;⋆New York University;
plewis@fb.com
Abstract
Large pre-trained language models have been shown to store factual knowledge
in their parameters, and achieve state-of-the-art results when fine-tuned on down-
stream NLP tasks. However, their ability to access and precisely manipulate knowl-
edge is still limited, and hence on knowledge-intensive tasks, their performance
lags behind task-specific architectures. Additionally, providing provenance for their
decisions and updating their world knowledge remain open research problems. Pre-
trained models with a differentiable access mechanism to explicit non-parametric
memory have so far been only investigated for extractive downstream tasks. We
explore a general-purpose fine-tuning recipe for retrieval-augmented generation
(RAG) — models which combine pre-trained parametric and non-parametric mem-
ory for language generation. We introduce RAG models where the parametric
memory is a pre-trained seq2seq model and the non-parametric memory is a dense
vector index of Wikipedia, accessed with a pre-trained neural retriever. We com-
pare two RAG formulations, one which conditions on the same retrieved passages
across the whole generated sequence, and another which can use different passages
per token. We fine-tune and evaluate our models on a wide range of knowledge-
intensive NLP tasks and set the state of the art on three open domain QA tasks,
outperforming parametric seq2seq models and task-specific retrieve-and-extract
architectures. For language generation tasks, we find that RAG models generate
more specific, diverse and factual language than a state-of-the-art parametric-only
seq2seq baseline.
1 Introduction
Pre-trained neural language models have been shown to learn a substantial amount of in-depth knowl-
edge from data [ 47]. They can do so without any access to an external memory, as a parameterized
implicit knowledge base [ 51,52]. While this development is exciting, such models do have down-
sides: They cannot easily expand or revise their memory, can’t straightforwardly provide insight into
their predictions, and may produce “hallucinations” [ 38]. Hybrid models that combine parametric
memory with non-parametric (i.e., retrieval-based) memories [ 20,26,48] can address some of these
issues because knowledge can be directly revised and expanded, and accessed knowledge can be
inspected and interpreted. REALM [ 20] and ORQA [ 31], two recently introduced models that
combine masked language models [ 8] with a differentiable retriever, have shown promising results,arXiv:2005.11401v4 [cs.CL] 12 Apr 2021 |
2304.07313.pdf | M2T: Masking Transformers Twice for Faster Decoding
Fabian Mentzer
Google Research
mentzer@google.comEirikur Agustsson
Google Research
eirikur@google.comMichael Tschannen
Google Research
tschannen@google.com
Abstract
We show how bidirectional transformers trained for
masked token prediction can be applied to neural image
compression to achieve state-of-the-art results. Such mod-
els were previously used for image generation by pro-
gressivly sampling groups of masked tokens according to
uncertainty-adaptive schedules. Unlike these works, we
demonstrate that predefined, deterministic schedules per-
form as well or better for image compression. This insight
allows us to use masked attention during training in ad-
dition to masked inputs, and activation caching during in-
ference, to significantly speed up our models ( ≈4×higher
inference speed) at a small increase in bitrate.
1. Introduction
Recently, transformers trained for masked token predic-
tion have successfully been applied to neural image and
video generation [11, 35]. In MaskGIT [11], the authors
use a VQ-GAN [16] to map images to vector-quantized to-
kens, and learn a transformer to predict the distribution of
these tokens. The key novelty of the approach was to use
BERT-like [13] random masks during training to then pre-
dict tokens in groups during inference, sampling tokens in
the same group in parallel at each inference step. Thereby,
each inference step is conditioned on the tokens generated
in previous steps. A big advantage of BERT-like training
with grouped inference versus prior state-of-the-art is that
considerably fewer steps are required to produce realistic
images (typically 10-20, rather than one per token).
These models are optimized to minimize the cross en-
tropy between the token distribution pmodeled by the trans-
former and the true (unknown) token distribution q, as mea-
sured via negative log likelihood (NLL). As is known from
information theory, this is equivalent to the bit cost required
to (losslessly) store a sample drawn from qwith a model
p[39]. Indeed, any model pthat predicts an explicit joint
distribution over tokens in a deterministic way can be turned
into a compression model by using pto entropy code the to-
kens, rather than sampling them.
0.1 0.2 0.3 0.4 0.5 bpp2628303234
PSNR on Kodak
Ours (MT)
Ours (M2T)
ELIC (He '22)
ContextFormer
(Koyuncu '22)
Devil-Details (Zou '22)
VTM
Entroformer (Qian '22)
Cheng '20
CHARM (Minnen '20)
Checkerboard (He '21)
MIM (El-Nouby '22)
BPG
JPEGFigure 1: Rate distortion results on Kodak. Our MTout-
performs the prior state-of-the-art ELIC [18]; M2T only in-
curs a small reduction in rate-distortion performance com-
pared to MT while running about 4×faster on hardware
(see Fig. 4)
Motivated by this, we aim to employ masked trans-
formers for neural image compression. Previous work has
used masked and unmasked transformers in the entropy
model for video compression [37, 25] and image compres-
sion [29, 22, 15]. However, these models are often ei-
ther prohibitively slow [22], or lag in rate-distortion per-
formance [29, 15]. In this paper, we show a conceptually
simple transformer-based approach that is state-of-the-art in
neural image compression, at practical runtimes. The model
is using off-the-shelf transformers, and does not rely on
special positional encodings or multi-scale factorizations,
in contrast to previous work. Additionally, we propose
a new variant combining ideas from MaskGIT-like input-
masked transformers and fully autoregressive attention-
masked transformers. The resulting model masks both the
input and attention layers, and allows us to substantially im-
prove runtimes at a small cost in rate-distortion.
To train masked transformers, the tokens to be masked
in each training step are usually selected uniformly at ran-
dom. During inference, the models are first applied to maskarXiv:2304.07313v1 [eess.IV] 14 Apr 2023 |
2303.15343v4.pdf | Sigmoid Loss for Language Image Pre-Training
Xiaohua Zhai⋆Basil Mustafa Alexander Kolesnikov Lucas Beyer⋆
Google DeepMind, Z ¨urich, Switzerland
{xzhai, basilm, akolesnikov, lbeyer }@google.com
Abstract
We propose a simple pairwise Sigmoid loss for
Language-Image Pre-training (SigLIP). Unlike standard
contrastive learning with softmax normalization, the sig-
moid loss operates solely on image-text pairs and does not
require a global view of the pairwise similarities for nor-
malization. The sigmoid loss simultaneously allows fur-
ther scaling up the batch size, while also performing bet-
ter at smaller batch sizes. Combined with Locked-image
Tuning, with only four TPUv4 chips, we train a SigLiT
model that achieves 84.5% ImageNet zero-shot accuracy
in two days. The disentanglement of the batch size from
the loss further allows us to study the impact of exam-
ples vs pairs and negative to positive ratio. Finally, we
push the batch size to the extreme, up to one million, and
find that the benefits of growing batch size quickly dimin-
ish, with a more reasonable batch size of 32 k being suf-
ficient. We release our models at https://github.
com/google-research/big_vision and hope our
research motivates further explorations in improving the
quality and efficiency of language-image pre-training.
1. Introduction
Contrastive pre-training using weak supervision from
image-text pairs found on the web is becoming the go-to
method for obtaining generic computer vision backbones,
slowly replacing pre-training on large labelled multi-class
datasets. The high-level idea is to simultaneously learn
an aligned representation space for images and texts using
paired data. Seminal works CLIP [36] and ALIGN [23] es-
tablished the viability of this approach at a large scale, and
following their success, many large image-text datasets be-
came available privately [59, 13, 21, 49] and publicly [40,
6, 15, 7, 41].
The standard recipe to pre-train such models leverages
the image-text contrastive objective. It aligns the image and
⋆equal contributionTable 1: SigLiT and SigLIP results . Sigmoid loss is mem-
ory efficient, allows larger batch sizes (BS) that unlocks
language image pre-training with a small number of chips.
SigLiT model with a frozen public
B/8 checkpoint [42],
trained on the LiT image-text dataset [59] using four TPU-
v4 chips for one day, achieves 79.7% 0-shot accuracy on
ImageNet. The same setup with a g/14 checkpoint [58]
leads to 84.5% accuracy, trained for two days. With a pub-
lic unlocked
B/16 image checkpoint [42], trained on the
WebLI dataset [13], SigLIP achieves 71.0% 0-shot accu-
racy using 16 TPU-v4 chips for three days. The last two
rows show results with randomly initialized models.
Image Text BS #TPUv4 Days INet-0
SigLiT
B/8 L∗32 k 4 1 79.8
SigLiT
g/14 L 20 k 4 2 84.5
SigLIP
B/16 B 16 k 16 3 71.0
SigLIP B/16 B 32 k 32 2 72.1
SigLIP B/16 B 32 k 32 5 73.4
∗We use a variant of the L model with 12 layers.
text embeddings for matching (positive) image-text pairs
while making sure that unrelated (negative) image-text pairs
are dissimilar in the embedding space. This is achieved via a
batch-level softmax-based contrastive loss, applied twice to
normalize the pairwise similarity scores across all images,
then all texts. A naive implementation of the softmax is
numerically unstable; it is usually stabilized by subtracting
the maximum input value before applying the softmax [18],
which requires another pass over the full batch.
In this paper, we propose a simpler alternative: the sig-
moid loss. It does not require any operation across the full
batch and hence greatly simplifies the distributed loss im-
plementation and boosts efficiency. Additionally, it con-
ceptually decouples the batch size from the definition of
the task. We compare the proposed sigmoid loss with the
standard softmax loss across multiple setups. In partic-
ular, we investigate sigmoid-based loss with two promi-
1 |
2404.11018v1.pdf | 2024-4-18
Many-Shot In-Context Learning
Rishabh Agarwal*, Avi Singh*, Lei M. Zhang†, Bernd Bohnet†, Stephanie Chan†, Ankesh Anand , Zaheer
Abbas , Azade Nova , John D. Co-Reyes , Eric Chu , Feryal Behbahani , Aleksandra Faust and Hugo Larochelle
*Contributed equally,†Core contribution
Largelanguagemodels(LLMs)excelatfew-shotin-contextlearning(ICL)–learningfromafewexamples
provided in context at inference, without any weight updates. Newly expanded context windows allow
us to investigate ICL with hundreds or thousands of examples – the many-shot regime. Going from
few-shot to many-shot, we observe significant performance gains across a wide variety of generative
and discriminative tasks. While promising, many-shot ICL can be bottlenecked by the available amount
of human-generated outputs. To mitigate this limitation, we explore two new settings: “Reinforced ICL”
and “Unsupervised ICL”. Reinforced ICL uses model-generated chain-of-thought rationales in place of
human rationales. Unsupervised ICL removes rationales from the prompt altogether, and prompts the
model only with domain-specific inputs. We find that both Reinforced and Unsupervised ICL can be quite
effective in the many-shot regime, particularly on complex reasoning tasks. Finally, we demonstrate
that, unlike few-shot learning, many-shot learning is effective at overriding pretraining biases and can
learn high-dimensional functions with numerical inputs. Our analysis also reveals the limitations of
next-token prediction loss as an indicator of downstream performance.
1. Introduction
SummarizationPlanning
(Logistics)Sequential Parity (20 digits)GPQA
Translation
Problem-solving (MATH)Classification (64 dim)Code Verifier Big-Bench
Hard (8 tasks)GSM8K
(Transfer)Sentiment
Analysis (FP)020406080100T ask Performance in %
(Gemini 1.5 Pro)
5-shot
1-shot
16-shot
5-shot
10-shot
4-shot
4-shot
4-shot
3-shot
4-shot
32-shot500-shot
800-shot
8192-shot
125-shot
997-shot
125-shot
512-shot
128-shot
50-shot
500-shot
2048-shot+5.0+15.0+36.4+9.2+4.2+7.9+21.0+5.0 +10.9+7.9+18.2Few-Shot ICL Many-Shot ICL
Figure 1|Many-shot vs Few-Shot In-Context Learning (ICL) across several tasks. Many-shot learning exhibits consistent
performance gains over few-shot ICL. This gain is especially dramatic for difficult non-natural language tasks like sequential
parity prediction and linear classification. Number of best-performing shots for many-shot ICL are shown inside the bar for
each task. For few-shot ICL, we either use typical number of shots used on a benchmark, for example, 4-shot for MATH, or
the longest prompt among the ones we tested with less than the GPT-3 context length of 2048 tokens. Reasoning-oriented
tasks, namely MATH, GSM8K, BBH, and GPQA uses human-generated chain-of-thought rationales. For translation, we report
performance FLORES-MT result on English to Kurdish, summarization uses XLSum, MATH corresponds to the MATH500
test set, and sentiment analysis results are reported with semantically-unrelated labels. See §3, §4, and §5 for more details.
Large language models (LLMs) have demonstrated a remarkable ability to perform in-context
learning (ICL): they can learn a new task just from input-output examples, also known as shots, which
precede a test input presented within the LLM context. However, an LLM’s context window, i.e. the
Corresponding author(s): rishabhagarwal@google.com, singhavi@google.com
©2024 Google DeepMind. All rights reservedarXiv:2404.11018v1 [cs.LG] 17 Apr 2024 |
2305.09836.pdf | Revisiting the Minimalist Approach to Offline
Reinforcement Learning
Denis Tarasov Vladislav Kurenkov Alexander Nikulin Sergey Kolesnikov
Tinkoff
{den.tarasov, v.kurenkov, a.p.nikulin, s.s.kolesnikov}@tinkoff.ai
Abstract
Recent years have witnessed significant advancements in offline reinforcement
learning (RL), resulting in the development of numerous algorithms with varying de-
grees of complexity. While these algorithms have led to noteworthy improvements,
many incorporate seemingly minor design choices that impact their effectiveness
beyond core algorithmic advances. However, the effect of these design choices
on established baselines remains understudied. In this work, we aim to bridge
this gap by conducting a retrospective analysis of recent works in offline RL and
propose ReBRAC, a minimalistic algorithm that integrates such design elements
built on top of the TD3+BC method. We evaluate ReBRAC on 51 datasets with
both proprioceptive and visual state spaces using D4RL and V-D4RL benchmarks,
demonstrating its state-of-the-art performance among ensemble-free methods in
both offline and offline-to-online settings. To further illustrate the efficacy of
these design choices, we perform a large-scale ablation study and hyperparameter
sensitivity analysis on the scale of thousands of experiments.1
1 Introduction
Interest of the reinforcement learning (RL) community in the offline setting has led to a myriad
of new algorithms specifically tailored to learning highly performant policies without the ability
to interact with an environment (Levine et al., 2020; Prudencio et al., 2022). Yet, similar to the
advances in online RL (Engstrom et al., 2020; Henderson et al., 2018), many of those algorithms
come with an added complexity – design and implementation choices beyond core algorithmic
innovations, requiring a delicate effort in reproduction, hyperparameter tuning, and causal attribution
of performance gains.
Indeed, the issue of complexity was already raised in the offline RL community by Fujimoto
& Gu (2021); the authors highlighted veiled design and implementation-level adjustments (e.g.,
different architectures or actor pre-training) and then demonstrated how a simple behavioral cloning
regularization added to the TD3 (Fujimoto et al., 2018) constitutes a strong baseline in the offline
setting. This minimalistic and uncluttered algorithm, TD3+BC, has become a de-facto standard
baseline to be compared against. Indeed, most new algorithms juxtapose against it and claim
significant gains over (Akimov et al., 2022; An et al., 2021; Nikulin et al., 2023; Wu et al., 2022;
Chen et al., 2022b; Ghasemipour et al., 2022). However, application of newly emerged design and
implementation choices to this baseline is still missing.
In this work, we build upon Fujimoto & Gu (2021) line of research and ask: what is the extent to which
newly emerged minor design choices can advance the minimalistic offline RL algorithm? The answer
is illustrated in Figure 1: we propose an extension to TD3+BC, ReBRAC (Section 3), that simply
adds on recently appeared design decisions upon it. We test our algorithm on both proprioceptive and
1Our implementation is available at https://github.com/DT6A/ReBRAC
37th Conference on Neural Information Processing Systems (NeurIPS 2023).arXiv:2305.09836v2 [cs.LG] 24 Oct 2023 |
2002.05202.pdf | arXiv:2002.05202v1 [cs.LG] 12 Feb 2020GLU Variants Improve Transformer
Noam Shazeer
Google
noam@google.com
February 14, 2020
Abstract
Gated Linear Units [ Dauphin et al. ,2016] consist of the component-wise product of two linear pro-
jections, one of which is first passed through a sigmoid funct ion. Variations on GLU are possible, using
different nonlinear (or even linear) functions in place of si gmoid. We test these variants in the feed-
forward sublayers of the Transformer [ Vaswani et al. ,2017] sequence-to-sequence model, and find that
some of them yield quality improvements over the typically- used ReLU or GELU activations.
1 Introduction
The Transformer [ Vaswani et al. ,2017] sequence-to-sequence model alternates between multi-he ad attention,
and what it calls "position-wise feed-forward networks" (F FN). The FFN takes a vector x(the hidden repre-
sentation at a particular position in the sequence) and pass es it through two learned linear transformations,
(represented by the matrices W1andW2and bias vectors b1andb2). A rectified-linear (ReLU) [ Glorot et al. ,
2011] activation function applied between the two linear transf ormations.
FFN( x, W 1, W2, b1, b2) = max(0 , xW 1+b1)W2+b2 (1)
Following the T5 codebase [ Raffel et al. ,2019]1, we use a version with no bias:
FFN ReLU(x, W 1, W2) = max( xW 1,0)W2 (2)
Subsequent work has proposed replacing the ReLU with other n onlinear activation functions such as
Gaussian Error Linear Units, GELU( x) =xΦ(x) [Hendrycks and Gimpel ,2016], and Swish β(x) =xσ(βx)
[Ramachandran et al. ,2017].
FFN GELU (x, W 1, W2) = GELU( xW 1)W2
FFN Swish(x, W 1, W2) = Swish 1(xW 1)W2(3)
2 Gated Linear Units (GLU) and Variants
[Dauphin et al. ,2016] introduced Gated Linear Units (GLU), a neural network laye r defined as the component-
wise product of two linear transformations of the input, one of which is sigmoid-activated. They also suggest
omitting the activation, which they call a "bilinear" layer and attribute to [ Mnih and Hinton ,2007].
GLU( x, W, V, b, c ) =σ(xW+b)⊗(xV+c)
Bilinear( x, W, V, b, c ) = ( xW+b)⊗(xV+c)(4)
We can also define GLU variants using other activation functi ons:
1Also in the interest of ML fairness.
1 |
978-3-642-41822-8-15.pdf | Auto-enco d er Based D ata C lustering
Chunfeng Song1,F e n gL i u2, Yongzhen Huang1, Liang Wang1, and Tieniu Tan1
1National Laboratory of Pattern Recognition (NLPR),
Institute of Automation, Chinese Academy of Sciences, Beijing, 100190, China
2School of Automation, Southeast University, Nanjing, 210096, China
Ab st r a c t . Linear or non-linear data transformations are widely used
processing techniques in clustering. Usually, they are beneficial to en-
hancing data representation. However, if data have a complex structure,
thesetechniqueswouldbeunsatisfyingforclustering.Inthispaper,basedon the auto-encoder network, which can learn a highly non-linear map-
ping function, we propose a new clustering method. Via simultaneously
considering datareconstruction andcompactness, ourmethod canobtainstableand effectiveclustering. Experimentsonthreedatabasesshow that
the proposed clustering model achieves excellent performance in terms
of both accuracy and normalized mutual information.
Ke y w ords: Clustering, Auto-encoder, Non-linear transformation.
1 I n t r o duct i on
Data clustering[4] isa basicprobleminpatternrecognition,whosegoalis group-
ing similar data into the same cluster. It attracts much attention and various
clustering methods have been presented, most of which either deal with the
original data, e.g., K-means [10], its linear transformation, e.g., spectral cluster-
ing[7],oritssimplenon-lineartransformation,e.g.,kernelK-means[2].However,
if original data are not well distributed due to large intra-variance as shown inthe left part of Figure 1, it would be difficult for traditionalclustering algorithms
to achieve satisfying performance.
To address the above problem, we attempt to map original data space to a
new space which is more suitable for clustering. The auto-encoder network [1]
is a good candidate to handle this problem. It provides a non-linear mapping
function by iteratively learning the en coder and the decoder. The encoder is ac-
tually the non-linear mapping function, and the decoder demands accurate data
reconstruction from the representatio n generated by the encoder. This process
is iterative, which guarantees that the mapping function is stable and effective
to represent the original da ta. Different from kernel K -means [2], which also in-
troduces non-linear transformations with fixed kernel functions, the non-linearfunction in auto-encoder is learned by optimizing an objective function.
The auto-encoder network is originally designed for data representation, and
it aims to minimize the reconstruction error. However, to the best of our knowl-edge, though widely used, the auto-en coder network has not been utilized for
J. Ru iz -S h u lc lop e r a n d G. S a n n i ti d i B a j a (E d s .): C IARP 2013, P a rt I, LNC S 8258, p p . 117–124, 2013.
c⃝ Spring e r- V e rla g B e rlin He ide l b e rg 201 3 |
sutskever10a.pdf | 789On the Convergence Properties of Contrastive Divergence
Ilya Sutskever Tijmen Tieleman
University of Toronto University of Toronto
Abstract
Contrastive Divergence (CD) is a popular
method for estimating the parameters of
Markov Random Fields (MRFs) by rapidly
approximating an intractable term in the gra-
dient of the log probability. Despite CD’s
empirical success, little is known about its
theoretical convergence properties.
In this paper, we analyze the CD 1up-
date rule for Restricted Boltzmann Machines
(RBMs) with binary variables. We show that
this update is not the gradient of any func-
tion, and construct a counterintuitive “regu-
larization function” that causes CD learning
to cycle indefinitely. Nonetheless, we show
that the regularized CD update has a fixed
point for a large class of regularization func-
tions using Brower’s fixed point theorem.
1 INTRODUCTION
Markov Random Fields (MRFs) are an important class
of probabilistic models that are useful for denoising,
prediction, and density estimation (Cross and Jain,
1981; Malfait and Roose, 1997; Portilla et al., 2003;
Roth and Black, 2005; Li, 1994; Wainwright, 2008). In
particular, MRFs subsume the Restricted Boltzmann
Machines (RBMs) (Hinton, 2002; Smolensky, 1986),
which are essential for learning Deep Belief Networks
(Hinton et al., 2006; Bengio et al., 2007; Hinton and
Salakhutdinov, 2006).
Nearly every application of MRFs requires estimating
their parameters from data. The natural maximum-
likelihood parameter estimation is challenging, be-
cause the log probability’s gradient is the difference
of two expectations, of which one cannot be easily
computed. As a result, a number of approximate
Appearing in Proceedings of the 13thInternational Con-
ference on Artificial Intelligence and Statistics (AISTATS)
2010, Chia Laguna Resort, Sardinia, Italy. Volume 9 of
JMLR: W&CP 9. Copyright 2010 by the authors.parameter estimation methods have been developed.
Pseudolikelihood (Besag, 1977) and Score Matching
(Hyvarinen, 2006) are tractable alternatives to the
log probability objective which are easier to optimize,
and Loopy Belief Propagation and its variants (Wain-
wright, 2008) directly approximate the intractable ex-
pectation in the gradient. This paper focuses on Con-
trastive Divergence (CD) (Hinton, 2002), which di-
rectly approximates the intractable expectation with
an easy Monte Carlo estimate. Being trivial to imple-
ment, CD is widely used (Hinton et al., 2006), but its
convergence properties are not entirely understood.
In this paper we gain a better understanding of the
noiseless CD 1update rule for binary RBMs, and report
the following results:
•We provide two proofs showing that the CD up-
date is not the gradient of any objective function.
This result was first proved by Tieleman (2007)
and stated by Bengio and Delalleau (2009).
•We construct an example of a nonconvex regu-
larization function that causes the CD update to
cycle indefinitely.
•The CD update is shown to have at least one fixed
point when used with L 2regularization.
2 RELATED WORK
There has been much work attempting to elucidate
the convergence properties of CD. Some of this work
shows that CD minimizes a known cost function when
used with specific Markov chains. For example, if
the Markov chain used to estimate the intractable
expectation (Hinton, 2002) is the Langevin Monte
Carlo method, then CD computes the gradient of the
score-matching objective function; similarly, when the
Markov chain samples a random component of the
data vector from its conditional distribution, then CD
becomes the gradient of the log pseudo-likelihood of
the model (Hyvarinen, 2007). Other work has pro-
vided general conditions under which CD converges to
the maximum likelihood solution (Yuille, 2004), which |
2306.02572.pdf | Les Houches Summer School Lecture Notes 2022 Preprint
Introduction to Latent Variable Energy-Based Models:
A Path Towards Autonomous Machine Intelligence
Anna Dawid1,2and Yann LeCun3,4⋆
1ICFO - Institut de Ciències Fotòniques, The Barcelona Institute of Science and Technology,
Av. Carl Friedrich Gauss 3, 08860 Castelldefels (Barcelona), Spain
2Faculty of Physics, University of Warsaw, Pasteura 5, 02-093 Warsaw, Poland
3Courant Institute of Mathematical Sciences, New York University
4Meta - Fundamental AI Research
⋆yann@cs.nyu.edu
June 6, 2023
Abstract
Current automated systems have crucial limitations that need to be addressed before
artificial intelligence can reach human-like levels and bring new technological revolu-
tions. Among others, our societies still lack Level 5 self-driving cars, domestic robots,
and virtual assistants that learn reliable world models, reason, and plan complex ac-
tion sequences. In these notes, we summarize the main ideas behind the architecture
of autonomous intelligence of the future proposed by Yann LeCun. In particular, we in-
troduce energy-based and latent variable models and combine their advantages in the
building block of LeCun’s proposal, that is, in the hierarchical joint embedding predictive
architecture (H-JEPA).
Contents
1 Introduction 2
2 Towards autonomous machine intelligence 3
2.1 Applications of machine learning today 3
2.2 Limitations of the current machine learning 4
2.3 New paradigm to autonomous intelligence 6
2.4 Self-supervised learning and representing uncertainty 7
2.5 Structure of the manuscript 8
3 Introduction to energy-based models 8
3.1 Energy-based models vs. probabilistic models 10
3.2 Latent variable energy-based models 11
4 Training an energy-based model 12
4.1 Contrastive methods 14
4.2 Architectural and regularized methods 16
5 Examples of energy-based models 17
5.1 Hopfield networks 17
5.2 Boltzmann machines 17
1arXiv:2306.02572v1 [cs.LG] 5 Jun 2023 |
2306.16922.pdf | THEEXPRESSIVE LEAKY MEMORY NEURON :
ANEFFICIENT AND EXPRESSIVE PHENOMENOLOGICAL
NEURON MODEL CANSOLVE LONG -HORIZON TASKS
Aaron Spieler1,2, Nasim Rahaman3,2, Georg Martius1,2, Bernhard Schölkopf2, and Anna Levina1,4
1University of Tübingen
2Max Planck Institute for Intelligent Systems, Tübingen
3Mila, Quebec AI Institute
4Max Planck Institute for Biological Cybernetics, Tübingen
ABSTRACT
Biological cortical neurons are remarkably sophisticated computational devices,
temporally integrating their vast synaptic input over an intricate dendritic tree,
subject to complex, nonlinearly interacting internal biological processes. A recent
study proposed to characterize this complexity by fitting accurate surrogate models
to replicate the input-output relationship of a detailed biophysical cortical pyramidal
neuron model and discovered it needed temporal convolutional networks (TCN)
with millions of parameters. Requiring these many parameters, however, could
be the result of a misalignment between the inductive biases of the TCN and
cortical neuron’s computations. In light of this, and with the aim to explore
the computational implications of leaky memory units and nonlinear dendritic
processing, we introduce the Expressive Leaky Memory (ELM) neuron model, a
biologically inspired phenomenological model of a cortical neuron. Remarkably, by
exploiting a few such slowly decaying memory-like hidden states and two-layered
nonlinear integration of synaptic input, our ELM neuron can accurately match
the aforementioned input-output relationship with under ten-thousand trainable
parameters. To further assess the computational ramifications of our neuron design,
we evaluate on various tasks with demanding temporal structures, including the
Long Range Arena (LRA) datasets, as well as a novel neuromorphic dataset based
on the Spiking Heidelberg Digits dataset (SHD-Adding). Leveraging a larger
number of memory units with sufficiently long timescales, and correspondingly
sophisticated synaptic integration, the ELM neuron proves to be competitive on
both datasets, reliably outperforming the classic Transformer or Chrono-LSTM
architectures on latter, even solving the Pathfinder-X task with over 70% accuracy
(16k context length). These findings indicate the importance of inductive biases
for efficient surrogate neuron models and the potential for biologically motivated
models to enhance performance in challenging machine learning tasks.
1 I NTRODUCTION
The human brain has impressive computational capabilities, yet the precise mechanisms underpinning
them remain largely undetermined. Two complementary directions are pursued in search of
mechanisms for brain computations. On the one hand, many researchers investigate how these
capabilities could arise from the collective activity of neurons connected into a complex network
structure Maass (1997); Gerstner & Kistler (2002); Grüning & Bohte (2014), where individual
neurons might be as basic as leaky integrators or ReLU neurons. On the other hand, it has been
proposed that the intrinsic computational power possessed by individual neurons Koch (1997); Koch
& Segev (2000); Silver (2010) contributes a significant part to the computations.
Even though most work focuses on the former hypothesis, an increasing amount of evidence indicates
that cortical neurons are remarkably sophisticated Silver (2010); Gidon et al. (2020); Larkum (2022),
1arXiv:2306.16922v2 [cs.NE] 10 Oct 2023 |
2004.04906.pdf | Dense Passage Retrieval for Open-Domain Question Answering
Vladimir Karpukhin∗, Barlas O ˘guz∗, Sewon Min†, Patrick Lewis,
Ledell Wu, Sergey Edunov, Danqi Chen‡, Wen-tau Yih
Facebook AI†University of Washington‡Princeton University
{vladk, barlaso, plewis, ledell, edunov, scottyih }@fb.com
sewon@cs.washington.edu
danqic@cs.princeton.edu
Abstract
Open-domain question answering relies on ef-
ficient passage retrieval to select candidate
contexts, where traditional sparse vector space
models, such as TF-IDF or BM25, are the de
facto method. In this work, we show that
retrieval can be practically implemented us-
ingdense representations alone, where em-
beddings are learned from a small number
of questions and passages by a simple dual-
encoder framework. When evaluated on a
wide range of open-domain QA datasets, our
dense retriever outperforms a strong Lucene-
BM25 system greatly by 9%-19% absolute in
terms of top-20 passage retrieval accuracy, and
helps our end-to-end QA system establish new
state-of-the-art on multiple open-domain QA
benchmarks.1
1 Introduction
Open-domain question answering (QA) (V oorhees,
1999) is a task that answers factoid questions us-
ing a large collection of documents. While early
QA systems are often complicated and consist of
multiple components (Ferrucci (2012); Moldovan
et al. (2003), inter alia ), the advances of reading
comprehension models suggest a much simplified
two-stage framework: (1) a context retriever first
selects a small subset of passages where some
of them contain the answer to the question, and
then (2) a machine reader can thoroughly exam-
ine the retrieved contexts and identify the correct
answer (Chen et al., 2017). Although reducing
open-domain QA to machine reading is a very rea-
sonable strategy, a huge performance degradation
is often observed in practice2, indicating the needs
of improving retrieval.
∗Equal contribution
1The code and trained models have been released at
https://github.com/facebookresearch/DPR.
2For instance, the exact match score on SQuAD v1.1 drops
from above 80% to less than 40% (Yang et al., 2019a).Retrieval in open-domain QA is usually imple-
mented using TF-IDF or BM25 (Robertson and
Zaragoza, 2009), which matches keywords effi-
ciently with an inverted index and can be seen
as representing the question and context in high-
dimensional, sparse vectors (with weighting). Con-
versely, the dense , latent semantic encoding is com-
plementary to sparse representations by design. For
example, synonyms or paraphrases that consist of
completely different tokens may still be mapped to
vectors close to each other. Consider the question
“Who is the bad guy in lord of the rings?” , which can
be answered from the context “Sala Baker is best
known for portraying the villain Sauron in the Lord
of the Rings trilogy. ” A term-based system would
have difficulty retrieving such a context, while
a dense retrieval system would be able to better
match “bad guy” with “villain” and fetch the cor-
rect context. Dense encodings are also learnable
by adjusting the embedding functions, which pro-
vides additional flexibility to have a task-specific
representation. With special in-memory data struc-
tures and indexing schemes, retrieval can be done
efficiently using maximum inner product search
(MIPS) algorithms (e.g., Shrivastava and Li (2014);
Guo et al. (2016)).
However, it is generally believed that learn-
ing a good dense vector representation needs a
large number of labeled pairs of question and con-
texts. Dense retrieval methods have thus never
be shown to outperform TF-IDF/BM25 for open-
domain QA before ORQA (Lee et al., 2019), which
proposes a sophisticated inverse cloze task (ICT)
objective, predicting the blocks that contain the
masked sentence, for additional pretraining. The
question encoder and the reader model are then fine-
tuned using pairs of questions and answers jointly.
Although ORQA successfully demonstrates that
dense retrieval can outperform BM25, setting new
state-of-the-art results on multiple open-domainarXiv:2004.04906v3 [cs.CL] 30 Sep 2020 |
427986745-768441298640104-1604906292521363076-n.pdf | Revisiting Feature Prediction for Learning Visual
Representations from Video
Adrien Bardes1,2,3,Quentin Garrido1,4,Jean Ponce3,5,6,Xinlei Chen1,Michael Rabbat1,Yann LeCun1,5,6,
Mahmoud Assran1,†,Nicolas Ballas1,†
1FAIR at Meta,2Inria,3École normale supérieure, CNRS, PSL Research University,4Univ. Gustave Eiffel,
CNRS, LIGM,5Courant Institute, New York University,6Center for Data Science, New York University
†Joint last author
This paper explores feature prediction as a stand-alone objective for unsupervised learning from video and
introduces V-JEPA, a collection of vision models trained solely using a feature prediction objective, without
the use of pretrained image encoders, text, negative examples, reconstruction, or other sources of supervision.
The models are trained on 2 million videos collected from public datasets and are evaluated on downstream
image and video tasks. Our results show that learning by predicting video features leads to versatile visual
representations that perform well on both motion and appearance-based tasks, without adaption of the
model’s parameters; e.g., using a frozen backbone. Our largest model, a ViT-H/16 trained only on videos,
obtains 81.9%on Kinetics-400, 72.2%on Something-Something-v2, and 77.9%on ImageNet1K.
Date:February 14, 2024
Correspondence: {abardes, massran, ballasn}@meta.com
Code:https://github.com/facebookresearch/jepa
Blogpost: Click here
1 Introduction
Humans possess the remarkable ability to map low-level
signals originating from the retina into a semantic spatio-
temporal understanding of the world; synthesizing no-
tions such as objects and global motion (Spelke et al.,
1995). A long-standing goal of the machine learning
community is to identify the principles or objectives that
may guide such unsupervised learning in humans (Field,
1994; Berkes and Wiskott, 2005; Hinton, 1989). One
related hypothesis is based on the predictive feature
principle (Rao and Ballard, 1999), which posits that
representations of temporally adjacent sensory stimuli
should be predictive of each other.
In this work, we revisit feature prediction as a stand-
alone objective for unsupervised learning of visual repre-
sentations from video. Numerous advances in the field —
such as the standard use of transformer architectures in
vision (Dosovitskiy et al., 2020), the maturing of masked
autoencoding frameworks (Xie et al., 2021; Bao et al.,
2021; He et al., 2021), query-based feature pooling (Chen
et al., 2022), joint-embedding predictive architectures
(JEPA) (LeCun, 2022; Assran et al., 2023; Baevski et al.,
2022b), and larger datasets — form a unique arsenal of
tools, which we integrate in a modern and conceptually
simple method, the video joint-embedding predictive ar-
chitecture orV-JEPA, which is based solely on feature
prediction, without using pretrained image encoders,
text, negative examples, human annotations, or pixel-
70727476788082848688909240506070SOTA fine-tuned task-specific
model on SSv 2(MVD)
SOTA fine-tuned
task-specific model
on K 400 (UniFormer)ViT-L/ 16V-JEPA
ViT-H/ 16
DINOv 2
ViT-g/ 14
OpenCLIP
ViT-G/ 14I-JEPA
ViT-H/ 16Hiera
Hiera-HVideoMAE
ViT-H/ 16
VideoMAEv 2
ViT-g/ 14OmniMAE
ViT-H/ 16
Kinetics 400Something-Something-v 2Frozen Evaluation
Video Feature Pred.
Video Pixel Pred.
Image ModelsFigure 1V-JEPA models pretrained on video learn versatile
visual representations. It performs well on motion-based
tasks (Something-Something-v2) and appearance-based tasks
(Kinetics 400) without adaptation of the model’s parameters,
i.e., using the same frozen backbone for both tasks.
level reconstruction.
We seek to answer the simple question:
How effective is feature prediction as a stand-
alone objective for unsupervised learning from
video with modern tools?
1 |
2206.02326.pdf | arXiv:2206.02326v1 [cs.LG] 6 Jun 2022Asymptotic Instance-Optimal Algorithms for Interactive D ecision
Making
Kefan Dong
Stanford University
kefandong@stanford.eduTengyu Ma
Stanford University
tengyuma@stanford.edu
June 7, 2022
Abstract
Past research on interactive decision making problems (ban dits, reinforcement learning, etc.) mostly focuses on
the minimax regret that measures the algorithm’s performan ce on the hardest instance. However, an ideal algorithm
should adapt to the complexity of a particular problem insta nce and incur smaller regrets on easy instances than
worst-case instances. In this paper, we design the first asym ptotic instance-optimal algorithm for general interactiv e
decision making problems with finite number of decisions und er mild conditions. On every instancef, our algorithm
outperforms allconsistent algorithms (those achieving non-trivial regre ts on all instances), and has asymptotic regret
C(f)lnn, whereC(f)is an exact characterization of the complexity of f. The key step of the algorithm involves
hypothesis testing with active data collection. It compute s the most economical decisions with which the algorithm
collects observations to test whether an estimated instanc e is indeed correct; thus, the complexity C(f)is the mini-
mum cost to test the instance fagainst other instances. Our results, instantiated on conc rete problems, recover the
classical gap-dependent bounds for multi-armed bandits [ Lai and Robbins ,1985 ] and prior works on linear bandits
[Lattimore and Szepesvari ,2017 ], and improve upon the previous best instance-dependent up per bound [ Xu et al. ,
2021 ] for reinforcement learning.
1 Introduction
Bandit and reinforcement learning (RL) algorithms demonst rated a wide range of successful real-life applications
[Silver et al. ,2016 ,2017 ,Mnih et al. ,2013 ,Berner et al. ,2019 ,Vinyals et al. ,2019 ,Mnih et al. ,2015 ,Degrave et al. ,
2022 ]. Past works have theoretically studied the regret or sampl e complexity of various interactive decision making
problems, such as contextual bandits, reinforcement learn ing (RL), partially observable Markov decision process
(seeAzar et al. [2017 ],Jin et al. [2018 ],Dong et al. [2021 ],Li et al. [2019 ],Agarwal et al. [2014 ],Foster and Rakhlin
[2020 ],Jin et al. [2020 ], and references therein). Recently, Foster et al. [2021 ] present a unified algorithmic principle
for achieving the minimax regret—the optimal regret for the worst-case problem instances.
However, minimax regret bounds do not necessarily always pr esent a full picture of the statistical complexity of
the problem. They characterize the complexity of the most di fficult instances, but potentially many other instances are
much easier. An ideal algorithm should adapt to the complexi ty of a particular instance and incur smaller regrets on
easy instances than the worst-case instances. Thus, an idea l regret bound should be instance-dependent, that is, de-
pending on some properties of each instance. Prior works des igned algorithms with instance-dependent regret bounds
that are stronger than minimax regret bounds, but they are of ten not directly comparable because they depend on differ-
ent properties of the instances, such as the gap conditions a nd the variance of the value function [ Zanette and Brunskill ,
2019 ,Xu et al. ,2021 ,Foster et al. ,2020 ,Tirinzoni et al. ,2021 ].
A more ambitious and challenging goal is to design instance-optimal algorithms that outperform, on every instance,
allconsistent algorithms (those achieving non-trivial regre ts on all instances). Past works designed instance-optimal
algorithms for multi-armed bandit [ Lai and Robbins ,1985 ], linear bandits [ Kirschner et al. ,2021 ,Hao et al. ,2020 ],
Lipschitz bandits [ Magureanu et al. ,2014 ], and ergodic MDPs [ Ok et al. ,2018 ]. However, instance-optimal regret
bounds for tabular reinforcement learning remain an open qu estion, despite recent progress [ Tirinzoni et al. ,2021 ,
1 |
2205.05131.pdf | UL2: Unifying Language Learning Paradigms
Yi Tay∗Mostafa Dehghani∗
Vinh Q. Tran♯Xavier Garcia♯Jason Wei♯Xuezhi Wang♯Hyung Won Chung♯
Siamak Shakeri♯Dara Bahri♭Tal Schuster♭Huaixiu Steven Zheng△
Denny Zhou△Neil Houlsby△Donald Metzler△
Google Brain
Abstract
Existing pre-trained models are generally geared towards a particular class of problems. To date, there
seemstobestillnoconsensusonwhattherightarchitectureandpre-trainingsetupshouldbe. Thispaper
presents a unified framework for pre-training models that are universally effective across datasets and
setups. We begin by disentangling architectural archetypes with pre-training objectives – two concepts
thatarecommonlyconflated. Next,wepresentageneralizedandunifiedperspectiveforself-supervision
inNLPandshowhowdifferentpre-trainingobjectivescanbecastasoneanotherandhowinterpolating
between different objectives can be effective. We then propose Mixture-of-Denoisers (MoD), a pre-training
objective that combines diverse pre-training paradigms together. We furthermore introduce a notion of
mode switching, wherein downstream fine-tuning is associated with specific pre-training schemes. We
conductextensiveablativeexperimentstocomparemultiplepre-trainingobjectivesandfindthatourmethod
pushes the Pareto-frontier by outperforming T5 and/or GPT-like models across multiple diverse setups.
Finally,byscalingourmodelupto20Bparameters,weachieveSOTAperformanceon50well-established
supervisedNLPtasksrangingfromlanguagegeneration(withautomatedandhumanevaluation),language
understanding, text classification, question answering, commonsense reasoning, long text reasoning, struc-
tured knowledge grounding and information retrieval. Our model also achieve strong results at in-context
learning,outperforming175BGPT-3(publishedpaperresults)onzero-shotSuperGLUEandtriplingthe
performance of T5-XXL on one-shot summarization. On zero-shot MMLU, UL2 20B outperforms T0 and T5
models. Additionally,weshowthatUL220Bworkswellwithchain-of-thoughtpromptingandreasoning,
making it an appealing choice for research into reasoning at a small to medium scale of 20B parameters.
Finally,weapplyFLANinstructiontuningtotheUL220Bmodel,achievingMMLUandBig-Benchscores
competitive to FLAN-PaLM 62B. We release Flax-based T5X model checkpoints for the UL2 20B model and
Flan-UL2 20B model at https://github.com/google-research/google-research/tree/master/ul2 .
∗Yi and Mostafa are co-leads of this project and are denoted with∗.♯denotes technical research contributors. ♭denotes data &
infrastructure contributions.△denotes advising contributions. Don, denoted with□is the last author. Full contributions of all authors
at the end of paper. Correspondence to yitay@google.com ordehghani@google.com .
1arXiv:2205.05131v3 [cs.CL] 28 Feb 2023 |
2304.01373.pdf | Pythia : A Suite for Analyzing Large Language Models
Across Training and Scaling
Stella Biderman* 1 2Hailey Schoelkopf* 1 3Quentin Anthony1Herbie Bradley1 4Kyle O’Brien1
Eric Hallahan1Mohammad Aflah Khan5Shivanshu Purohit6 1USVSN Sai Prashanth1Edward Raff2
Aviya Skowron1Lintang Sutawika1 7Oskar van der Wal8
Abstract
How do large language models (LLMs) develop
and evolve over the course of training? How do
these patterns change as models scale? To an-
swer these questions, we introduce Pythia , a suite
of 16 LLMs all trained on public data seen in
the exact same order and ranging in size from
70M to 12B parameters. We provide public ac-
cess to 154 checkpoints for each one of the 16
models, alongside tools to download and recon-
struct their exact training dataloaders for further
study. We intend Pythia to facilitate research in
many areas, and we present several case stud-
ies including novel results in memorization, term
frequency effects on few-shot performance, and
reducing gender bias. We demonstrate that this
highly controlled setup can be used to yield novel
insights toward LLMs and their training dynam-
ics. Trained models, analysis code, training
code, and training data can be found at https:
//github.com/EleutherAI/pythia .
1. Introduction
Over the past several years, large transformer models have
established themselves as the premier methodology for gen-
erative tasks in natural language processing (Brown et al.,
2020; Sanh et al., 2021; Chowdhery et al., 2022). Beyond
NLP, transformers have also made big splashes as genera-
tive models in areas as diverse as text-to-image synthesis
(Ramesh et al., 2022; Crowson et al., 2022; Rombach et al.,
*Equal contribution1EleutherAI2Booz Allen Hamilton,
McLean, USA3Yale University, New Haven, USA4University of
Cambridge, UK5Indraprastha Institute of Information Technology
Delhi, India6Stability AI7Datasaur.ai, USA8Institute for Logic,
Language and Computation, University of Amsterdam, Nether-
lands. Correspondence to: Stella Biderman <stella@eleuther.ai >,
Hailey Schoelkopf <hailey@eleuther.ai >.
Proceedings of the 40thInternational Conference on Machine
Learning , Honolulu, Hawaii, USA. PMLR 202, 2023. Copyright
2023 by the author(s).2022), protein modeling (Jumper et al., 2021; Ahdritz et al.,
2022), and computer programming (Chen et al., 2021; Xu
et al., 2022; Fried et al., 2022). Despite these successes,
very little is known about how and why these models are so
successful.
Critical to understanding the functioning of transformers
is better understanding how these models behave along
two axes: training and scaling. It is well established that
there are regular and predictable patterns in the behavior of
trained language models as they scale (Kaplan et al., 2020;
Henighan et al., 2020; Hernandez et al., 2021; Mikami et al.,
2021; Pu et al., 2021; Sharma & Kaplan, 2020; Ghorbani
et al., 2021), but prior work connecting these “Scaling Laws”
to the learning dynamics of language models is minimal.
One of the driving reasons for this gap in research is a lack
of access to appropriate model suites to test theories: al-
though there are more publicly available LLMs than ever,
they do not meet common requirements for researchers, as
discussed in Section 2 of this paper. Of the research along
these lines that does exist (McGrath et al., 2021; Tirumala
et al., 2022; Xia et al., 2022), it is overwhelmingly done on
non-public models or model checkpoints, further emphasiz-
ing the importance of having publicly available model suites
for scientific research.
In this paper we introduce Pythia , a suite of decoder-only
autoregressive language models ranging from 70M to 12B
parameters designed specifically to facilitate such scientific
research. The Pythia suite is the only publicly released suite
of LLMs that satisfies three key properties:
1.Models span several orders of magnitude of model
scale.
2.All models were trained on the same data in the same
order.
3.The data and intermediate checkpoints are publicly
available for study.
We train 8 model sizes each on both the Pile (Gao et al.,
2020; Biderman et al., 2022) and the Pile after deduplication,
providing 2 copies of the suite which can be compared.
1arXiv:2304.01373v2 [cs.CL] 31 May 2023 |
2306.14846.pdf | ViNT: A Foundation Model for Visual Navigation
Dhruv Shah†, Ajay Sridhar†, Nitish Dashora†,
Kyle Stachowicz, Kevin Black, Noriaki Hirose, Sergey Levine
UC Berkeley
Abstract: General-purpose pre-trained models (“foundation models”) have en-
abled practitioners to produce generalizable solutions for individual machine
learning problems with datasets that are significantly smaller than those required
for learning from scratch. Such models are typically trained on large and diverse
datasets with weak supervision, consuming much more training data than is avail-
able for any individual downstream application. In this paper, we describe the
Visual Navigation Transformer (ViNT), a foundation model that aims to bring
the success of general-purpose pre-trained models to vision-based robotic navi-
gation. ViNT is trained with a general goal-reaching objective that can be used
with any navigation dataset, and employs a flexible Transformer-based architec-
ture to learn navigational affordances and enable efficient adaptation to a variety
of downstream navigational tasks. ViNT is trained on a number of existing naviga-
tion datasets, comprising hundreds of hours of robotic navigation from a variety of
different robotic platforms, and exhibits positive transfer , outperforming special-
ist models trained on narrower datasets. ViNT can be augmented with diffusion-
based goal proposals to explore novel environments, and can solve kilometer-scale
navigation problems when equipped with long-range heuristics. ViNT can also be
adapted to novel task specifications with a technique inspired by prompt-tuning,
where the goal encoder is replaced by an encoding of another task modality (e.g.,
GPS waypoints or turn-by-turn directions) embedded into the same space of goal
tokens. This flexibility and ability to accommodate a variety of downstream prob-
lem domains establish ViNT as an effective foundation model for mobile robotics.
Training Data Zero-Shot Deployment
ViNT Foundation Model
Adapt to Downstream T asks
Kilometer-Scale Exploration
Route-Guided Navigation
Coverage Mapping
Figure 1: Overview of the ViNT foundation model. ViNT generalizes zero-shot across environments and
robot embodiments, and can be directly applied to tasks including exploration and navigation around humans.
ViNT can also be fine-tuned with a small amount of data to expand its capabilities to new tasks.
1 Introduction
Recently, machine learning methods have achieved broad success in natural language processing [1],
visual perception [2–4], and other domains [5, 6] by leveraging Internet-scale data to train general-
purpose “foundation” models that can be adapted to new tasks by zero-shot transfer, prompt-tuning,
or fine-tuning on target data [7–10]. Although this paradigm has been successful in many domains,
it is difficult to apply in robotics due to the sheer diversity of environments, platforms, and applica-
tions. In this paper we ask the question: what is required of a foundation model for mobile robotics?
†Lead Authors. Videos, code, and models: general-navigation-models.github.io.
7th Conference on Robot Learning (CoRL 2023), Atlanta, USA.arXiv:2306.14846v2 [cs.RO] 24 Oct 2023 |
2207.08286.pdf | An Overview of Distant Supervision for Relation Extraction with a Focus
on Denoising and Pre-training Methods
William P Hogan
Department of Computer Science & Engineering
University of California, San Diego
Abstract
Relation Extraction (RE) is a foundational
task of natural language processing. RE
seeks to transform raw, unstructured text into
structured knowledge by identifying relational
information between entity pairs found in
text. RE has numerous uses, such as knowl-
edge graph completion, text summarization,
question-answering, and search querying. The
history of RE methods can be roughly or-
ganized into four phases: pattern-based RE,
statistical-based RE, neural-based RE, and
large language model-based RE. This survey
begins with an overview of a few exemplary
works in the earlier phases of RE, highlight-
ing limitations and shortcomings to contex-
tualize progress. Next, we review popular
benchmarks and critically examine metrics
used to assess RE performance. We then dis-
cuss distant supervision, a paradigm that has
shaped the development of modern RE meth-
ods. Lastly, we review recent RE works focus-
ing on denoising and pre-training methods.
1 Introduction
Relation extraction (RE), a subtask of information
extraction, is a foundational task in natural lan-
guage processing (NLP). The RE task is to deter-
mine a relationship between two distinct entities
from text, producing fact triples in the form [ head ,
relation ,tail] or, as referred to in some works, [ sub-
ject,predicate ,object ]. For example, after reading
the Wikipedia page on Noam Chomsky, we learn
that Noam was born in Philadelphia, Pennsylvania,
which corresponds to the fact triple [ Noam Chom-
sky,born in ,Philadelphia ]. Fact triples are foun-
dational to human knowledge and play a key role
in many downstream NLP tasks such as question-
answering, search queries, and knowledge-graph
completion (Xu et al., 2016; Lin et al., 2015; Li
et al., 2014).
Figure 1: A sample of relation labels generated by dis-
tant supervision. A knowledge graph, here a small snip-
pet from WikiData (Vrande ˇci´c and Kr ¨otzsch, 2014), is
paired with sentences to label instances of relations
linking an entity pair.
Distant supervision for relation extraction is a
method that pairs a knowledge graph—a graph of
entities connected by edges labeled with relation
classes—with an unstructured corpus to generate la-
beled data automatically (Mintz et al., 2009). First,
entities from the knowledge graph are identified in
the text, and then the following assumption is made:
all sentences containing an entity pair express the
corresponding relation class, as determined by the
accompanying knowledge graph. Figure 1 pro-
vides an example of automatically generated re-
lation labels pairing a knowledge graph, namely
WikiData (Vrande ˇci´c and Kr ¨otzsch, 2014), with
raw sentences.
Formally, the problem statement for distantly su-arXiv:2207.08286v1 [cs.CL] 17 Jul 2022 |
2210.10760.pdf | Scaling Laws for Reward Model Overoptimization
Leo Gao
OpenAIJohn Schulman
OpenAIJacob Hilton
OpenAI
Abstract
In reinforcement learning from human feedback, it is common to optimize against
a reward model trained to predict human preferences. Because the reward model
is an imperfect proxy, optimizing its value too much can hinder ground truth
performance, in accordance with Goodhart’s law. This effect has been frequently
observed, but not carefully measured due to the expense of collecting human
preference data. In this work, we use a synthetic setup in which a fixed “gold-
standard” reward model plays the role of humans, providing labels used to train a
proxy reward model. We study how the gold reward model score changes as we
optimize against the proxy reward model using either reinforcement learning or
best-of-nsampling. We find that this relationship follows a different functional
form depending on the method of optimization, and that in both cases its coefficients
scale smoothly with the number of reward model parameters. We also study the
effect on this relationship of the size of the reward model dataset, the number of
reward model and policy parameters, and the coefficient of the KL penalty added
to the reward in the reinforcement learning setup. We explore the implications of
these empirical results for theoretical considerations in AI alignment.
1 Introduction
Goodhart’s law is an adage that states, “When a measure becomes a target, it ceases to be a good
measure.” In machine learning, this effect arises with proxy objectives provided by static learned
models, such as discriminators and reward models. Optimizing too much against such a model
eventually hinders the true objective, a phenomenon we refer to as overoptimization . It is important to
understand the size of this effect and how it scales, in order to predict how much a learned model can
be safely optimized against. Moreover, studying this effect empirically could aid in the development
of theoretical models of Goodhart’s law for neural networks, which could be critical for avoiding
dangerous misalignment of future AI systems.
In this work, we study overoptimization in the context of large language models fine-tuned as
reward models trained to predict which of two options a human will prefer. Such reward models
have been used to train language models to perform a variety of complex tasks that are hard to
judge automatically, including summarization [Stiennon et al., 2020], question-answering [Nakano
et al., 2021, Menick et al., 2022], and general assistance [Ouyang et al., 2022, Bai et al., 2022,
Glaese et al., 2022]. Typically, the reward model score is optimized using either policy gradient-
based reinforcement learning or best-of- nsampling, also known as rejection sampling or reranking.
Overoptimization can occur with both methods, and we study both to better understand whether and
how overoptimization behaves differently across both methods.
A major challenge in studying overoptimization in this context is the expense of collecting human
preference labels. A large number of labels are required to accurately estimate overall preference
probabilities, and this is exacerbated by small effect sizes and the need to take many measurements in
order to fit scaling laws. To overcome this, we use a synthetic setup that is described in Section 2, in
which labels are supplied by a “gold-standard” reward model (RM) instead of humans.
Preprint. Under review.arXiv:2210.10760v1 [cs.LG] 19 Oct 2022 |
10.1038.s41588-023-01649-8.pdf | Nature Genetics | Volume 56 | March 2024 | 483–492
483
nature geneticshttps://doi.org/10.1038/s41588-023-01649-8
Article
In vitro reconstitution of chromatin domains
shows a role for nucleosome positioning in
3D genome organization
Elisa Oberbeckmann 1,4 , Kimberly Quililan2,3,4, Patrick Cramer1 &
A. Marieke Oudelaar 2
Eukaryotic genomes are organized into chromatin domains. The molecular
mechanisms driving the formation of these domains are difficult to dissect in vivo and remain poorly understood. Here we reconstitute Saccharomyces cerevisiae chromatin in vitro and determine its 3D organization at subnucleosome resolution by micrococcal nuclease-based chromosome conformation capture and molecular dynamics simulations. We show that regularly spaced and phased nucleosome arrays form chromatin domains in vitro that resemble domains in vivo. This demonstrates that neither loop extrusion nor transcription is required for basic domain formation in yeast. In addition, we find that the boundaries of reconstituted domains correspond to nucleosome-free regions and that insulation strength scales with their width. Finally, we show that domain compaction depends on nucleosome linker length, with longer linkers forming more compact structures. Together, our results demonstrate that regular nucleosome positioning is important for the formation of chromatin domains and provide a proof-of-principle for bottom-up 3D genome studies.
The spatial organization of the genome modulates nuclear processes,
including transcription, replication and DNA repair. Eukaryotic
genomes are organized into chromatin structures across different
scales. The smallest unit of chromatin is the nucleosome core parti-
cle, which consists of 147 base pairs (bp) of DNA wrapped around a
histone octamer1–3. Nucleosome core particles are connected by short
DNA ‘linkers’ and form nucleosome arrays, which further organize
into secondary structures that define the orientation of subsequent
nucleosomes with respect to each other. At a larger scale, eukaryotic
genomes organize into self-interacting domains. In mammals, these
domains are formed by at least two distinct mechanisms4. First, active
and inactive regions of chromatin form functionally distinct com -
partments that span a wide range of sizes5. Second, a process of loop
extrusion, mediated by cohesin and CCCTC binding factor (CTCF),
organizes the genome into local structures termed topologically associating domains (TADs), which usually range from 100 kbp to
1 Mbp in size6,7.
The higher-order organization of the genome into self-interacting
domains is conserved in eukaryotes with smaller genomes, includ -
ing Drosophila melanogaster8 and Saccharomyces cerevisiae9,10, in
which domain sizes range from 10 to 500 kbp and 2 to 10 kbp, respec -
tively. These domains are usually referred to with the general terms
chromatin domain, chromosomal domain or chromosomal interac -
tion domain8,10. This reflects that the nature of the domains in these
species and the mechanisms by which they are formed are less well
understood. Hereafter, we will therefore adopt the general term chro -
matin domain to refer to these domains. Because the boundaries of
chromatin domains in fly8,11,12 and yeast10,13 frequently overlap with
promoters of highly transcribed genes, it has been proposed that the
process of transcription or the transcriptional state of chromatin Received: 30 March 2023
Accepted: 15 December 2023
Published online: 30 January 2024
Check for updates
1Max Planck Institute for Multidisciplinary Sciences, Department of Molecular Biology, Göttingen, Germany. 2Max Planck Institute for Multidisciplinary
Sciences, Genome Organization and Regulation, Göttingen, Germany. 3Present address: The Francis Crick Institute, London, UK. 4These authors
contributed equally: Elisa Oberbeckmann, Kimberly Quililan. e-mail: elisa.oberbeckmann@mpinat.mpg.de; marieke.oudelaar@mpinat.mpg.de |
2306.01708.pdf | Resolving Interference When Merging Models
Prateek Yadav1Derek Tam1
Leshem Choshen2Colin Raffel1Mohit Bansal1
1University of North Carolina at Chapel Hill2IBM Research
leshem.choshen@il.ibm.com
{praty,dtredsox,craffel,mbansal}@cs.unc.edu
Abstract
Transfer learning – i.e., further fine-tuning a pre-trained model on a downstream
task – can confer significant advantages, including improved downstream perfor-
mance, faster convergence, and better sample efficiency. These advantages have
led to a proliferation of task-specific fine-tuned models, which typically can only
perform a single task and do not benefit from one another. Recently, model merging
techniques have emerged as a solution to combine multiple task-specific models
into a single multitask model without performing additional training. However,
existing merging methods often ignore the interference between parameters of
different models, resulting in large performance drops when merging multiple
models. In this paper, we demonstrate that prior merging techniques inadvertently
lose valuable information due to two major sources of interference: (a) interfer-
ence due to redundant parameter values and (b) disagreement on the sign of a
given parameter’s values across models. To address this, we propose our method,
TRIM, ELECT SIGN& M ERGE (TIES-MERGING ), which introduces three novel
steps when merging models: (1) resetting parameters that only changed a small
amount during fine-tuning, (2) resolving sign conflicts, and (3) merging only the
parameters that are in alignment with the final agreed-upon sign. We find that
TIES-MERGING outperforms several existing methods in diverse settings covering
a range of modalities, domains, number of tasks, model sizes, architectures, and
fine-tuning settings. We further analyze the impact of different types of interference
on model parameters, and highlight the importance of resolving sign interference.1
1 Introduction
Pre-trained models (PTMs) have become widespread in many real-world applications [ 83,6]. Using
PTMs typically involves fine-tuning them to specialize on a specific task [ 65,12], which can lead to
improved performance with less task-specific labeled data. These benefits have resulted in the release
of thousands of finetuned checkpoints [ 75] derived from popular PTMs such as ViT [ 14] for vision
and T5 [ 54] for language. However, having a separate fine-tuned model for each task has various
drawbacks: (1) for each new application, a separate model has to be stored and deployed [ 17,81], and
(2) models trained in isolation cannot leverage information from related tasks to improve in-domain
performance or out-of-domain generalization [ 62,54,70]. Multitask learning [ 62,53] could address
these concerns but requires costly training and simultaneous access to all tasks [ 17]. Moreover, it can
be complex and resource-intensive to determine how best to mix datasets to ensure that multitask
training is beneficial for all tasks [51, 50, 74, 48, 2, 17].
Recently, a growing body of research has focused on model merging [9,29,31,43,28,76]. One
application of merging involves combining multiple task-specific models into a single multitask
1Our code is available at https://github.com/prateeky2806/ties-merging
Preprint. Under review.arXiv:2306.01708v1 [cs.LG] 2 Jun 2023 |
2312.10003.pdf | REST MEETS REACT: S ELF-IMPROVEMENT FOR
MULTI -STEPREASONING LLM A GENT
Renat Aksitov†1, Sobhan Miryoosefi†1, Zonglin Li†1, Daliang Li†1, Sheila Babayan†2,
Kavya Kopparapu†2, Zachary Fisher1, Ruiqi Guo1, Sushant Prakash1, Pranesh Srinivasan3,
Manzil Zaheer2, Felix Yu1, and Sanjiv Kumar1
1Google Research,2Google DeepMind,3Google
†Core contributors
ABSTRACT
Answering complex natural language questions often necessitates multi-step rea-
soning and integrating external information. Several systems have combined
knowledge retrieval with a large language model (LLM) to answer such questions.
These systems, however, suffer from various failure cases, and we cannot directly
train them end-to-end to fix such failures, as interaction with external knowledge
is non-differentiable. To address these deficiencies, we define a ReAct-style LLM
agent with the ability to reason and act upon external knowledge. We further
refine the agent through a ReST-like method that iteratively trains on previous tra-
jectories, employing growing-batch reinforcement learning with AI feedback for
continuous self-improvement and self-distillation. Starting from a prompted large
model and after just two iterations of the algorithm, we can produce a fine-tuned
small model that achieves comparable performance on challenging compositional
question-answering benchmarks with two orders of magnitude fewer parameters.
1 I NTRODUCTION
Figure 1: Agent self-improvement and self-distillation.
Bamboogle auto-eval, mean accuracy and standard de-
viation over 10 runs, (%)For many simple natural language tasks,
like basic question-answering or summa-
rization, we can relatively easily decide
whether the final output is good or bad,
collect large amounts of such data, and
train the language models using these out-
comes as feedback. At the same time, for
more complex problems, outcome-based
systems are often insufficient, and a pro-
cess supervision approach has recently
gained much attention as a more promis-
ing alternative (Reppert et al. (2023)).
There is explosive growth in techniques
(Gao et al. (2023); Madaan et al. (2023)),
frameworks (Dohan et al. (2022); Khattab
et al. (2023b)), and libraries (Liu (2022),
Chase (2022)) for defining process-based
workflows with LLMs through human-understandable task decompositions. Many such decomposi-
tions involve interaction with external tools / APIs / environments, in which case the corresponding
multi-step workflow is generally referred to as an LLM agent (Xi et al. (2023)), a system capable of
performing a sequence of actions to achieve a goal.
Let’s consider the task of answering complex, open-ended questions, where the agent needs to use a
search API to look up multiple pieces of information before composing a paragraph-length answer.
One popular approach for building such agents with LLMs is the ReAct method (Yao et al., 2022),
which involves interleaving chain-of-thought reasoning with actions and observations during sev-
1arXiv:2312.10003v1 [cs.CL] 15 Dec 2023 |
2310.11564.pdf | PERSONALIZED SOUPS : PERSONALIZED LARGE
LANGUAGE MODEL ALIGNMENT VIA POST-HOC
PARAMETER MERGING
Joel Jang1,2Seungone Kim3Bill Yuchen Lin2Yizhong Wang1Jack Hessel2
Luke Zettlemoyer1Hannaneh Hajishirzi1,2Yejin Choi1,2Prithviraj Ammanabrolu4
1University of Washington2Allen Institute for AI3KAIST AI4UC San Diego
joeljang@cs.washington.edu
ABSTRACT
While Reinforcement Learning from Human Feedback (RLHF) aligns Large Lan-
guage Models (LLMs) with general, aggregate human preferences, it is subop-
timal for learning diverse, individual perspectives. In this work, we study Re-
inforcement Learning from Personalized Human Feedback (RL PHF) problem,
wherein LLMs are aligned to multiple (sometimes conflicting) preferences by
modeling alignment as a Multi-Objective Reinforcement Learning (MORL) prob-
lem. Compared to strong single-objective baselines, we show that we can achieve
personalized alignment by decomposing preferences into multiple dimensions.
These dimensions are defined based on personalizations that are declared as de-
sirable by the user. In this work, we show that they can be efficiently trained
independently in a distributed manner and combined effectively post-hoc through
parameter merging.1
1 I NTRODUCTION
Reinforcement Learning from Human Feedback (RLHF) (Nakano et al., 2021a; Ouyang et al.,
2022a; Bai et al., 2022a; Dubois et al., 2023; Bai et al., 2022b) typically optimizes a policy model
that receives training signals from a single reward model that aims to capture the general prefer-
ences of a population. In this work, we instead propose Reinforcement Learning from Personalized
Human Feedback (RL PHF), a new, multi-objective formulation of the human preference alignment
problem, where Large Language Models (LLMs) are trained to be efficiently aligned with a range
of different, potentially personalized combinations of human preferences.
We model RL PHF as a Multi-Objective Reinforcement Learning (MORL) problem, which allows
training the policy model with multiple, conflicting objectives since it aims to vary the importance
of each objective during inference. In existing RLHF formulations, pairwise human feedback is col-
lected by asking human annotators to choose which model response is generally better and is used
to train a general reward model. This makes implicit assumptions that may not hold for everyone.
For example, recent work has shown that LLMs aligned with RLHF prefer verbose output gener-
ations (Zheng et al., 2023; Dubois et al., 2023; Wang et al., 2023; Singhal et al., 2023). We aim
to support a wider range of multifaceted preferences that are explicitly declared as desirable by the
user—giving the user control over the facets of output text they want to see as well as the personal
data they wish to reveal to the model. We collect personalized human feedback corresponding to
multiple such dimensions, noting that they may also be conflicting in nature.
We first implement a strong MORL baseline called P ROMPTED -MORL where there are multiple
reward signals for each of the objectives (preferences) given via prompts during RL training. Next,
we propose P ERSONALIZED SOUPS , a method that circumvents simultaneously optimizing multiple
preferences by first optimizing multiple policy models each with distinct preferences with Proximal
Policy Optimization (PPO) and merging the parameters of the policy models whose preferences
we want to composite together on the fly during inference. This modular approach significantly
1Code: https://github.com/joeljang/RLPHF
1arXiv:2310.11564v1 [cs.CL] 17 Oct 2023 |
2401.05300.pdf | I am a Strange Dataset: Metalinguistic Tests for Language Models
Tristan Thrush§, Jared Moore§, Miguel Monares†‡, Christopher Potts§, Douwe Kiela§¶
§Stanford University; †UC San Diego; ‡Playtest AI; ¶Contextual AI
tthrush@stanford.edu
Abstract
Statements involving metalinguistic self-
reference (“This paper has six sections.”) are
prevalent in many domains. Can large language
models (LLMs) handle such language? In this
paper, we present “I am a Strange Dataset”,
a new dataset for addressing this question.
There are two subtasks: generation and
verification . In generation, models continue
statements like “The penultimate word in this
sentence is” (where a correct continuation is
“is”). In verification, models judge the truth
of statements like “The penultimate word in
this sentence is sentence.” (false). We also
provide minimally different metalinguistic
non-self-reference examples to complement
the main dataset by probing for whether
models can handle metalinguistic language
at all. The dataset is hand-crafted by experts
and validated by non-expert annotators. We
test a variety of open-source LLMs (7B to 70B
parameters) as well as closed-source LLMs
through APIs. All models perform close to
chance across both subtasks and even on the
non-self-referential metalinguistic control data,
though we find some steady improvement
with model scale. GPT 4 is the only model to
consistently do significantly better than chance,
and it is still only in the 60% range, while our
untrained human annotators score well in the
89–93% range. The dataset and evaluation
toolkit are available at https://github.com/
TristanThrush/i-am-a-strange-dataset .
1 Introduction
Self-reference plays a crucial role in the way we
think about mathematics (Gödel, 1931), theoretical
computer science (Church, 1936), recursive pro-
gramming (Hofstadter, 1979), philosophy (Tarski,
1931), understanding complex cases in hate speech
detection (Allan, 2017), aptitude tests (Propp,
1993), and comedy (Hofstadter, 1985). Some po-
sitions in the philosophy of mind consider self-
referential capabilities to be a key aspect of higher
P
No. if someone asks whether
this sentence has a capital
letter, the correct answer is
Figure 1: An example highlighting the challenge pre-
sented by our task. All models that we tested on our
dataset are close to chance-level.
intelligence or even consciousness (Hofstadter,
2007; Baars, 1993). Of course, self-reference is
also pervasive in how we communicate: at least
one paper you read today is bound to contain “In
this paper” (Thrush et al., 2024).
In this paper, we focus on metalinguistic self-
reference, the complex kind of self-reference in
which language is used to make claims about it-
self, as in “This sentence has five words” and “This
paper has six sections”.1Using such language in-
volves reasoning about metalinguistic properties
(counting words, naming parts of speech, etc.) and
resolving self-reference. Humans generally have
no trouble with such language, and may even enjoy
its playful and sometimes paradoxical nature (Hof-
stadter, 1979, 1985, 2007).
Recently, Large Language Models (LLMs) have
demonstrated striking cognitive capabilities (Rad-
ford et al., 2019; Brown et al., 2020; OpenAI, 2022,
2023; Anthropic, 2023; Touvron et al., 2023; Jiang
et al., 2023; Zhu et al., 2023). But do they have
the same mastery over metalinguistic self-reference
as we do? See Figure 1 for an example of the is-
sue that LLMs face. To help address this question,
we present a new task and dataset called “I am
a Strange Dataset”. We are inspired by Douglas
Hofstadter’s explorations of self-reference in lan-
guage (Hofstadter, 1979, 1985, 2007), and borrow
part of the name from one of his books: “I am a
Strange Loop” (Hofstadter, 2007).
1Sentences like “I am Douglas Hofstadter” are self-
referential but not metalinguistic in the sense of interest here.arXiv:2401.05300v1 [cs.CL] 10 Jan 2024 |
2306.00238.pdf | Bytes Are All You Need: Transformers Operating Directly On File Bytes
Maxwell Horton, Sachin Mehta, Ali Farhadi, Mohammad Rastegari
Apple
Abstract
Modern deep learning approaches usually transform
inputs into a modality-specific form. For example, the
most common deep learning approach to image classi-
fication involves decoding image file bytes into an RGB
tensor which is passed into a neural network. Instead,
we investigate performing classification directly on file
bytes, without the need for decoding files at inference
time. Using file bytes as model inputs enables the de-
velopment of models which can operate on multiple
input modalities. Our model, ByteFormer , achieves an
ImageNet Top-1 classification accuracy of 77.33% when
training and testing directly on TIFF file bytes using
a transformer backbone with configuration similar to
DeiT-Ti ( 72.2% accuracy when operating on RGB im-
ages). Without modifications or hyperparameter tuning,
ByteFormer achieves 95.42% classification accuracy when
operating on WAV files from the Speech Commands v2
dataset (compared to state-of-the-art accuracy of 98.7%).
Additionally, we demonstrate that ByteFormer has appli-
cations in privacy-preserving inference. ByteFormer is
capable of performing inference on particular obfuscated
input representations with no loss of accuracy. We also
demonstrate ByteFormer’s ability to perform inference
with a hypothetical privacy-preserving camera which
avoids forming full images by consistently masking 90%
of pixel channels, while still achieving 71.35% accu-
racy on ImageNet. Our code will be made available
at https://github.com/apple/ml-cvnets/
tree/main/examples/byteformer .
1. Introduction
Deep learning inference usually involves explicit model-
ing of the input modality. For example, Vision Transform-
ers (ViTs) [7] explicitly model the 2D spatial structure of
images by encoding image patches into vectors. Similarly,
audio inference often involves computing spectral features
(such as MFCCs [25]) to pass into a network [10, 18]. When
a user wants to perform inference on a file stored on disk
(e.g. a JPEG image file or an MP3 audio file), the user mustfirst decode the file into a modality-specific representation
(e.g. an RGB tensor or MFCCs), as in Figure 1a.
The practice of decoding inputs into a modality-specific
representation has two main drawbacks. First, it requires
hand-crafting an input representation and a model stem for
each input modality. Recent works such as PerceiverIO
[14] and UnifiedIO [24] have shown that Transformer back-
bones can be used for a variety of different tasks. However,
these methods still require modality-specific input prepro-
cessing. For instance, PerceiverIO decodes image files into
[H×W, C]tensors before passing them into the network.
Other modalities input to PerceiverIO are processed into
different forms. We hypothesize that it’s possible to remove
all modality-specific input preprocessing by performing in-
ference directly on file bytes.
The second drawback of decoding inputs into a
modality-specific representation is that it reduces privacy
by exposing the data being analyzed. Consider the case of a
smart-home device that performs inference on RGB images.
If an adversary accesses this model input, the user’s privacy
might be compromised. We hypothesize that inference can
instead be performed on privacy-preserving inputs.
To address these drawbacks, we note that a common
property of many input modalities is that they can be stored
as file bytes. Thus, we use file bytes (without any decoding)
as inputs to our model at inference time (Figure 1b). We
use a modified Transformer [39] architecture for our model,
given their ability to handle a variety of modalities [14, 24]
and variable-length inputs. We call our model ByteFormer.
We demonstrate the efficacy of ByteFormer on Ima-
geNet [6] classification, achieving 77.33% accuracy on files
stored in the TIFF format. Our model uses transformer
backbone hyperparameters chosen in DeiT-Ti [38] (which
achieves 72.2%accuracy on RGB inputs). We also demon-
strate strong results on PNG and JPEG files. Additionally,
we demonstrate that our classification model can achieve
95.8%accuracy on Speech Commands v2 [42], compara-
ble to state-of-the-art ( 98.7%) [18], without any architec-
ture changes or hyperparameter tuning .
Because ByteFormer can handle a variety of input rep-
resentations, we can also use it to operate on privacy-
preserving inputs. We demonstrate that we can remap in-arXiv:2306.00238v1 [cs.CV] 31 May 2023 |
2305.12387.pdf | Optimal Time Complexities of
Parallel Stochastic Optimization Methods
Under a Fixed Computation Model
Alexander Tyurin
KAUST
Saudi Arabia
alexandertiurin@gmail.comPeter Richt ´arik
KAUST
Saudi Arabia
richtarik@gmail.com
Abstract
Parallelization is a popular strategy for improving the performance of iterative
algorithms. Optimization methods are no exception: design of efficient parallel
optimization methods and tight analysis of their theoretical properties are important
research endeavors. While the minimax complexities are well known for sequential
optimization methods, the theory of parallel optimization methods is less explored.
In this paper, we propose a new protocol that generalizes the classical oracle frame-
work approach. Using this protocol, we establish minimax complexities for parallel
optimization methods that have access to an unbiased stochastic gradient oracle
with bounded variance. We consider a fixed computation model characterized
by each worker requiring a fixed but worker-dependent time to calculate stochas-
tic gradient. We prove lower bounds and develop optimal algorithms that attain
them. Our results have surprising consequences for the literature of asynchronous
optimization methods.
1 Introduction
We consider the nonconvex optimization problem
min
x∈Qn
f(x) :=Eξ∼D[f(x;ξ)]o
, (1)
where f:Rd×Sξ→R, Q⊆Rd,andξis a random variable with some distribution DonSξ.In
machine learning, Sξcould be the space of all possible data, Dis the distribution of the training
dataset, and f(·, ξ)is the loss of a data sample ξ.In this paper we address the following natural setup:
(i)nworkers are available to work in parallel,
(ii) the ithworker requires τiseconds1to calculate a stochastic gradient of f.
The function fisL–smooth and lower-bounded (see Assumptions 7.1–7.2), and stochastic gradients
are unbiased and σ2-variance-bounded (see Assumption 7.3).
1.1 Classical theory
In the nonconvex setting, gradient descent (GD) is an optimal method with respect to the number of
gradient ( ∇f) calls (Lan, 2020; Nesterov, 2018; Carmon et al., 2020) for finding an approximately
stationary point of f. Obviously, a key issue with GD is that it requires access to the exact gradients
1Or any other unit of time.
37th Conference on Neural Information Processing Systems (NeurIPS 2023).arXiv:2305.12387v2 [math.OC] 26 Nov 2023 |
2104.08821.pdf | SimCSE: Simple Contrastive Learning of Sentence Embeddings
Tianyu Gao†∗Xingcheng Yao‡∗Danqi Chen†
†Department of Computer Science, Princeton University
‡Institute for Interdisciplinary Information Sciences, Tsinghua University
{tianyug,danqic}@cs.princeton.edu
yxc18@mails.tsinghua.edu.cn
Abstract
This paper presents SimCSE, a simple con-
trastive learning framework that greatly ad-
vances state-of-the-art sentence embeddings.
We first describe an unsupervised approach,
which takes an input sentence and predicts
itself in a contrastive objective, with only
standard dropout used as noise. This simple
method works surprisingly well, performing
on par with previous supervised counterparts.
We find that dropout acts as minimal data aug-
mentation, and removing it leads to a repre-
sentation collapse. Then, we propose a super-
vised approach, which incorporates annotated
pairs from natural language inference datasets
into our contrastive learning framework by us-
ing “entailment” pairs as positives and “con-
tradiction” pairs as hard negatives. We evalu-
ate SimCSE on standard semantic textual simi-
larity (STS) tasks, and our unsupervised and
supervised models using BERT base achieve
an average of 76.3% and 81.6% Spearman’s
correlation respectively, a 4.2% and 2.2%
improvement compared to the previous best
results. We also show—both theoretically
and empirically—that the contrastive learning
objective regularizes pre-trained embeddings’
anisotropic space to be more uniform, and it
better aligns positive pairs when supervised
signals are available.1
1 Introduction
Learning universal sentence embeddings is a fun-
damental problem in natural language process-
ing and has been studied extensively in the litera-
ture (Kiros et al., 2015; Hill et al., 2016; Conneau
et al., 2017; Logeswaran and Lee, 2018; Cer et al.,
2018; Reimers and Gurevych, 2019, inter alia ).
In this work, we advance state-of-the-art sentence
*The first two authors contributed equally (listed in alpha-
betical order). This work was done when Xingcheng visited
the Princeton NLP group remotely.
1Our code and pre-trained models are publicly available at
https://github.com/princeton-nlp/SimCSE .embedding methods and demonstrate that a con-
trastive objective can be extremely effective when
coupled with pre-trained language models such as
BERT (Devlin et al., 2019) or RoBERTa (Liu et al.,
2019). We present SimCSE, a simplecontrastive
sentence embedding framework, which can pro-
duce superior sentence embeddings, from either
unlabeled or labeled data.
Ourunsupervised SimCSE simply predicts the
input sentence itself with only dropout (Srivastava
et al., 2014) used as noise (Figure 1(a)). In other
words, we pass the same sentence to the pre-trained
encoder twice : by applying the standard dropout
twice, we can obtain two different embeddings as
“positive pairs”. Then we take other sentences in
the same mini-batch as “negatives”, and the model
predicts the positive one among the negatives. Al-
though it may appear strikingly simple, this ap-
proach outperforms training objectives such as pre-
dicting next sentences (Logeswaran and Lee, 2018)
and discrete data augmentation (e.g., word dele-
tion and replacement) by a large margin, and even
matches previous supervised methods. Through
careful analysis, we find that dropout acts as mini-
mal “data augmentation” of hidden representations
while removing it leads to a representation collapse.
Oursupervised SimCSE builds upon the recent
success of using natural language inference (NLI)
datasets for sentence embeddings (Conneau et al.,
2017; Reimers and Gurevych, 2019) and incorpo-
rates annotated sentence pairs in contrastive learn-
ing (Figure 1(b)). Unlike previous work that casts
it as a 3-way classification task (entailment, neu-
tral, and contradiction), we leverage the fact that
entailment pairs can be naturally used as positive
instances. We also find that adding correspond-
ing contradiction pairs as hard negatives further
improves performance. This simple use of NLI
datasets achieves a substantial improvement com-
pared to prior methods using the same datasets.
We also compare to other labeled sentence-pairarXiv:2104.08821v4 [cs.CL] 18 May 2022 |
1912.02292.pdf | DEEPDOUBLE DESCENT :
WHERE BIGGER MODELS AND MORE DATA HURT
Preetum Nakkiran∗
Harvard UniversityGal Kaplun†
Harvard UniversityYamini Bansal†
Harvard UniversityTristan Yang
Harvard University
Boaz Barak
Harvard UniversityIlya Sutskever
OpenAI
ABSTRACT
We show that a variety of modern deep learning tasks exhibit a “double-descent”
phenomenon where, as we increase model size, performance first gets worse and
then gets better. Moreover, we show that double descent occurs not just as a
function of model size, but also as a function of the number of training epochs.
We unify the above phenomena by defining a new complexity measure we call
theeffective model complexity and conjecture a generalized double descent with
respect to this measure. Furthermore, our notion of model complexity allows us to
identify certain regimes where increasing (even quadrupling) the number of train
samples actually hurts test performance.
1 I NTRODUCTION
Figure 1: Left: Train and test error as a function of model size, for ResNet18s of varying width
on CIFAR-10 with 15% label noise. Right: Test error, shown for varying train epochs. All models
trained using Adam for 4K epochs. The largest model (width 64) corresponds to standard ResNet18.
The bias-variance trade-off is a fundamental concept in classical statistical learning theory (e.g.,
Hastie et al. (2005)). The idea is that models of higher complexity have lower bias but higher vari-
ance. According to this theory, once model complexity passes a certain threshold, models “overfit”
with the variance term dominating the test error, and hence from this point onward, increasing model
complexity will only decrease performance (i.e., increase test error). Hence conventional wisdom
in classical statistics is that, once we pass a certain threshold, “larger models are worse. ”
However, modern neural networks exhibit no such phenomenon. Such networks have millions of
parameters, more than enough to fit even random labels (Zhang et al. (2016)), and yet they perform
much better on many tasks than smaller models. Indeed, conventional wisdom among practitioners
is that “larger models are better’ ’ (Krizhevsky et al. (2012), Huang et al. (2018), Szegedy et al.
∗Work performed in part while Preetum Nakkiran was interning at OpenAI, with Ilya Sutskever. We espe-
cially thank Mikhail Belkin and Christopher Olah for helpful discussions throughout this work. Correspondence
Email: preetum@cs.harvard.edu
†Equal contribution
1arXiv:1912.02292v1 [cs.LG] 4 Dec 2019 |
2401.10241.pdf | ZERO BUBBLE PIPELINE PARALLELISM
Penghui Qi∗, Xinyi Wan∗, Guangxing Huang & Min Lin
Sea AI Lab
{qiph,wanxy,huanggx,linmin }@sea.com
ABSTRACT
Pipeline parallelism is one of the key components for large-scale distributed train-
ing, yet its efficiency suffers from pipeline bubbles which were deemed inevitable.
In this work, we introduce a scheduling strategy that, to our knowledge, is the
first to successfully achieve zero pipeline bubbles under synchronous training se-
mantics. The key idea behind this improvement is to split the backward compu-
tation into two parts, one that computes gradient for the input and another that
computes for the parameters. Based on this idea, we handcraft novel pipeline
schedules that significantly outperform the baseline methods. We further de-
velop an algorithm that automatically finds an optimal schedule based on spe-
cific model configuration and memory limit. Additionally, to truly achieve zero
bubble, we introduce a novel technique to bypass synchronizations during the op-
timizer step. Experimental evaluations show that our method outperforms the
1F1B schedule up to 23% in throughput under a similar memory limit. This
number can be further pushed to 31% when the memory constraint is relaxed.
We believe our results mark a major step forward in harnessing the true po-
tential of pipeline parallelism. We open sourced our implementation based on
the popular Megatron-LM repository on https://github.com/sail-sg/
zero-bubble-pipeline-parallelism .
1 I NTRODUCTION
The realm of distributed model training has become a focal point in the deep learning community,
especially with the advent of increasingly large and intricate models. Training these behemoths
often requires a vast amount of GPUs interconnected with various topologies. Various parallelism
techniques have been proposed for training DNN in the past years. Data parallelism (DP) (Goyal
et al., 2017; Li et al., 2020) is the default strategy for models of small to moderate sizes due to
its simplicity. Beyond a model size, it is no longer possible to fit the model parameters in one
single GPU. This is when model parallelism comes to the rescue (Harlap et al., 2018; Huang et al.,
2019; Fan et al., 2021; Zheng et al., 2022). There are two main model parallel schemes, tensor
parallelism (TP) and pipeline parallelism (PP). TP splits the matrix multiplication in one layer to
several devices, while PP segments the entire model into different stages which can be processed
across different devices. Notably, ZeRO (Rajbhandari et al., 2020) provides a strong alternative to
model parallelism by sharding parameters across devices, while keeping the simplicity of DP.
Recent research indicates that achieving optimal performance in large-scale training scenarios re-
quires a non-trivial interaction of DP, TP and PP strategies. In the abundance of interconnection
resources, e.g. NVLink between GPUs within one compute node, a hybrid of DP, TP and ZeRO
strategies works efficiently. Whereas there are numerous empirical evidences Fan et al. (2021);
Zheng et al. (2022); Narayanan et al. (2021) showing PP is particularly advantageous for utilizing
cross-server connections, especially at the scale of thousands of GPUs. This highlights the primary
aim of our work: enhancing the efficiency of PP.
Going deeper into the intricacies of PP, the efficiency of its implementation relies heavily on the
amount of device idle time referred to as pipeline bubbles. Due to the dependency between lay-
ers, bubbles seem inevitable. A prominent early work to address this issue is GPipe (Huang et al.,
2019), which attempts to reduce the bubble ratio by increasing the number of concurrent batches
∗Equal Contributors
1arXiv:2401.10241v1 [cs.DC] 30 Nov 2023 |
2310.01352v4.pdf | Published as a conference paper at ICLR 2024
RA-DIT: R ETRIEVAL -AUGMENTED DUAL INSTRUC -
TION TUNING
Xi Victoria Lin∗Xilun Chen∗Mingda Chen∗
Weijia Shi Maria Lomeli Rich James Pedro Rodriguez Jacob Kahn
Gergely Szilvasy Mike Lewis Luke Zettlemoyer Scott Yih
FAIR at Meta
{victorialin,xilun,mingdachen,scottyih }@meta.com
ABSTRACT
Retrieval-augmented language models (RALMs) improve performance by access-
ing long-tail and up-to-date knowledge from external data stores, but are challeng-
ing to build. Existing approaches require either expensive retrieval-specific modi-
fications to LM pre-training or use post-hoc integration of the data store that leads
to suboptimal performance. We introduce Retrieval- Augmented DualInstruction
Tuning (RA-DIT), a lightweight fine-tuning methodology that provides a third
option by retrofitting any LLM with retrieval capabilities. Our approach operates
in two distinct fine-tuning steps: (1) one updates a pre-trained LM to better use
retrieved information, while (2) the other updates the retriever to return more rel-
evant results, as preferred by the LM. By fine-tuning over tasks that require both
knowledge utilization and contextual awareness, we demonstrate that each stage
yields significant performance improvements, and using both leads to additional
gains. Our best model, RA-DIT 65B, achieves state-of-the-art performance across
a range of knowledge-intensive zero- and few-shot learning benchmarks, signif-
icantly outperforming existing in-context RALM approaches by up to +8.9% in
0-shot setting and +1.4% in 5-shot setting on average.
1 I NTRODUCTION
Large language models (LLMs) excel as zero- and few-shot learners across various tasks (Brown
et al., 2020; Chowdhery et al., 2022; Touvron et al., 2023a;b; Anil et al., 2023; OpenAI, 2023).
However, because knowledge is represented only in the model parameters, they struggle to capture
long-tail knowledge (Tirumala et al., 2022; Sun et al., 2023) and require substantial resources to be
kept up-to-date (Miller, 2023). Retrieval-Augmented Language Modeling (RALM) integrates LLMs
with non-parametric information retrieval to overcome these limitations (Guu et al., 2020; Borgeaud
et al., 2022; Izacard et al., 2022b; Shi et al., 2023b; Ram et al., 2023). By explicitly decoupling
knowledge retrieval with the backbone language model, such architectures have exhibited superior
performance on knowledge intensive tasks such as open-domain question answering (Lewis et al.,
2020; Izacard et al., 2022b) and live chat interactions (Liu, 2022).
Existing RALM architectures focus on two high-level challenges: (i) enhancing the LLM’s capabil-
ity to incorporate retrieved knowledge (Lewis et al., 2020; Izacard et al., 2022b) and (ii) refining the
retrieval component to return more relevant content (Shi et al., 2023b; Izacard et al., 2022b). Previ-
ous work have also introduced retrieval capabilities at different stages of the model training process.
REALM (Guu et al., 2020) and RETRO (Borgeaud et al., 2022) opt for end-to-end pre-training , in-
corporating the retrieval component from the outset. Atlas (Izacard et al., 2022b) builds upon the T5
language model (Raffel et al., 2020), and continuosly pre-trains the framework over unsupervised
text. R EPLUG (Shi et al., 2023b) and In-Context RALM (Ram et al., 2023) combine off-the-shelf
LLMs with general-purpose retrievers, showing that these two components can be effectively fused
through the emergent in-context learning capbabilities of LLMs. However, extensive pre-training of
such architectures is expensive, and the off-the-shelf fusion approach also has limitations, particu-
larly as the LLMs are not inherently trained to incorporate retrieved content.
∗Equal contribution
1arXiv:2310.01352v4 [cs.CL] 6 May 2024 |
2304.09871.pdf | A Theory on Adam Instability in Large-Scale Machine Learning
Igor Molybog∗, Peter Albert, Moya Chen, Zachary DeVito,
David Esiobu, Naman Goyal, Punit Singh Koura, Sharan Narang,
Andrew Poulton, Ruan Silva, Binh Tang, Diana Liskovich, Puxin Xu, Yuchen Zhang,
Melanie Kambadur, Stephen Roller, Susan Zhang
Meta AI
April 26, 2023
Abstract
We present a theory for the previously unexplained divergent behavior noticed in the training of
large language models. We argue that the phenomenon is an artifact of the dominant optimization
algorithm used for training, called Adam. We observe that Adam can enter a state in which
the parameter update vector has a relatively large norm and is essentially uncorrelated with the
direction of descent on the training loss landscape, leading to divergence. This artifact is more
likely to be observed in the training of a deep model with a large batch size, which is the typical
setting of large-scale language model training. To argue the theory, we present observations from
the training runs of the language models of different scales: 7 billion, 30 billion, 65 billion, and
546 billion parameters.
1 Introduction
Training instability reported by Chowdhery et al. [2022] is an interesting phenomenon that has only
been reported for the large language models trained on an order of a trillion tokens, posing a threat to
further scaling of the AI systems. Chowdhery et al. [2022] have observed dozens of spikes in the loss
curve throughout training. To mitigate the issue, they re-started training from a checkpoint roughly
100 steps before the spike started, and skipped roughly 200–500 data batches, in order to exclude
batches that were seen right before and during the spike. In that case, the spike of the loss value did
not repeat. The spikes were also not observed when the skipped data was fed through the model again
after the aforementioned mitigation, which implies that the data itself did not cause the spike, but
rather an interference of the data batch with the state of the model training run. The purpose of this
work is to rigorously reproduce the experiment with a different hardware and software setup, come
up with an explanation for the observed behavior supported by empirical evidence and theoretical
arguments, and propose alternative ways of mitigating the issue.
Loss spikes are difficult to study because any reproduction of these spikes at a smaller scale is
not necessarily caused by or remediated by the same factors as in larger scales. We therefore analyze
large-scale language modeling experiments, training four models between 7 billion and 546 billion
parameters. The models are decoder-only transformers [Brown et al., 2020, Smith et al., 2022] with
different depth and embedding dimensions and trained using the AdamW [Loshchilov and Hutter,
2017] algorithm with a linear learning rate schedule. Comparing to the modified Adafactor [Shazeer
and Stern, 2018] used by Chowdhery et al. [2022], we did not use the ”parameter scaling”, β2build-up
or the dynamic weight decay. This did not critically change the observed training instabilities. We
also made modifications in the architecture relative to the setup of Chowdhery et al. [2022] so that
the phenomenon we reproduce are robust to some changes in the specifics of model architectures. For
example, we used the ReLU activation function like Zhang et al. [2022] instead of SwiGLU Shazeer
[2020], and absolute learned positional embeddings instead of RoPE Su et al. [2021]. The settings
of each training run that are important in the context of our analysis are displayed in Table 1. We
cross-checked our results with the models trained using a different codebase and a different dataset,
∗igormolybog@meta.com
1arXiv:2304.09871v2 [cs.LG] 25 Apr 2023 |
2024.02.27.582234v2.full.pdf | Sequence modeling and design
from molecular to genome scale with Evo
Eric Nguyen∗,1,2, Michael Poli∗,3, Matthew G. Durrant∗,2,
Armin W. Thomas1, Brian Kang1, Jeremy Sullivan2,
Madelena Y. Ng1, Ashley Lewis1, Aman Patel1, Aaron Lou1,
Stefano Ermon1,4, Stephen A. Baccus1, Tina Hernandez-Boussard1, Christopher Ré1,
Patrick D. Hsu†,2,5, and Brian L. Hie†,1,2
1Stanford University,2Arc Institute,3TogetherAI,4CZ Biohub,5University of California, Berkeley
Abstract
The genome is a sequence that completely encodes the DNA, RNA, and proteins that orchestrate the function
of a whole organism. Advances in machine learning combined with massive datasets of whole genomes could
enable a biological foundation model that accelerates the mechanistic understanding and generative design
of complex molecular interactions. We report Evo, a genomic foundation model that enables prediction and
generation tasks from the molecular to genome scale. Using an architecture based on advances in deep
signal processing, we scale Evo to 7billion parameters with a context length of 131kilobases (kb) at single-
nucleotide, byte resolution. Trained on 2.7M prokaryotic and phage genomes, Evo can generalize across
the three fundamental modalities of the central dogma of molecular biology to perform zero-shot function
prediction that is competitive with, or outperforms, leading domain-specific language models. Evo also excels
at multi-element generation tasks, which we demonstrate by generating synthetic CRISPR-Cas molecular
complexes and entire transposable systems for the first time. Using information learned over whole genomes,
Evo can also predict gene essentiality at nucleotide resolution and can generate coding-rich sequences up to
650kb in length, orders of magnitude longer than previous methods. Advances in multi-modal and multi-
scalelearningwithEvoprovidesapromisingpathtowardimprovingourunderstandingandcontrolofbiology
across multiple levels of complexity.
1. Introduction
DNA is the fundamental layer of biological information that is responsible for transmitting the results of evo-
lution across generations of life (Morgan, 1910;Watson and Crick, 1953;Nirenberg and Matthaei, 1961).
Evolutionary variation in genome sequences is a reflection of adaptation and selection for biological function
at the phenotypic level (Dobzhansky, 1951). Rapid advances in DNA sequencing technologies have enabled
the systematic mapping of this evolutionary diversity at the whole-genome scale.
A machine that learns this breadth of information across genomes could model the function of DNA, RNA,
and proteins, as well as their diverse interactions that orchestrate complex biological functions, mediate dis-
ease, or create a complete organism. Modern machine learning algorithms combined with massive datasets of
genomic sequences could enable a general biological foundation model that learns the intrinsic logic of whole
genomes.
However, current efforts to model molecular biology with machine learning have been focused on creating
modality-specific models that are specialized to proteins, regulatory DNA, or RNA (Jumper et al., 2021;Rives
et al.,2021;Avsec et al., 2021;Theodoris et al., 2023). In addition, generative applications in biology have
been limited to the design of single molecules, simple complexes (Watson et al., 2023;Madani et al., 2023;
∗Equal contribution. †Corresponding author. B.L.H. (brianhie@stanford.edu); P.D.H. (patrick@arcinstitute.org).
1. CC-BY 4.0 International license made available under a(which was not certified by peer review) is the author/funder, who has granted bioRxiv a license to display the preprint in perpetuity. It is The copyright holder for this preprint this version posted March 6, 2024. ; https://doi.org/10.1101/2024.02.27.582234doi: bioRxiv preprint |
2203.12644.pdf | Linearizing Transformer with Key-Value Memory
Yizhe Zhang∗
Meta AI
yizhezhang@fb.comDeng Cai∗
The Chinese University of Hong Kong
thisisjcykcd@gmail.com
Abstract
Efficient transformer variants with linear time
complexity have been developed to mitigate
the quadratic computational overhead of the
vanilla transformer. Among them are low-
rank projection methods such as Linformer
and kernel-based Transformers. Despite their
unique merits, they usually suffer from a per-
formance drop comparing with the vanilla
transformer on many sequence generation
tasks, and often fail to obtain computation
gain when the generation is short. We pro-
pose MemSizer, an approach towards closing
the performance gap while improving the effi-
ciency even with short generation. It projects
the source sequences into lower dimension
representations like Linformer, while enjoy-
ing efficient recurrent-style incremental com-
putation similar to kernel-based transformers.
This yields linear computation time and con-
stant memory complexity at inference time.
MemSizer also employs a lightweight multi-
head mechanism which renders the compu-
tation as light as a single-head model. We
demonstrate that MemSizer provides an im-
proved balance between efficiency and accu-
racy over the vanilla transformer and other
efficient transformer variants in three typi-
cal sequence generation tasks, including ma-
chine translation, abstractive text summariza-
tion, and language modeling.
1 Introduction
Transformer (Vaswani et al., 2017) has become the
de facto standard for almost all NLP tasks across
the board. At the core of the vanilla transformer
is the attention mechanism that captures the in-
teractions between feature vectors at different po-
sitions in a sequence. Despite its great success,
the vanilla transformer models are typically com-
putationally expensive as the computation of the
attention mechanism scales quadratically with the
∗Equal contribution.sequence length. This bottleneck limits the effi-
cient deployment of large-scale pre-trained models,
such as GPT-3 (Brown et al., 2020), Image Trans-
former (Parmar et al., 2018), Codex (Chen et al.,
2021) and DALL-E (Ramesh et al., 2021). Training
and deploying such gigantic transformer models
can be prohibitively difficult for scenarios with
limited resource budgets and may result in huge
energy consumption and greenhouse gas emission
(Strubell et al., 2019; Schwartz et al., 2020).
A number of transformer variants have been
proposed to reduce the computational overhead
(Tay et al., 2020c). One family of methods lever-
ages low-rank projections to reduce the number
of pair-wise interactions ( i.e., the size of attention
matrices) (Wang et al., 2020; Xiong et al., 2021;
Tay et al., 2020a). These methods first project
the input sequence into a low-resolution represen-
tation. For example, Wang et al. (2020) project
the length dimension to a fixed feature dimension.
Nevertheless, these methods have difficulties mod-
eling variable-length sequences and autoregressive
(causal) attention, impeding their applications in
sequence generation tasks. Recent works propose
to approximate the softmax attention through ker-
nelization (Katharopoulos et al., 2020; Peng et al.,
2021; Choromanski et al., 2021; Kasai et al., 2021).
For sequence generation tasks, these works can
cache computation in a recurrent manner, leading
to constant memory complexity in sequence length
during inference. Despite the improved efficiency
in long-form generation, the computation gain of
these kernel-based approaches vanishes when the
generation is as short as a typical sentence length.
Additionally, they usually suffer from a perfor-
mance loss when training from scratch (Kasai et al.,
2021).
In this work, we propose an approach called
MemSizer, an efficient transformer variant which
follows the paradigm of low-rank projections while
enjoying memory-efficient recurrent-style genera-arXiv:2203.12644v4 [cs.CL] 13 Oct 2022 |
1909.05215.pdf | Published as a conference paper at ICLR 2020
RECONSTRUCTING CONTINUOUS DISTRIBUTIONS OF
3D PROTEIN STRUCTURE FROM CRYO -EM IMAGES
Ellen D. Zhong
MIT
zhonge@mit.eduTristan Bepler
MIT
tbepler@mit.eduJoseph H. Davis∗
MIT
jhdavis@mit.eduBonnie Berger∗
MIT
bab@mit.edu
ABSTRACT
Cryo-electron microscopy (cryo-EM) is a powerful technique for determining the
structure of proteins and other macromolecular complexes at near-atomic resolution.
In single particle cryo-EM, the central problem is to reconstruct the 3D structure of
a macromolecule from 104−7noisy and randomly oriented 2D projection images.
However, the imaged protein complexes may exhibit structural variability, which
complicates reconstruction and is typically addressed using discrete clustering
approaches that fail to capture the full range of protein dynamics. Here, we
introduce a novel method for cryo-EM reconstruction that extends naturally to
modeling continuous generative factors of structural heterogeneity. This method
encodes structures in Fourier space using coordinate-based deep neural networks,
and trains these networks from unlabeled 2D cryo-EM images by combining
exact inference over image orientation with variational inference for structural
heterogeneity. We demonstrate that the proposed method, termed cryoDRGN, can
perform ab initio reconstruction of 3D protein complexes from simulated and real
2D cryo-EM image data. To our knowledge, cryoDRGN is the first neural network-
based approach for cryo-EM reconstruction and the first end-to-end method for
directly reconstructing continuous ensembles of protein structures from cryo-EM
images.
1 I NTRODUCTION
Cryo-electron microscopy (cryo-EM) is a Nobel Prize-winning technique capable of determining the
structure of proteins and macromolecular complexes at near-atomic resolution. In a single particle
cryo-EM experiment, a purified solution of the target protein or biomolecular complex is frozen in
a thin layer of vitreous ice and imaged at sub-nanometer resolution using an electron microscope.
After initial preprocessing and segmentation of the raw data, the dataset typically comprises 104−7
noisy projection images. Each image contains a separate instance of the molecule, recorded as the
molecule’s electron density integrated along the imaging axis (Figure 1). A major bottleneck in
cryo-EM structure determination is the computational task of 3D reconstruction, where the goal is
to solve the inverse problem of learning the structure, i.e. the 3D electron density volume, which
gave rise to the projection images. Unlike classic tomographic reconstruction (e.g. MRI), cryo-
EM reconstruction is complicated by the unknown orientation of each copy of the molecule in the
ice. Furthermore, cryo-EM reconstruction algorithms must handle challenges such as an extremely
low signal to noise ratio (SNR), unknown in-plane translations, imperfect signal transfer due to
microscope optics, and discretization of the measurements. Despite these challenges, continuing
advances in hardware and software have enabled structure determination at near-atomic resolution
forrigid proteins (Kühlbrandt (2014); Scheres (2012b); Renaud et al. (2018); Li et al. (2013)).
Many proteins and other biomolecules are intrinsically flexible and undergo large conformational
changes to perform their function. Since each cryo-EM image contains a unique instance of the
molecule of interest, cryo-EM has the potential to resolve structural heterogeneity, which is experi-
mentally infeasible with other structural biology techniques such as X-ray crystallography. However,
this heterogeneity poses a substantial challenge for reconstruction as each image is no longer of the
same structure. Traditional reconstruction algorithms address heterogeneity with discrete clustering
∗Corresponding authors
1arXiv:1909.05215v3 [q-bio.QM] 15 Feb 2020 |
2104.08663v2.pdf | BEIR: A Heterogenous Benchmark for Zero-shot Evaluation of
Information Retrieval Models
Nandan Thakur, Nils Reimers, Andreas Rücklé, Abhishek Srivastava, Iryna Gurevych
Ubiquitous Knowledge Processing Lab (UKP-TUDA)
Department of Computer Science, Technische Universität Darmstadt
www.ukp.tu-darmstadt.de
Abstract
Neural IR models have often been studied in
homogeneous and narrow settings, which has
considerably limited insights into their gen-
eralization capabilities. To address this, and
to allow researchers to more broadly estab-
lish the effectiveness of their models, we in-
troduce BEIR (Benchmarking IR), a hetero-
geneous benchmark for information retrieval.
We leverage a careful selection of 17 datasets
for evaluation spanning diverse retrieval tasks
including open-domain datasets as well as nar-
row expert domains. We study the effective-
ness of nine state-of-the-art retrieval models
in azero-shot evaluation setup on BEIR , find-
ing that performing well consistently across all
datasets is challenging.
Our results show BM25 is a robust baseline
andReranking -based models overall achieve
the best zero-shot performances, however, at
high computational costs. In contrast, Dense -
retrieval models are computationally more effi-
cient but often underperform other approaches,
highlighting the considerable room for im-
provement in their generalization capabilities.
In this work, we extensively analyze different
retrieval models and provide several sugges-
tions that we believe may be useful for future
work. BEIR datasets and code are available at
https://github.com/UKPLab/beir .
1 Introduction
Many real-world NLP problems rely on a practi-
cal and efficient retrieval component as a first step
to find relevant information. Examples are open-
domain question-answering (Chen et al., 2017),
claim-verification (Thorne et al., 2018), and dupli-
cate question detection (Zhang et al., 2015). Tra-
ditionally, retrieval has been dominated by lexical
approaches like TF-IDF or BM25 (Robertson and
Zaragoza, 2009). However, these approaches suffer
from what is known as lexical gap (Berger et al.,
2000) and only retrieve documents that containthe keywords also present within the query. Fur-
ther, queries and documents are treated in a bag-of-
words manner which does not take word ordering
into consideration.
Recently, deep learning and in particular pre-
trained Transformer models like BERT (Devlin
et al., 2018) have became popular in the infor-
mation retrieval space (Lin et al., 2020). They
overcome the lexical gap by mapping queries and
documents to a dense vector (Guo et al., 2016; Lee
et al., 2019; Karpukhin et al., 2020; Guu et al.,
2020; Gao et al., 2020; Liang et al., 2020; Ma
et al., 2021). The relevant documents for a given
query are then retrieved using (approximate) near-
est neighbor search (Johnson et al., 2017).
Another widely used approach involves re-
ranking documents from the output of a first-stage
retrieval system (Nogueira et al., 2019a, 2020;
Nogueira and Cho, 2020; Khattab and Zaharia,
2020). While dense retrieval approaches try to
overcome the (potential) lexical gap, re-ranking
approaches aim to create a better comparison of
the retrieved documents. Different approaches can
also be combined together (Ding et al., 2020; Gao
et al., 2020; Luan et al., 2021).
Previous approaches were commonly trained on
rather large datasets like the Natural Questions
(NQ) dataset (Kwiatkowski et al., 2019) contain-
ing around 133k training examples or the MS-
MARCO dataset (Nguyen et al., 2016) with more
than 500k training examples. Existing approaches
have been shown to perform well when evaluated
in-domain or for similar tasks (Nogueira and Cho,
2020; Karpukhin et al., 2020; Ding et al., 2020).
However, large training corpora are not available
for most tasks and domains. As creating a large
training corpus can be expensive, it is not feasible
to create such for most tasks and domains. Hence,
in most scenarios, we apply retrieval models in a
zero-shot setup, i.e. pre-trained models are applied
out-of-the-box across new tasks and domains. InarXiv:2104.08663v2 [cs.IR] 28 Apr 2021 |
2402.08609.pdf | 2024-2-14
Mixtures of Experts Unlock Parameter Scaling
for Deep RL
Johan Obando-Ceron*,1,2,3, Ghada Sokar*,1, Timon Willi*,4, Clare Lyle1, Jesse Farebrother1,2,5, Jakob
Foerster4, Gintare Karolina Dziugaite1,2,5, Doina Precup1,2,5and Pablo Samuel Castro1,2,3
*Equal contributions,1Google DeepMind,2Mila - Québec AI Institute,3Université de Montréal,4University of Oxford,5McGill
University
The recent rapid progress in (self) supervised learning models is in large part predicted by empirical
scaling laws: a model’s performance scales proportionally to its size. Analogous scaling laws remain
elusive for reinforcement learning domains, however, where increasing the parameter count of a model
often hurts its final performance. In this paper, we demonstrate that incorporating Mixture-of-Expert
(MoE) modules, and in particular Soft MoE s (Puigcerver et al., 2023), into value-based networks results
in more parameter-scalable models, evidenced by substantial performance increases across a variety of
training regimes and model sizes. This work thus provides strong empirical evidence towards developing
scaling laws for reinforcement learning.
1. Introduction
Deep Reinforcement Learning (RL) – the com-
bination of reinforcement learning algorithms
with deep neural networks – has proven effective
at producing agents that perform complex tasks
at super-human levels (Bellemare et al., 2020;
Berneretal.,2019;Fawzietal.,2022;Mnihetal.,
2015; Vinyals et al., 2019). While deep networks
are critical to any successful application of RL in
complex environments, their design and learning
dynamics in RL remain a mystery. Indeed, recent
work highlights some of the surprising phenom-
ena that arise when using deep networks in RL,
often going against the behaviours observed in
supervised learning settings (Ceron et al., 2023;
Graesser et al., 2022; Kumar et al., 2021a; Lyle
etal.,2022a;Nikishinetal.,2022;Ostrovskietal.,
2021; Sokar et al., 2023).
The supervised learning community convinc-
ingly showed that larger networks result in im-
proved performance, in particular for language
models (Kaplan et al., 2020). In contrast, re-
cent work demonstrates that scaling networks
in RL is challenging and requires the use of so-
phisticated techniques to stabilize learning, such
as supervised auxiliary losses, distillation, and
pre-training (Farebrother et al., 2022; Schwarzer
et al., 2023; Taiga et al., 2022). Furthermore,
deep RL networks are under-utilizing their pa-rameters, which may account for the observed
difficulties in obtaining improved performance
fromscale(Kumaretal.,2021a;Lyleetal.,2022a;
Sokar et al., 2023). Parameter count cannot be
scaled efficiently if those parameters are not used
effectively.
Architectural advances, such as transformers
(Vaswani et al., 2017), adapters (Houlsby et al.,
2019), and Mixtures of Experts (MoEs; Shazeer
et al., 2017), have been central to the scaling
properties of supervised learning models, espe-
cially in natural language and computer vision
problem settings. MoEs, in particular, are cru-
cial to scaling networks to billions (and recently
trillions) of parameters, because their modular-
ity combines naturally with distributed computa-
tionapproaches(Fedusetal.,2022). Additionally,
MoEs induce structured sparsity in a network, and
certain types of sparsity have been shown to im-
prove network performance (Evci et al., 2020;
Gale et al., 2019).
In this paper, we explore the effect of mix-
ture of experts on the parameter scalability of
value-based deep RL networks, i.e., does perfor-
mance increase as we increase the number of
parameters? We demonstrate that incorporating
Soft MoE s (Puigcerver et al., 2023) strongly im-
provestheperformanceofvariousdeepRLagents,
and performance improvements scale with the
Corresponding author(s): psc@google.com
©2024 Google DeepMind. All rights reservedarXiv:2402.08609v1 [cs.LG] 13 Feb 2024 |
2306.17563.pdf | arXiv:2306.17563v1 [cs.IR] 30 Jun 2023Preprint
LARGE LANGUAGE MODELS ARE EFFECTIVE TEXT
RANKERS WITH PAIRWISE RANKING PROMPTING
Zhen Qin, Rolf Jagerman, Kai Hui, Honglei Zhuang, Junru Wu, J iaming Shen,
Tianqi Liu, Jialu Liu, Donald Metzler, Xuanhui Wang, Michae l Bendersky
Google Research
{zhenqin,jagerman,kaihuibj,hlz,junru,jmshen,tianqil iu,jialu,
metzler,xuanhui,bemike}@google.com
ABSTRACT
Ranking documents using Large Language Models (LLMs) by dir ectly feeding
the query and candidate documents into the prompt is an inter esting and prac-
tical problem. However, there has been limited success so fa r, as researchers
have found it difficult to outperform fine-tuned baseline ran kers on benchmark
datasets. We analyze pointwise and listwise ranking prompt s used by existing
methods and argue that off-the-shelf LLMs do not fully under stand these rank-
ing formulations, possibly due to the nature of how LLMs are t rained. In this
paper, we propose to significantly reduce the burden on LLMs b y using a new
technique called Pairwise Ranking Prompting (PRP). Our results are the first in
the literature to achieve state-of-the-art ranking perfor mance on standard bench-
marks using moderate-sized open-sourced LLMs. On TREC-DL2 020, PRP based
on the Flan-UL2 model with 20B parameters outperforms the pr evious best ap-
proach in the literature, which is based on the blackbox comm ercial GPT-4 that
has 50x (estimated) model size, by over 5% at NDCG@1. On TREC- DL2019,
PRP is only inferior to the GPT-4 solution on the NDCG@5 and ND CG@10 met-
rics, while outperforming other existing solutions, such a s InstructGPT which has
175B parameters, by over 10% for nearly all ranking metrics. Furthermore, we
propose several variants of PRP to improve efficiency and sho w that it is possible
to achieve competitive results even with linear complexity . We also discuss other
benefits of PRP, such as supporting both generation and scori ng LLM APIs, as
well as being insensitive to input ordering.
1 I NTRODUCTION
Large Language Model (LLMs) such as GPT-3 (Brown et al., 2020 ) and PaLM (Chowdhery et al.,
2022) have demonstrated impressive performance on a wide ra nge of natural language tasks, achiev-
ing comparable or better performance when compared with the ir supervised counterparts that are
potentially trained with millions of labeled examples, eve n in the zero-shot setting (Kojima et al.,
2022; Agrawal et al., 2022; Huang et al., 2022; Hou et al., 202 3).
However, there is limited success for the important text ran king problem using LLMs (Ma et al.,
2023). Existing results usually significantly underperfor m well-trained baseline rankers (e.g.,
Nogueira et al. (2020); Zhuang et al. (2023)). The only excep tion is a recent approach proposed
in (Sun et al., 2023), which depends on the blackbox, giant, a nd commercial GPT-4 system. Besides
the technical concerns such as sensitivity to input order (r anking metrics can drop by more than
50% when the input document order changes), we argue that rel ying on such blackbox systems is
not ideal for academic researchers due to significant cost co nstraints and access limitations to these
systems, though we do acknowledge the value of such explorat ions in showing the capacity of LLMs
for ranking tasks.
In this work, we first discuss why it is difficult for LLMs to per form ranking tasks with existing
methods, specifically, the pointwise and listwise formulat ions. For pointwise approaches, ranking
requires LLMs to output calibrated prediction probabiliti es before sorting, which is known to be
very difficult and is not supported by the generation only LLM APIs (such as GPT-4). For listwise
approaches, even with instructions that look very clear to h umans, LLMs can frequently generate
1 |
2310.07096.pdf | Sparse Universal Transformer
Shawn Tan1 *
tanjings@mila.quebecYikang Shen2 *
yikang.shen@ibm.com
Zhenfang Chen2
zfchen@ibm.comAaron Courville1
courvila@iro.umontreal.caChuang Gan2
chuangg@ibm.com
1Mila, University of Montreal2MIT-IBM Watson AI Lab
Abstract
The Universal Transformer (UT) is a variant of
the Transformer that shares parameters across
its layers. Empirical evidence shows that UTs
have better compositional generalization than
Vanilla Transformers (VTs) in formal language
tasks. The parameter-sharing also affords it
better parameter efficiency than VTs. Despite
its many advantages, scaling UT parameters
is much more compute and memory intensive
than scaling up a VT. This paper proposes the
Sparse Universal Transformer (SUT), which
leverages Sparse Mixture of Experts (SMoE)
and a new stick-breaking-based dynamic halt-
ing mechanism to reduce UT’s computation
complexity while retaining its parameter effi-
ciency and generalization ability. Experiments
show that SUT achieves the same performance
as strong baseline models while only using
half computation and parameters on WMT’14
and strong generalization results on formal lan-
guage tasks (Logical inference and CFQ). The
new halting mechanism also enables around
50% reduction in computation during inference
with very little performance decrease on formal
language tasks.
1 Introduction
Recent theoretical work has pointed out that finite-
depth Transformers have an issue of expressibility
that will result in failure to generalize (Hahn, 2020;
Hao et al., 2022; Merrill et al., 2022; Liu et al.,
2022). Delétang et al. (2022) ran several neural
architectures on a suite of different synthetic lan-
guages generated from different levels of the Chom-
sky hierarchy and empirically confirmed these re-
sults, showing that VTs have difficulty generaliz-
ing to Regular languages. Universal Transformers
(UTs; Dehghani et al. 2018) are Transformers that
share parameters at every layer of the architecture.
Csordás et al. (2021) performed several composi-
tional generalization experiments on VTs and UTs
along with absolute and relative position embed-
Figure 1: A VT has separate Transformer blocks for
each layer, with different parameters. For a UT with
the same number of parameters, the UT block will be
∼3 times the dimensions of each VT block. Running
this block for 3 layers would then incur approximately
9 times the runtime memory. Using SMoEs can recover
approximately the same computational cost as the VT.
dings, and showed that UTs with relative positional
embeddings performed better on these tasks.
However, the task of scaling UTs is challenging
due to its computation complexity (Kaplan et al.,
2020; Tay et al., 2022; Takase and Kiyono, 2021).
Consider a VT with Pparameters for each layer
andLlayers. Evaluating such a VT has compu-
tation complexity associated with the model size
LP. A size-equivalent UT would have a UT block
withLPparameters and computation complexity
of approximately LPto run the block once. To run
such a UT for equivalent Llayers would incur a
complexity of L2P. This increased computation
complexity directly translates to increased train-
ing and inference time. According to Takase and
Kiyono (2021), UT requires two times the training
time and far more GPU memory than VT in WMT
English-German translation task.
Sparsely activated neural networks were intro-
duced to reduce the computation complexity ofarXiv:2310.07096v1 [cs.CL] 11 Oct 2023 |
1502.05767.pdf | arXiv:1502.05767v4 [cs.SC] 5 Feb 2018Automatic Differentiation
in Machine Learning: a Survey
Atılım G¨ une¸ s Baydin gunes@robots.ox.ac.uk
Department of Engineering Science
University of Oxford
Oxford OX1 3PJ, United Kingdom
Barak A. Pearlmutter barak@pearlmutter.net
Department of Computer Science
National University of Ireland Maynooth
Maynooth, Co. Kildare, Ireland
Alexey Andreyevich Radul axch@mit.edu
Department of Brain and Cognitive Sciences
Massachusetts Institute of Technology
Cambridge, MA 02139, United States
Jeffrey Mark Siskind qobi@purdue.edu
School of Electrical and Computer Engineering
Purdue University
West Lafayette, IN 47907, United States
Abstract
Derivatives, mostly in the form of gradients and Hessians, are ubiqu itous in machine learn-
ing. Automatic differentiation (AD), also called algorithmic differentiat ion or simply “auto-
diff”, is a family of techniques similar to but more general than backpr opagation for effi-
ciently and accurately evaluating derivatives of numeric functions e xpressed as computer
programs. AD is a small but established field with applications in areas in cluding compu-
tational fluid dynamics, atmospheric sciences, and engineering des ign optimization. Until
very recently, the fields of machine learning and AD have largely been unaware of each
other and, in some cases, have independently discovered each oth er’s results. Despite its
relevance, general-purpose AD has been missing from the machine le arning toolbox, a situ-
ation slowly changing with its ongoing adoption under the names “dyna mic computational
graphs” and “differentiable programming”. We survey the intersec tion of AD and machine
learning, cover applications where AD has direct relevance, and add ress the main imple-
mentation techniques. By precisely defining the main differentiation t echniques and their
interrelationships, we aim to bring clarity to the usage of the terms “ autodiff”, “automatic
differentiation”, and “symbolic differentiation” as these are encoun tered more and more in
machine learning settings.
Keywords: Backpropagation, Differentiable Programming |
1611.03852v3.pdf | arXiv:1611.03852v3 [cs.LG] 25 Nov 2016A ConnectionBetweenGenerativeAdversarial
Networks,InverseReinforcementLearning,and
Energy-BasedModels
ChelseaFinn∗, PaulChristiano∗, PieterAbbeel, SergeyLevine
UniversityofCalifornia,Berkeley
{cbfinn,paulfchristiano,pabbeel,svlevine}@eecs.berk eley.edu
Abstract
Generative adversarial networks (GANs) are a recently prop osedclass of genera-
tivemodelsinwhichageneratoristrainedtooptimizeacost functionthatisbeing
simultaneously learned by a discriminator. While the idea o f learning cost func-
tionsis relativelynew to the field of generativemodeling,l earningcosts has long
been studied in control and reinforcement learning (RL) dom ains, typically for
imitationlearningfromdemonstrations. Inthese fields, le arningthe costfunction
underlyingobservedbehaviorisknownasinversereinforce mentlearning(IRL)or
inverseoptimalcontrol. While atfirst theconnectionbetwe encost learninginRL
and cost learning in generative modeling may appear to be a su perficial one, we
showin thispaperthatcertainIRL methodsarein fact mathem aticallyequivalent
to GANs. In particular, we demonstrate an equivalence betwe en a sample-based
algorithmformaximumentropyIRLandaGAN inwhichthegener ator’sdensity
canbe evaluatedandis providedasan additionalinputto the discriminator. Inter-
estingly, maximum entropy IRL is a special case of an energy- based model. We
discusstheinterpretationofGANsasanalgorithmfortrain ingenergy-basedmod-
els, andrelate thisinterpretationtootherrecentworktha tseekstoconnectGANs
and EBMs. By formally highlighting the connection between G ANs, IRL, and
EBMs, we hope that researchers in all three communities can b etter identify and
apply transferable ideas from one domain to another, partic ularly for developing
morestable andscalablealgorithms: a majorchallengein al l threedomains.
1 Introduction
Generativeadversarialnetworks(GANs)arearecentlyprop osedclassofgenerativemodelsinwhich
a generatoris trainedto optimizea cost functionthat is bei ngsimultaneouslylearnedby a discrimi-
nator[8]. While the ideaoflearningobjectivesisrelative lynewto thefield ofgenerativemodeling,
learningcostorrewardfunctionshaslongbeenstudiedinco ntrol[5]andwaspopularizedin2000for
reinforcementlearningproblems[15]. In these fields, lear ningthe cost functionunderlyingdemon-
strated behavior is referred to as inverse reinforcement le arning (IRL) or inverse optimal control
(IOC). At first glance, the connectionbetween cost learning in RL and cost learning for generative
models may appear to be superficial; however, if we apply GANs to a setting where the generator
density can be efficiently evaluated, the result is exactly e quivalent to a sample-based algorithm
for maximum entropy (MaxEnt) IRL. Interestingly, as MaxEnt IRL is an energy-basedmodel, this
connectionsuggestsa methodforusingGANstotraina broade rclassofenergy-basedmodels.
MaxEnt IRL is a widely-used objective for IRL, proposed by Zi ebart et al. [27]. Sample-based
algorithms for performingmaximum entropy (MaxEnt) IRL hav e scaled cost learning to scenarios
∗Indicates equal contribution. |
1601.00670.pdf | Variational Inference: A Review for Statisticians
David M. Blei
Department of Computer Science and Statistics
Columbia University
Alp Kucukelbir
Department of Computer Science
Columbia University
Jon D. McAuliffe
Department of Statistics
University of California, Berkeley
May 11, 2018
Abstract
One of the core problems of modern statistics is to approximate difficult-to-compute
probability densities. This problem is especially important in Bayesian statistics, which
frames all inference about unknown quantities as a calculation involving the posterior
density. In this paper, we review variational inference ( VI), a method from machine
learning that approximates probability densities through optimization. VIhas been used
in many applications and tends to be faster than classical methods, such as Markov chain
Monte Carlo sampling. The idea behind VIis to first posit a family of densities and then
to find the member of that family which is close to the target. Closeness is measured
by Kullback-Leibler divergence. We review the ideas behind mean-field variational
inference, discuss the special case of VIapplied to exponential family models, present
a full example with a Bayesian mixture of Gaussians, and derive a variant that uses
stochastic optimization to scale up to massive data. We discuss modern research in VIand
highlight important open problems. VIis powerful, but it is not yet well understood. Our
hope in writing this paper is to catalyze statistical research on this class of algorithms.
Keywords: Algorithms; Statistical Computing; Computationally Intensive Methods.
1arXiv:1601.00670v9 [stat.CO] 9 May 2018 |
2310.17722.pdf | LARGE LANGUAGE MODELS AS GENERALIZABLE
POLICIES FOR EMBODIED TASKS
Andrew Szot, Max Schwarzer, Harsh Agrawal, Bogdan Mazoure, Walter Talbott
Katherine Metcalf, Natalie Mackraz, Devon Hjelm, Alexander Toshev
Apple
ABSTRACT
We show that large language models (LLMs) can be adapted to be generalizable
policies for embodied visual tasks. Our approach, called Large LAnguage model
Reinforcement Learning Policy (LLaRP), adapts a pre-trained frozen LLM to take
as input text instructions and visual egocentric observations and output actions di-
rectly in the environment. Using reinforcement learning, we train LLaRP to see
and act solely through environmental interactions. We show that LLaRP is robust
to complex paraphrasings of task instructions and can generalize to new tasks that
require novel optimal behavior. In particular, on 1,000unseen tasks it achieves
42% success rate, 1.7x the success rate of other common learned baselines or zero-
shot applications of LLMs. Finally, to aid the community in studying language
conditioned, massively multi-task, embodied AI problems we release a novel
benchmark, Language Rearrangement, consisting of 150,000training and 1,000
testing tasks for language-conditioned rearrangement. Video examples of LLaRP
in unseen Language Rearrangement instructions are at https://llm-rl.github.io.
1 I NTRODUCTION
Large Language Models (LLMs), characterized as billion-parameter models trained on enormous
amounts of text data, have demonstrated unprecedented language understanding capabilities. Fur-
thermore, LLMs have demonstrated powerful capabilities beyond core language understanding prob-
lems, such as dialog systems (Thoppilan et al., 2022; Glaese et al., 2022), visual understanding prob-
lems (Alayrac et al., 2022; Li et al., 2023b; Peng et al., 2023; Koh et al., 2023), reasoning (Wei et al.,
2022; Lewkowycz et al., 2022), code generation (Chen et al., 2021b), embodied reasoning (Driess
et al., 2023), and robot control (Ahn et al., 2022). These capabilities often emerge in a zero-shot
fashion, without dedicated training data for each capability, indicating that LLMs contain knowledge
general and broad enough to apply to numerous domains. Furthermore, these capabilities emerge
despite that the input and output spaces in these domains are oftentimes not naturally expressed in
language, e. g. images as inputs, and robot commands as outputs.
A key objective in Embodied AI is generalizable decision-making that can transfer to novel tasks, so
it is natural to ask if the generalization abilities of LLMs can be incorporated into embodied prob-
lems. Existing advances in using LLMs for Embodied AI have relied on static expert datasets (Driess
et al., 2023; Brohan et al., 2023), which requires prohibitively large and expensive amounts of di-
verse expert data. Conversely, Embodied AI simulators enable agents to learn from an environment
through direct interaction, exploration, and reward feedback (Kolve et al., 2019; Szot et al., 2021;
Li et al., 2023a). However, the generalization capabilities of such agents to a large number of new
embodied tasks are not on par with the aforementioned domains.
LLMs have been shown to be applicable in online settings when the control domain is that of nat-
ural language, e.g., Reinforcement Learning from Human Feedback (RLHF) for multi-turn dialog
applications (Ouyang et al., 2022). In this work, we successfully show that LLMs can be adapted for
Reinforcement Learning (RL) problems in Embodied AI, using a method we call Large LAnguage
model Reinforcement learning Policy (LLaRP). We demonstrate advanced capabilities on a diverse
set of rearrangement tasks, where the input and output domains aren’t just language (see Fig. 1) In
particular, we demonstrate the following three contributions:
1arXiv:2310.17722v1 [cs.LG] 26 Oct 2023 |
RFeynman-plentySpace.pdf | Plenty of Room at the Bottom
Richard P. Feynman
(Dated: Dec. 1959)
This is the transcript of a talk presented by Richard P. Feynman to the American Physical Society
in Pasadena on December 1959, which explores the immense possibilities afforded by miniaturization.
I imagine experimental physicists must often look with
envy at men like Kamerlingh Onnes, who discovered a
field like low temperature, which seems to be bottomless
and in which one can go down and down. Such a man
is then a leader and has some temporary monopoly in
a scientific adventure. Percy Bridgman, in designing a
way to obtain higher pressures, opened up another new
field and was able to move into it and to lead us all along.
The development of ever higher vacuum was a continuing
development of the same kind.
I would like to describe a field, in which little has been
done, but in which an enormous amount can be done in
principle. This field is not quite the same as the others
in that it will not tell us much of fundamental physics (in
the sense of, “What are the strange particles?”) but it is
more like solid-state physics in the sense that it might tell
us much of great interest about the strange phenomena
that occur in complex situations. Furthermore, a point
that is most important is that it would have an enormous
number of technical applications.
What I want to talk about is the problem of manipu-
lating and controlling things on a small scale.
As soon as I mention this, people tell me about minia-
turization, and how far it has progressed today. They tell
me about electric motors that are the size of the nail on
your small finger. And there is a device on the market,
they tell me, by which you can write the Lord’s Prayer
on the head of a pin. But that’s nothing; that’s the most
primitive, halting step in the direction I intend to dis-
cuss. It is a staggeringly small world that is below. In
the year 2000, when they look back at this age, they will
wonder why it was not until the year 1960 that anybody
began seriously to move in this direction.
Why cannot we write the entire 24 volumes of the En-
cyclopedia Brittanica on the head of a pin?
Let’s see what would be involved. The head of a pin is
a sixteenth of an inch across. If you magnify it by 25,000
diameters, the area of the head of the pin is then equal to
the area of all the pages of the Encyclopaedia Brittanica.
Therefore, all it is necessary to do is to reduce in size
all the writing in the Encyclopaedia by 25,000 times. Is
that possible? The resolving power of the eye is about
1/120 of an inch—that is roughly the diameter of one of
the little dots on the fine half-tone reproductions in the
Encyclopaedia. This, when you demagnify it by 25,000
times, is still 80 angstroms in diameter—32 atoms across,
in an ordinary metal. In other words, one of those dots
still would contain in its area 1,000 atoms. So, each dotcan easily be adjusted in size as required by the photo-
engraving, and there is no question that there is enough
room on the head of a pin to put all of the Encyclopaedia
Brittanica.
Furthermore, it can be read if it is so written. Let’s
imagine that it is written in raised letters of metal; that
is, where the black is in the Encyclopedia, we have raised
letters of metal that are actually 1/25,000 of their ordi-
nary size. How would we read it?
If we had something written in such a way, we could
read it using techniques in common use today. (They will
undoubtedly find a better way when we do actually have
it written, but to make my point conservatively I shall
just take techniques we know today.) We would press
the metal into a plastic material and make a mold of it,
then peel the plastic off very carefully, evaporate silica
into the plastic to get a very thin film, then shadow it by
evaporating gold at an angle against the silica so that all
the little letters will appear clearly, dissolve the plastic
away from the silica film, and then look through it with
an electron microscope!
There is no question that if the thing were reduced by
25,000 times in the form of raised letters on the pin, it
would be easy for us to read it today. Furthermore; there
is no question that we would find it easy to make copies
of the master; we would just need to press the same metal
plate again into plastic and we would have another copy.
How do we write small?
The next question is: How do we write it? We have
no standard technique to do this now. But let me argue
that it is not as difficult as it first appears to be. We
can reverse the lenses of the electron microscope in or-
der to demagnify as well as magnify. A source of ions,
sent through the microscope lenses in reverse, could be
focused to a very small spot. We could write with that
spot like we write in a TV cathode ray oscilloscope, by
going across in lines, and having an adjustment which
determines the amount of material which is going to be
deposited as we scan in lines.
This method might be very slow because of space
charge limitations. There will be more rapid methods.
We could first make, perhaps by some photo process, a
screen which has holes in it in the form of the letters.
Then we would strike an arc behind the holes and draw
metallic ions through the holes; then we could again use
our system of lenses and make a small image in the form
of ions, which would deposit the metal on the pin.
A simpler way might be this (though I am not sure it |
NIPS-2017-deep-reinforcement-learning-from-human-preferences-Paper.pdf | Deep Reinforcement Learning
from Human Preferences
Paul F Christiano
OpenAI
paul@openai.comJan Leike
DeepMind
leike@google.comTom B Brown
Google Brain⇤
tombbrown@google.com
Miljan Martic
DeepMind
miljanm@google.comShane Legg
DeepMind
legg@google.comDario Amodei
OpenAI
damodei@openai.com
Abstract
For sophisticated reinforcement learning (RL) systems to interact usefully with
real-world environments, we need to communicate complex goals to these systems.
In this work, we explore goals defined in terms of (non-expert) human preferences
between pairs of trajectory segments. We show that this approach can effectively
solve complex RL tasks without access to the reward function, including Atari
games and simulated robot locomotion, while providing feedback on less than
1% of our agent’s interactions with the environment. This reduces the cost of
human oversight far enough that it can be practically applied to state-of-the-art
RL systems. To demonstrate the flexibility of our approach, we show that we can
successfully train complex novel behaviors with about an hour of human time.
These behaviors and environments are considerably more complex than any which
have been previously learned from human feedback.
1 Introduction
Recent success in scaling reinforcement learning (RL) to large problems has been driven in domains
that have a well-specified reward function (Mnih et al., 2015, 2016; Silver et al., 2016). Unfortunately,
many tasks involve goals that are complex, poorly-defined, or hard to specify. Overcoming this
limitation would greatly expand the possible impact of deep RL and could increase the reach of
machine learning more broadly.
For example, suppose that we wanted to use reinforcement learning to train a robot to clean a table or
scramble an egg. It’s not clear how to construct a suitable reward function, which will need to be a
function of the robot’s sensors. We could try to design a simple reward function that approximately
captures the intended behavior, but this will often result in behavior that optimizes our reward
function without actually satisfying our preferences. This difficulty underlies recent concerns about
misalignment between our values and the objectives of our RL systems (Bostrom, 2014; Russell,
2016; Amodei et al., 2016). If we could successfully communicate our actual objectives to our agents,
it would be a significant step towards addressing these concerns.
If we have demonstrations of the desired task, we can use inverse reinforcement learning (Ng and
Russell, 2000) or imitation learning to copy the demonstrated behavior. But these approaches are not
directly applicable to behaviors that are difficult for humans to demonstrate (such as controlling a
robot with many degrees of freedom but non-human morphology).
⇤Work done while at OpenAI.
31st Conference on Neural Information Processing Systems (NIPS 2017), Long Beach, CA, USA. |
2403.20327.pdf | Gecko: Versatile Text Embeddings Distilled
from Large Language Models
Jinhyuk Lee*, Zhuyun Dai*, Xiaoqi Ren*, Blair Chen, Daniel Cer, Jeremy R. Cole, Kai Hui, Michael Boratko,
Rajvi Kapadia, Wen Ding, Yi Luan, Sai Meher Karthik Duddu, Gustavo Hernandez Abrego, Weiqiang Shi, Nithi
Gupta, Aditya Kusupati, Prateek Jain, Siddhartha Reddy Jonnalagadda, Ming-Wei Chang and Iftekhar Naim
*Equal contributions
We present Gecko, a compact and versatile text embedding model. Gecko achieves strong retrieval
performance by leveraging a key idea: distilling knowledge from large language models (LLMs) into a
retriever. Our two-step distillation process begins with generating diverse, synthetic paired data using
an LLM. Next, we further refine the data quality by retrieving a set of candidate passages for each query,
and relabeling the positive and hard negative passages using the same LLM. The effectiveness of our
approach is demonstrated by the compactness of the Gecko. On the Massive Text Embedding Benchmark
(MTEB), Gecko with 256 embedding dimensions outperforms all existing entries with 768 embedding
size. Gecko with 768 embedding dimensions achieves an average score of 66.31, competing with 7x
larger models and 5x higher dimensional embeddings.
1. Introduction
Text embedding models represent natural language as dense vectors, positioning semantically similar
text near each other within the embedding space (Gao et al., 2021; Le and Mikolov, 2014; Reimers
and Gurevych, 2019). These embeddings are commonly used for a wide range of downstream tasks
including document retrieval, sentence similarity, classification, and clustering (Muennighoff et al.,
2023). Instead of building separate embedding models for each downstream task, recent efforts seek
to create a single embedding model supporting many tasks.
The recent development of general-purpose text embedding models presents a challenge: these
models require large amounts of training data to comprehensively cover desired domains and skills.
Recent embedding efforts have focused on using extensive collections of training examples (Li et al.,
2023; Wang et al., 2022). Large language models (LLMs) offer a powerful alternative, as they contain
vast knowledge across various domains and are known to be exceptional few-shot learners (Anil et al.,
2023; Brown et al., 2020). Recent work demonstrates the effectiveness of using LLMs for synthetic
data generation, but the focus has primarily been on augmenting existing human-labeled data or
improving performance in specific domains (Dai et al., 2022; Jeronymo et al., 2023). It motivates us
to re-examine: to what extent can we leverage LLMs directly to improve text embedding models?
In this work, we present Gecko, a highly versatile yet efficient embedding model, powered by the
vast world knowledge of LLMs. Our approach leverages insights from knowledge distillation to create
a two-step LLM-powered embedding model. Starting with a large corpus of (unlabeled) passages,
we use a few-shot prompted LLM to generate a relevant task and query for each passage, similar to
Dai et al. (2022) and Wang et al. (2023). We then embed the concatenated task and query using a
pretrained embedding model to obtain nearest neighbor passages, use an LLM to rerank the passages,
and obtain positive and negative passages based on the LLM scores. The reranking step is key to
enhance the quality as we discover that the best passage to answer the generated query often differs
from the original source passage. We show that using our LLM-based dataset, FRet, alone can lead to
significantly improvement, setting a strong baseline as a zero-shot embedding model on MTEB.
Corresponding author(s): jinhyuklee@google.com
©2024 Google DeepMind. All rights reservedarXiv:2403.20327v1 [cs.CL] 29 Mar 2024 |
1509.02971.pdf | Published as a conference paper at ICLR 2016
CONTINUOUS CONTROL WITH DEEP REINFORCEMENT
LEARNING
Timothy P. Lillicrap∗, Jonathan J. Hunt∗, Alexander Pritzel, Nicolas Heess,
Tom Erez, Yuval Tassa, David Silver & Daan Wierstra
Google Deepmind
London, UK
{countzero, jjhunt, apritzel, heess,
etom, tassa, davidsilver, wierstra }@ google.com
ABSTRACT
We adapt the ideas underlying the success of Deep Q-Learning to the continuous
action domain. We present an actor-critic, model-free algorithm based on the de-
terministic policy gradient that can operate over continuous action spaces. Using
the same learning algorithm, network architecture and hyper-parameters, our al-
gorithm robustly solves more than 20 simulated physics tasks, including classic
problems such as cartpole swing-up, dexterous manipulation, legged locomotion
and car driving. Our algorithm is able to find policies whose performance is com-
petitive with those found by a planning algorithm with full access to the dynamics
of the domain and its derivatives. We further demonstrate that for many of the
tasks the algorithm can learn policies “end-to-end”: directly from raw pixel in-
puts.
1 I NTRODUCTION
One of the primary goals of the field of artificial intelligence is to solve complex tasks from unpro-
cessed, high-dimensional, sensory input. Recently, significant progress has been made by combin-
ing advances in deep learning for sensory processing (Krizhevsky et al., 2012) with reinforcement
learning, resulting in the “Deep Q Network” (DQN) algorithm (Mnih et al., 2015) that is capable of
human level performance on many Atari video games using unprocessed pixels for input. To do so,
deep neural network function approximators were used to estimate the action-value function.
However, while DQN solves problems with high-dimensional observation spaces, it can only handle
discrete and low-dimensional action spaces. Many tasks of interest, most notably physical control
tasks, have continuous (real valued) and high dimensional action spaces. DQN cannot be straight-
forwardly applied to continuous domains since it relies on a finding the action that maximizes the
action-value function, which in the continuous valued case requires an iterative optimization process
at every step.
An obvious approach to adapting deep reinforcement learning methods such as DQN to continuous
domains is to to simply discretize the action space. However, this has many limitations, most no-
tably the curse of dimensionality: the number of actions increases exponentially with the number
of degrees of freedom. For example, a 7 degree of freedom system (as in the human arm) with the
coarsest discretization ai∈{−k,0,k}for each joint leads to an action space with dimensionality:
37= 2187 . The situation is even worse for tasks that require fine control of actions as they require
a correspondingly finer grained discretization, leading to an explosion of the number of discrete
actions. Such large action spaces are difficult to explore efficiently, and thus successfully training
DQN-like networks in this context is likely intractable. Additionally, naive discretization of action
spaces needlessly throws away information about the structure of the action domain, which may be
essential for solving many problems.
In this work we present a model-free, off-policy actor-critic algorithm using deep function approx-
imators that can learn policies in high-dimensional, continuous action spaces. Our work is based
∗These authors contributed equally.
1arXiv:1509.02971v6 [cs.LG] 5 Jul 2019 |
10.1101.2024.03.07.584001.pdf | Protein language models are biased by unequal sequence
sampling across the tree of life
Frances Ding frances@berkeley.edu
Department of Electrical Engineering and Computer Sciences
University of California, Berkeley
Jacob Steinhardt jsteinhardt@berkeley.edu
Departments of Statistics and Electrical Engineering and Computer Sciences
University of California, Berkeley
Abstract
Protein language models (pLMs) trained on large protein sequence databases have been
used to understand disease and design novel proteins. In design tasks, the likelihood of a
protein sequence under a pLM is often used as a proxy for protein fitness, so it is critical
to understand what signals likelihoods capture. In this work we find that pLM likelihoods
unintentionally encode a species bias: likelihoods of protein sequences from certain species
are systematically higher, independent of the protein in question. We quantify this bias
and show that it arises in large part because of unequal species representation in popular
protein sequence databases. We further show that the bias can be detrimental for some
protein design applications, such as enhancing thermostability. These results highlight the
importance of understanding and curating pLM training data to mitigate biases and improve
protein design capabilities in under-explored parts of sequence space.
1 Introduction
Proteins are the building blocks and workhorses of life, performing essential roles in human and ecosystem
health. Inspired by advances in natural language processing, many different protein language models (pLMs)
have been trained to model the distribution of naturally occurring protein sequences (Rives et al., 2021;
Elnaggar et al., 2021;Madani et al., 2023;Lin et al., 2023;Alamdari et al., 2023). pLMs have been successfully
used to predict protein 3D structure (Lin et al., 2023), catalytic activity (Eom et al., 2024), and other
biophysical properties (Brandes et al., 2022;Jagota et al., 2023), generally with additional supervision for
fine-tuning. Excitingly, without needing additional supervision, likelihoods from pLMs have been shown to
correlate well with protein fitness, i.e. desirable qualities such as catalytic activity, stability, and binding
affinity (Meier et al., 2021;Notin et al., 2023a;Nijkamp et al., 2023).
Because of this correlation with fitness, pLM likelihoods are increasingly used in protein design. They have
been used to screen for potentially beneficial mutations (Johnson et al., 2023), to design libraries of protein
candidates with higher hit rates than previously state-of-the-art synthetic libraries (Shin et al., 2021), and to
efficiently evolve human antibodies without any additional supervision (Hie et al., 2023).
In this work we find that likelihoods from popular pLMs have a species bias: likelihoods of naturally occurring
protein sequences are systematically higher in certain species, which can be detrimental for some protein
design applications. We describe the extent of this species bias, show that it arises from imbalanced species
representation in the protein sequence databases used for training, and measure the impact of the bias on
protein design.
We first describe a stylized model for pLM training to show intuitively how this bias arises (Section 3), then
support our empirical claims with three main results in Sections 4-6. In Section 4we show that across the
many different proteins we study, certain species almost always have higher pLM likelihoods for their protein
1. CC-BY 4.0 International license available under a(which was not certified by peer review) is the author/funder, who has granted bioRxiv a license to display the preprint in perpetuity. It is made The copyright holder for this preprint this version posted March 12, 2024. ; https://doi.org/10.1101/2024.03.07.584001doi: bioRxiv preprint |
2305.14314.pdf | QL ORA: Efficient Finetuning of Quantized LLMs
Tim Dettmers∗Artidoro Pagnoni∗Ari Holtzman
Luke Zettlemoyer
University of Washington
{dettmers,artidoro,ahai,lsz}@cs.washington.edu
Abstract
We present QLORA, an efficient finetuning approach that reduces memory us-
age enough to finetune a 65B parameter model on a single 48GB GPU while
preserving full 16-bit finetuning task performance. QLORAbackpropagates gradi-
ents through a frozen, 4-bit quantized pretrained language model into Low Rank
Adapters (LoRA). Our best model family, which we name Guanaco , outperforms
all previous openly released models on the Vicuna benchmark, reaching 99.3%
of the performance level of ChatGPT while only requiring 24 hours of finetuning
on a single GPU. QLORAintroduces a number of innovations to save memory
without sacrificing performance: (a) 4-bit NormalFloat (NF4), a new data type that
is information theoretically optimal for normally distributed weights (b) Double
Quantization to reduce the average memory footprint by quantizing the quantization
constants, and (c) Paged Optimizers to manage memory spikes. We use QLORA
to finetune more than 1,000 models, providing a detailed analysis of instruction
following and chatbot performance across 8 instruction datasets, multiple model
types (LLaMA, T5), and model scales that would be infeasible to run with regular
finetuning (e.g. 33B and 65B parameter models). Our results show that QLoRA
finetuning on a small high-quality dataset leads to state-of-the-art results, even
when using smaller models than the previous SoTA. We provide a detailed analysis
of chatbot performance based on both human and GPT-4 evaluations showing that
GPT-4 evaluations are a cheap and reasonable alternative to human evaluation. Fur-
thermore, we find that current chatbot benchmarks are not trustworthy to accurately
evaluate the performance levels of chatbots. A lemon-picked analysis demonstrates
where Guanaco fails compared to ChatGPT. We release all of our models and code,
including CUDA kernels for 4-bit training.2
1 Introduction
Finetuning large language models (LLMs) is a highly effective way to improve their performance,
[40,62,43,61,59,37] and to add desirable or remove undesirable behaviors [ 43,2,4]. However,
finetuning very large models is prohibitively expensive; regular 16-bit finetuning of a LLaMA 65B
parameter model [ 57] requires more than 780 GB of GPU memory. While recent quantization
methods can reduce the memory footprint of LLMs [ 14,13,18,66], such techniques only work for
inference and break down during training [65].
We demonstrate for the first time that it is possible to finetune a quantized 4-bit model without any
performance degradation. Our method, QLORA, uses a novel high-precision technique to quantize
a pretrained model to 4-bit, then adds a small set of learnable Low-rank Adapter weights [ 28]
∗Equal contribution.
2https://github.com/artidoro/qlora andhttps://github.com/TimDettmers/bitsandbytes
Preprint. Under review.arXiv:2305.14314v1 [cs.LG] 23 May 2023 |
2312.16682.pdf | Some things are more CRINGE than others:
Preference Optimization with the Pairwise Cringe Loss
Jing Xu1Andrew Lee1Sainbayar Sukhbaatar1Jason Weston1
Abstract
Practitioners commonly align large language mod-
els using pairwise preferences, i.e., given labels
of the type response A is preferred to response B
for a given input. Perhaps less commonly, meth-
ods have also been developed for binary feed-
back, i.e. training models given labels of type
response A is good or bad. We show how an ex-
isting performant binary feedback method, the
Cringe Loss (Adolphs et al., 2022), can be gen-
eralized to the pairwise preference setting using
a simple soft margin extension. Pairwise Cringe
Loss is straightforward to implement and efficient
to train, and we find it outperforms state-of-the-art
preference optimization algorithms such as PPO
and DPO on the AlpacaFarm benchmark.
1. Introduction
Aligning large language models (LLMs) after pre-training
can give large gains in their performance for downstream
tasks for users (Roller et al., 2020; Gururangan et al., 2020;
Ouyang et al., 2022). Exactly how to implement this align-
ment depends on the labels one collects. Given positive
examples of correct behavior one can perform supervised
fine-tuning (SFT) using standard likelihood-based training.
Given both positive and negative examples ( binary feed-
back), one can use methods such as unlikelihood training
on the negative examples (Welleck et al., 2020), or the more
performant Cringe Loss (Adolphs et al., 2022). However, a
more common approach than using binary feedback, pop-
ularized by work such as Stiennon et al. (2020); Ouyang
et al. (2022); Touvron et al. (2023) is to collect pairwise
preferences of the type response A is better than response B
for a given input. In this case one can use methods such as
PPO (Schulman et al., 2017), DPO (Rafailov et al., 2023)
and other variants.
In this work we seek to compare SFT, binary feedback and
pairwise preference algorithms, and to ask the question: can
1Meta. Correspondence to: Jing Xu <jingxu23@meta.com >.one convert existing binary feedback algorithms to use pair-
wise preference data? In particular the Cringe Loss is a
method for binary feedback, which we show can be general-
ized to the pairwise preference case. The Cringe Loss works
as follows: positive examples use the standard likelihood
training loss, while for a given negative example it contrasts
each token in the negative sequence against other likely
tokens – to encourage the negative sequence to no longer
be the top-ranked sequence. After training on the initial
feedback data, the method is then iterated by labeling data
using the improved model, which was shown to improve
results further. Cringe Loss was shown to perform well with
binary feedback data compared to competing methods, such
as SFT, unlikelihood loss and best-of-N reranking (Adolphs
et al., 2022) and for improving large-scale dialogue systems
(Xu et al., 2023b). However, collecting and using pairwise
preferences for training has currently proven a more popular
approach to developing aligned LLMs.
We thus explore generalizing the Cringe Loss to the pairwise
preference setting. We hence develop the Pairwise Cringe
Loss, by using a differentiable margin-based loss on the
pair of responses. In particular, we add a margin-based
multiplier to the Cringe Loss to turn it on or off depending
on how much probability distance is between the pair. When
the preferred response A becomes much more likely than
the response B, the Cringe Loss is turned off so that the
model capacity is better spent on pairs that are closer in
probabilities.
We experimentally compare competing approaches, includ-
ing binary and pairwise variants of Cringe Loss. The first
task is to reduce repetitions (Arora et al., 2022; Welleck
et al., 2020), which can be measured accurately so it gives
us more control. In this task, we find that Pairwise Cringe
outperforms Binary Cringe, and has performance similar to
DPO, while the Pairwise Cringe generations have slightly
better quality. Next, we employ a more realistic setup us-
ing the AlpacaFarm (Dubois et al., 2023) benchmark that
provides pairwise preference data for general instruction fol-
lowing. Pairwise Cringe Loss again outperforms the Binary
Cringe variant, in addition to SFT, and more importantly out-
performs state-of-the-art methods DPO and PPO. Pairwise
Cringe Loss is simple to implement and efficient to train,
1arXiv:2312.16682v1 [cs.CL] 27 Dec 2023 |
5175-reward-design-with-language-mo.pdf | Published as a conference paper at ICLR 2023
REWARD DESIGN WITH LANGUAGE MODELS
Minae Kwon, Sang Michael Xie, Kalesha Bullard†, Dorsa Sadigh
Stanford University, DeepMind†
{minae ,xie,dorsa }@cs.stanford.edu ,ksbullard@deepmind.com†
ABSTRACT
Reward design in reinforcement learning (RL) is challenging since specifying human
notions of desired behavior may be difficult via reward functions or require many expert
demonstrations. Can we instead cheaply design rewards using a natural language inter-
face? This paper explores how to simplify reward design by prompting a large language
model (LLM) such as GPT-3 as a proxy reward function, where the user provides a tex-
tual prompt containing a few examples (few-shot) or a description (zero-shot) of the de-
sired behavior. Our approach leverages this proxy reward function in an RL framework.
Specifically, users specify a prompt once at the beginning of training. During training,
the LLM evaluates an RL agent’s behavior against the desired behavior described by the
prompt and outputs a corresponding reward signal. The RL agent then uses this reward
to update its behavior. We evaluate whether our approach can train agents aligned with
user objectives in the Ultimatum Game, matrix games, and the DEALORNODEAL
negotiation task. In all three tasks, we show that RL agents trained with our framework
are well-aligned with the user’s objectives and outperform RL agents trained with
reward functions learned via supervised learning. Code and prompts can be found here.
1 I NTRODUCTION
Autonomous agents are becoming increasingly capable with the rise of compute and data. This underscores
the importance for human users to be able to control what policies the agents learn and ensure the policies
are aligned with their objectives. For instance, imagine training an agent to represent users in a salary
negotiation. A working mother fighting for a livable wage may want their agent to be stubborn whereas a
new hire looking to develop a good relationship with the company may want their agent to be more versatile.
Currently, users specify desired behaviors by 1) designing reward functions or 2) providing large amounts of
labeled data. Both approaches are challenging and impractical for different reasons. Designing reward func-
tions is not an intuitive way to specify preferences. For instance, it isn’t straightforward how to write a reward
function for a “versatile” negotiator. Furthermore, designing reward functions that balance between different
objectives — also known as the “reward design problem” — is notoriously difficult because agents are sus-
ceptible to reward hacking (Amodei et al., 2016; Hadfield-Menell et al., 2017). On the other hand, one can
learn a reward function from labeled examples. However, that is not possible with a single example; we need
large amounts of labeled data to capture the nuances of different users’ preferences and objectives, which
has shown to be costly (Zhang et al., 2016). Additionally, both approaches do not generalize well to new
users who have different objectives — we would have to re-design our reward functions or re-collect data.
Our aim is to create an easier way for users to communicate their preferences, where the interface is
more intuitive than crafting a reward function and where they can cheaply specify their preferences with
no more than a few examples. To do this, we leverage large language models (LLMs) that are trained
on internet-scale text data and have shown an impressive ability to learn in-context from few or zero
examples (Brown et al., 2020). Our key insight is that
The scale of data that LLMs have been trained on make them great in-context learners
and also allows them to capture meaningful commonsense priors about human behavior.
Given a few examples or a description demonstrating the user’s objective, an LLM
should be able to provide an accurate instantiation of reward values on a new test
example, allowing for easier generalization to new objectives.
To this end, we explore how to prompt an LLM as a proxy reward function to train RL agents from user
inputs. In our approach, the user specifies an objective with a natural language prompt. Objectives can
1 |
2005.14165.pdf | Language Models are Few-Shot Learners
Tom B. Brown∗Benjamin Mann∗Nick Ryder∗Melanie Subbiah∗
Jared Kaplan†Prafulla Dhariwal Arvind Neelakantan Pranav Shyam Girish Sastry
Amanda Askell Sandhini Agarwal Ariel Herbert-Voss Gretchen Krueger Tom Henighan
Rewon Child Aditya Ramesh Daniel M. Ziegler Jeffrey Wu Clemens Winter
Christopher Hesse Mark Chen Eric Sigler Mateusz Litwin Scott Gray
Benjamin Chess Jack Clark Christopher Berner
Sam McCandlish Alec Radford Ilya Sutskever Dario Amodei
OpenAI
Abstract
Recent work has demonstrated substantial gains on many NLP tasks and benchmarks by pre-training
on a large corpus of text followed by fine-tuning on a specific task. While typically task-agnostic
in architecture, this method still requires task-specific fine-tuning datasets of thousands or tens of
thousands of examples. By contrast, humans can generally perform a new language task from only
a few examples or from simple instructions – something which current NLP systems still largely
struggle to do. Here we show that scaling up language models greatly improves task-agnostic,
few-shot performance, sometimes even reaching competitiveness with prior state-of-the-art fine-
tuning approaches. Specifically, we train GPT-3, an autoregressive language model with 175 billion
parameters, 10x more than any previous non-sparse language model, and test its performance in
the few-shot setting. For all tasks, GPT-3 is applied without any gradient updates or fine-tuning,
with tasks and few-shot demonstrations specified purely via text interaction with the model. GPT-3
achieves strong performance on many NLP datasets, including translation, question-answering, and
cloze tasks, as well as several tasks that require on-the-fly reasoning or domain adaptation, such as
unscrambling words, using a novel word in a sentence, or performing 3-digit arithmetic. At the same
time, we also identify some datasets where GPT-3’s few-shot learning still struggles, as well as some
datasets where GPT-3 faces methodological issues related to training on large web corpora. Finally,
we find that GPT-3 can generate samples of news articles which human evaluators have difficulty
distinguishing from articles written by humans. We discuss broader societal impacts of this finding
and of GPT-3 in general.
∗Equal contribution
†Johns Hopkins University, OpenAI
Author contributions listed at end of paper.arXiv:2005.14165v4 [cs.CL] 22 Jul 2020 |
2304.14767.pdf | Dissecting Recall of Factual Associations in
Auto-Regressive Language Models
Mor Geva1Jasmijn Bastings1Katja Filippova1Amir Globerson2,3
1Google DeepMind2Tel Aviv University3Google Research
{pipek, bastings, katjaf, amirg}@google.com
Abstract
Transformer-based language models (LMs)
are known to capture factual knowledge in
their parameters. While previous work looked
intowhere factual associations are stored, only
little is known about how they are retrieved in-
ternally during inference. We investigate this
question through the lens of information flow.
Given a subject-relation query, we study how
the model aggregates information about the
subject and relation to predict the correct at-
tribute. With interventions on attention edges,
we first identify two critical points where in-
formation propagates to the prediction: one
from the relation positions followed by another
from the subject positions. Next, by analyz-
ing the information at these points, we unveil a
three-step internal mechanism for attribute ex-
traction. First, the representation at the last-
subject position goes through an enrichment
process, driven by the early MLP sublayers,
to encode many subject-related attributes. Sec-
ond, information from the relation propagates
to the prediction. Third, the prediction repre-
sentation “queries” the enriched subject to ex-
tract the attribute. Perhaps surprisingly, this
extraction is typically done via attention heads,
which often encode subject-attribute mappings
in their parameters. Overall, our findings in-
troduce a comprehensive view of how factual
associations are stored and extracted internally
in LMs, facilitating future research on knowl-
edge localization and editing.
1 Introduction
Transformer-based language models (LMs) cap-
ture vast amounts of factual knowledge (Roberts
et al., 2020; Jiang et al., 2020), which they en-
code in their parameters and recall during inference
(Petroni et al., 2019; Cohen et al., 2023). While
recent works focused on identifying where factual
knowledge is encoded in the network (Meng et al.,
2022a; Dai et al., 2022; Wallat et al., 2020), it
remains unclear how this knowledge is extracted
from the model parameters during inference.
Apple
Apple
Beats Music is owned byMLP ATTN
(A) Subject
enrichment
(B) Relation
propagation (C) Attribute
Extraction Figure 1: Illustration of our findings: given subject-
relation query, a subject representation is constructed
via attributes’ enrichment from MLP sublayers (A),
while the relation propagates to the prediction (B). The
attribute is then extracted by the MHSA sublayers (C).
In this work, we investigate this question through
the lens of information flow, across layers and input
positions (Elhage et al., 2021). We focus on a ba-
sic information extraction setting, where a subject
and a relation are given in a sentence (e.g. “Beats
Music is owned by” ), and the next token is the cor-
responding attribute (i.e. “Apple” ). We restrict
our analysis to cases where the model predicts the
correct attribute as the next token, and set out to un-
derstand how internal representations evolve across
the layers to produce the output.
Focusing on modern auto-regressive decoder-
only LMs, such an extraction process could be
implemented in many different ways. Informally,
the model needs to “merge” the subject and relation
in order to be able to extract the right attribute, and
this merger can be conducted at different layers andarXiv:2304.14767v1 [cs.CL] 28 Apr 2023 |
2307.00524.pdf | Large Language Models Enable Few-Shot Clustering
Vijay Viswanathan1, Kiril Gashteovski2,
Carolin Lawrence2, Tongshuang Wu1, Graham Neubig1, 3
1Carnegie Mellon University,2NEC Laboratories Europe,3Inspired Cognition
Abstract
Unlike traditional unsupervised clustering,
semi-supervised clustering allows users to pro-
vide meaningful structure to the data, which
helps the clustering algorithm to match the
user’s intent. Existing approaches to semi-
supervised clustering require a significant
amount of feedback from an expert to improve
the clusters. In this paper, we ask whether
a large language model can amplify an ex-
pert’s guidance to enable query-efficient, few-
shot semi-supervised text clustering. We show
that LLMs are surprisingly effective at im-
proving clustering. We explore three stages
where LLMs can be incorporated into cluster-
ing: before clustering (improving input fea-
tures), during clustering (by providing con-
straints to the clusterer), and after clustering
(using LLMs post-correction). We find incor-
porating LLMs in the first two stages can rou-
tinely provide significant improvements in clus-
ter quality, and that LLMs enable a user to
make trade-offs between cost and accuracy to
produce desired clusters. We release our code
and LLM prompts for the public to use.1
1 Introduction
Unsupervised clustering aims to do an impossible
task: organize data in a way that satisfies a domain
expert’s needs without any specification of what
those needs are. Clustering, by its nature, is fun-
damentally an underspecified problem. According
to Caruana (2013), this underspecification makes
clustering “probably approximately useless.”
Semi-supervised clustering, on the other hand,
aims to solve this problem by enabling the domain
expert to guide the clustering algorithm (Bae et al.,
2020). Prior works have introduced different types
of interaction between an expert and a clustering
algorithm, such as initializing clusters with hand-
picked seed points (Basu et al., 2002), specifying
1https://github.com/viswavi/
few-shot-clustering
LLM Traditional
Semi-Supervised
Clustering
LLM-Guided
Few-Shot
Clustering Figure 1: In traditional semi-supervised clustering, a
user provides a large amount of feedback to the clusterer.
In our approach, the user prompts an LLM with a small
amount of feedback. The LLM then generates a large
amount of pseudo-feedback for the clusterer.
pairwise constraints (Basu et al., 2004; Zhang et al.,
2019), providing feature feedback (Dasgupta and
Ng, 2010), splitting or merging clusters (Awasthi
et al., 2013), or locking one cluster and refining the
rest (Coden et al., 2017). These interfaces have all
been shown to give experts control of the final clus-
ters. However, they require significant effort from
the expert. For example, in a simulation that uses
split/merge, pairwise constraint, and lock/refine in-
teractions (Coden et al., 2017), it took between 20
and 100 human-machine interactions to get any
clustering algorithm to produce clusters that fit the
human’s needs. Therefore, for large, real-world
datasets with a large number of possible clusters,
the feedback cost required by interactive clustering
algorithms can be immense.
Building on a body of recent work that uses
Large Language Models (LLMs) as noisy simu-
lations of human decision-making (Fu et al., 2023;
Horton, 2023; Park et al., 2023), we propose a dif-
ferent approach for semi-supervised text clustering.
In particular, we answer the following research
question: Can an expert provide a few demonstra-
tions of their desired interaction (e.g., pairwise
constraints) to a large language model, then let the
LLM direct the clustering algorithm?arXiv:2307.00524v1 [cs.CL] 2 Jul 2023 |
deep-boltzmann-machines.pdf | Deep BoltzmannMachines
Ruslan Salakhutdinov
DepartmentofComputerScience
UniversityofToronto
rsalakhu@cs.toronto.eduGeoffreyHinton
DepartmentofComputerScience
UniversityofToronto
hinton@cs.toronto.edu
Abstract
We present a new learning algorithm for Boltz-
mann machines that contain many layers of hid-
den variables. Data-dependent expectations are
estimated using a variational approximationthat
tends to focus on a single mode, and data-
independent expectations are approximated us-
ing persistent Markov chains. The use of two
quite different techniques for estimating the two
types of expectation that enter into the gradient
of the log-likelihood makes it practical to learn
Boltzmann machines with multiple hidden lay-
ers andmillionsof parameters. The learningcan
be mademoreefficient by usinga layer-by-layer
“pre-training” phase that allows variational in-
ference to be initialized with a single bottom-
up pass. We present results on the MNIST and
NORB datasets showing that deep Boltzmann
machines learn good generativemodels and per-
form well on handwritten digit and visual object
recognitiontasks.
1 Introduction
The original learning algorithm for Boltzmann machines
(Hinton and Sejnowski, 1983) required randomly initial-
ized Markov chains to approach their equilibrium distri-
butions in order to estimate the data-dependent and data-
independent expectations that a connected pair of binary
variableswouldbothbeon. Thedifferenceofthesetwoex-
pectationsisthegradientrequiredformaximumlikelihood
learning. Even with the help of simulated annealing, this
learning procedure was too slow to be practical. Learning
canbemademuchmoreefficientinarestrictedBoltzmann
machine(RBM),whichhasnoconnectionsbetweenhidden
Appearing in Proceedings of the 12thInternational Confe-rence
onArtificialIntelligenceandStatistics(AISTATS)2009,C learwa-
terBeach,Florida,USA.Volume5ofJMLR:W&CP5. Copyright
2009 by the authors.units(Hinton,2002). Multiplehiddenlayerscanbelearned
by treating the hidden activities of one RBM as the data
for training a higher-level RBM (Hinton et al., 2006; Hin-
ton and Salakhutdinov,2006). However, if multiple layers
arelearnedinthisgreedy,layer-by-layerway,theresulti ng
composite model is nota multilayer Boltzmann machine
(Hintonetal.,2006). Itisahybridgenerativemodelcalled
a“deepbeliefnet”thathasundirectedconnectionsbetween
its top two layers and downward directed connections be-
tweenall itslowerlayers.
In this paper we present a much more efficient learning
procedure for fully general Boltzmann machines. We also
show that if the connections between hidden units are re-
stricted in such a way that the hidden units form multi-
ple layers, it is possible to use a stack of slightly modified
RBM’s to initialize the weights of a deep Boltzmann ma-
chinebeforeapplyingournewlearningprocedure.
2 Boltzmann Machines (BM's)
A Boltzmann machine is a network of symmetrically cou-
pledstochasticbinaryunits. Itcontainsasetofvisibleun its
v∈{0,1}D, and a set of hidden units h∈{0,1}P(see
Fig.1). Theenergyofthestate {v,h}is definedas:
E(v,h;θ) =−1
2v⊤Lv−1
2h⊤Jh−v⊤Wh,(1)
where θ={W,L,J}arethemodelparameters1:W,L,J
represent visible-to-hidden, visible-to-visible, and hi dden-
to-hidden symmetric interaction terms. The diagonal ele-
ments of LandJare set to 0. The probability that the
modelassignstoa visiblevector vis:
p(v;θ) =p∗(v;θ)
Z(θ)=1
Z(θ)∑
hexp (−E(v,h;θ)),(2)
Z(θ) =∑
v∑
hexp (−E(v,h;θ)),(3)
where p∗denotes unnormalized probability, and Z(θ)is
the partition function. The conditional distributions over
1We have omittedthe bias terms for clarityof presentation |
2305.16264.pdf | Scaling Data-Constrained Language Models
Niklas Muennighoff1Alexander M. Rush1Boaz Barak2Teven Le Scao1
Aleksandra Piktus1Nouamane Tazi1Sampo Pyysalo3Thomas Wolf1Colin Raffel1
1Hugging Face2Harvard University3University of Turku
n.muennighoff@gmail.com
Abstract
The current trend of scaling language models involves increasing both parameter
count and training dataset size. Extrapolating this trend suggests that training
dataset size may soon be limited by the amount of text data available on the internet.
Motivated by this limit, we investigate scaling language models in data-constrained
regimes. Specifically, we run a large set of experiments varying the extent of data
repetition and compute budget, ranging up to 900 billion training tokens and 9
billion parameter models. We find that with constrained data for a fixed compute
budget, training with up to 4 epochs of repeated data yields negligible changes to
loss compared to having unique data. However, with more repetition, the value of
adding compute eventually decays to zero. We propose and empirically validate
a scaling law for compute optimality that accounts for the decreasing value of
repeated tokens and excess parameters. Finally, we experiment with approaches
mitigating data scarcity, including augmenting the training dataset with code data
or removing commonly used filters. Models and datasets from our 400 training runs
are freely available at https://github.com/huggingface/datablations .
12B
(1)48B
(4)120B
(10)480B
(40)1.2T
(100)
T okens
(Epochs)2.02.22.42.62.83.03.23.4Final test loss
Up to4 epochs
repeating is almost
as good as new dataRapidly diminishing
returns for
more repetitionsAt40 epochs,
repeating is worthlessReturn on compute when repeating
178B
(7.1)242B
(9.7)
T okens
(Epochs)6.34B8.67BParameters
Loss: 2.376
Loss: 2.3591022 FLOPsAllocating compute when repeating
Data-Constrained Scaling Laws
Models trained
Loss assuming repeated data is worth the same as new data
Loss predicted by our data-constrained scaling lawsRegime of same compute (IsoFLOP)
Efficient frontier assuming repeated data is worth the same as new data
Efficient frontier predicted by our data-constrained scaling laws
Figure 1: Return andAllocation when repeating data. (Left): Loss of LLMs (4.2B parameters)
scaled on repeated data decays predictably (§6). (Right): To maximize performance when repeating,
our data-constrained scaling laws and empirical data suggest training smaller models for more epochs
in contrast to what assuming Chinchilla scaling laws [ 42] hold for repeated data would predict (§5).
37th Conference on Neural Information Processing Systems (NeurIPS 2023).arXiv:2305.16264v4 [cs.CL] 26 Oct 2023 |
Estimation-of-Entropy-and-Mutual-Information.pdf | ARTICLE Communicated by Jonathan Victor
Estimation of Entropy and Mutual Information
Liam Paninski
liam@cns.nyu.edu
Center for Neural Science, New York University, New York, NY 10003, U.S.A.
We present some new results on the nonparametric estimation of entropy
and mutual information. First, we use an exact local expansion of theentropy function to prove almost sure consistency and central limit the-orems for three of the most commonly used discretized information esti-mators. The setup is related to Grenander’s method of sieves and placesno assumptions on the underlying probability measure generating thedata. Second, we prove a converse to these consistency theorems, demon-strating that a misapplication of the most common estimation techniquesleads to an arbitrarily poor estimate of the true information, even givenunlimited data. This “inconsistency” theorem leads to an analytical ap-proximation of the bias, valid in surprisingly small sample regimes andmore accurate than the usual
1
Nformula of Miller and Madow over a large
region of parameter space. The two most practical implications of theseresults are negative: (1) information estimates in a certain data regime arelikely contaminated by bias, even if “bias-corrected” estimators are used,and (2) confidence intervals calculated by standard techniques drasticallyunderestimate the error of the most common estimation methods.
Finally, we note a very useful connection between the bias of entropy
estimators and a certain polynomial approximation problem. By castingbias calculation problems in this approximation theory framework, weobtain the best possible generalization of known asymptotic bias results.More interesting, this framework leads to an estimator with some niceproperties: the estimator comes equipped with rigorous bounds on themaximum error over all possible underlying probability distributions,and this maximum error turns out to be surprisingly small. We demon-strate the application of this new estimator on both real and simulateddata.
1 Introduction
The mathematical theory of information transmission represents a pinna-
cle of statistical research: the ideas are at once beautiful and applicableto a remarkably wide variety of questions. While psychologists and neu-rophysiologists began to apply these concepts almost immediately aftertheir introduction, the past decade has seen a dramatic increase in the
Neural Computation 15, 1191–1253 (2003) c⃝2003 Massachusetts Institute of Technology |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.