\documentclass[11pt,letterpaper]{article}
\usepackage{emnlp2017}
\usepackage{times}
\usepackage{mdwlist}
\usepackage{latexsym}
\usepackage{mathtools}
\usepackage{amsfonts}
\usepackage{amssymb}
\usepackage{booktabs}
\usepackage{xcolor}
\usepackage{enumitem}
\usepackage{lipsum}
\usepackage{graphicx}
\usepackage{subcaption}
\usepackage{xspace}
\usepackage{algorithmic,algorithm}
\usepackage{bbm}

\renewcommand{\arraystretch}{1.2}
\newcommand{\norm}[1]{\left\lVert#1\right\rVert}
\renewcommand{\vec}[1]{\boldsymbol{#1}}

\renewcommand{\equationautorefname}{Eq}
\renewcommand{\sectionautorefname}{\S\kern-0.2em}
\renewcommand{\subsectionautorefname}{\S\kern-0.2em}
\renewcommand{\subsubsectionautorefname}{\S\kern-0.2em}

\newcommand{\bleu}{\textsc{Bleu}\xspace}
\newcommand{\persentence}{Per-Sentence \bleu}
\newcommand{\heldout}{Heldout \bleu}

\newcommand{\halcomment}[1]{
  \colorbox{magenta!20}{  \parbox{.8\linewidth}{ Hal:  #1}  }}
\newcommand{\jbgcomment}[1]{  \colorbox{green!20}{  \parbox{.8\linewidth}{ Jordan:  #1}  }}
\newcommand{\kcomment}[1]{  \colorbox{cyan!20}{  \parbox{.8\linewidth}{ K:  #1}  }}


\newcommand{\ignore}[1]{}

\emnlpfinalcopy

\def\emnlppaperid{1355}



\newcommand\BibTeX{B{\sc ib}\TeX}


\title{Reinforcement Learning for Bandit Neural Machine Translation with Simulated Human Feedback}

\newcommand{\idcs}{${}^\odot$}
\newcommand{\idlsc}{${}^\spadesuit$}
\newcommand{\idumiacs}{${}^\diamondsuit$}
\newcommand{\idischool}{${}^\clubsuit$}
\newcommand{\idmsr}{${}^\heartsuit$}

\author{Khanh Nguyen\idcs\idumiacs \and Hal Daum{\'e} III\idcs\idlsc\idumiacs\idmsr \and Jordan Boyd-Graber\idcs\idlsc\idischool\idumiacs \\
  University of Maryland: Computer Science\idcs, Language Science\idlsc, iSchool\idischool, UMIACS\idumiacs\\
  Microsoft Research, New York\idmsr\\
  \tt{ \{kxnguyen,hal,jbg\}@umiacs.umd.edu }
 }





\date{}

\begin{document}

\abovedisplayskip=12pt plus 3pt minus 9pt
\abovedisplayshortskip=0pt plus 3pt
\belowdisplayskip=12pt plus 3pt minus 9pt
\belowdisplayshortskip=7pt plus 3pt minus 4pt

\maketitle

\begin{abstract}
  Machine translation is a natural candidate problem for reinforcement
learning from human feedback: users provide quick, dirty ratings on candidate translations
to guide a system to improve.  Yet, current neural machine translation training focuses
on expensive human-generated reference translations.  We describe a reinforcement learning algorithm that improves neural machine translation systems from simulated human feedback.
Our algorithm combines the advantage actor-critic algorithm~\cite{mnih2016asynchronous}
with the attention-based neural encoder-decoder architecture~\cite{luong2015effective}.
This algorithm (a) is well-designed for problems with a large action space and delayed rewards,
(b) effectively optimizes traditional corpus-level machine translation metrics, and
(c) is robust to skewed, high-variance, granular feedback modeled after actual human behaviors.
 \end{abstract}


\section{Introduction}

Bandit structured prediction is the task of learning to solve complex joint prediction problems (like parsing or machine translation) under a very limited feedback model:
a system must produce a \emph{single} structured output (e.g., translation) and then the world
reveals a \emph{score} that measures how good or bad that output is, but provides neither a ``correct'' output nor feedback on any other possible output \cite{daume15lols,sokolov2015coactive}.
Because of the extreme sparsity of this feedback, a common experimental setup is that one pre-trains a good-but-not-great ``reference'' system based on whatever labeled data is available, and then seeks to improve it over time using this bandit feedback.
A common motivation for this problem setting is cost.
In the case of translation, bilingual ``experts'' can read a source sentence and a possible translation, and can much more quickly provide a rating of that translation than they can produce a full translation on their own.
Furthermore, one can often collect even less expensive ratings from ``non-experts'' who may or may not be bilingual \cite{hu2014crowdsourced}.
Breaking this reliance on expensive data could unlock previously
ignored languages and speed development of broad-coverage machine translation systems.


All work on bandit structured prediction we know makes an important simplifying assumption: the \emph{score} provided by the world is \emph{exactly} the score the system must optimize (\autoref{sec:problem}).
In the case of parsing, the score is attachment score; in the case of machine translation, the score is (sentence-level) \bleu.
While this simplifying assumption has been incredibly useful in building algorithms, it is highly unrealistic.
Any time we want to optimize a system by collecting user feedback, we must take into account:
\begin{enumerate}[noitemsep,nolistsep]
\item The metric we care about (e.g., expert ratings) may not correlate perfectly with the measure that the reference system was trained on (e.g., \bleu or log likelihood);
\item Human judgments might be more granular than traditional
  continuous metrics (e.g., thumbs up vs. thumbs down);
\item Human feedback have high \emph{variance} (e.g., different raters
  might give different responses given the same system output);
\item Human feedback might be substantially \emph{skewed} (e.g., a
  rater may think all system outputs are poor).
\end{enumerate}
Our first contribution is a strategy to
simulate expert and non-expert ratings to evaluate the robustness of bandit structured prediction algorithms in general, in a more realistic environment (\autoref{sec:noise_model}).
We construct a family of perturbations to capture three attributes: \emph{granularity}, \emph{variance}, and \emph{skew}.
We apply these perturbations on automatically generated scores to simulate noisy human ratings. 
To make our simulated ratings as realistic as possible, we study recent human evaluation data \cite{graham2017can} and fit models to match the noise profiles in actual human ratings (\autoref{sec:variance}).

Our second contribution is a reinforcement learning solution to bandit structured prediction and a study of its robustness to these simulated human ratings (\autoref{sec:method}).\footnote{Our code is at \url{https://github.com/khanhptnk/bandit-nmt} (in PyTorch).}
We combine an encoder-decoder architecture of machine translation~\cite{luong2015effective} with
the advantage actor-critic algorithm~\cite{mnih2016asynchronous}, yielding an approach that is
simple to implement but works on low-resource bandit machine translation.
Even with substantially restricted granularity, with high variance feedback, or with skewed rewards, this combination improves pre-trained models (\autoref{sec:results}).
In particular, under realistic settings of our noise parameters, the
algorithm's online reward and final held-out accuracies do not significantly degrade from a noise-free setting.















 
\section{Bandit Machine Translation} \label{sec:problem}


The bandit structured prediction problem \cite{daume15lols,sokolov2015coactive} is an extension of the contextual bandits problem \cite{kakade2008efficient,langford2008epoch} to structured prediction.
Bandit structured prediction operates over time $i=1 \dots K$ as:
\begin{enumerate}[nolistsep,noitemsep]
  \item World reveals context $\vec x^{(i)}$
  \item Algorithm predicts structured output $\hat{\vec y}^{(i)}$
  \item World reveals reward $R \left(\hat{\vec y}^{(i)}, \vec x^{(i)} \right)$
\end{enumerate}

We consider the problem of \emph{learning to translate from human ratings} in
a bandit structured prediction framework.
In each round, a translation model receives a source sentence $\vec x^{(i)}$, produces a
translation $\hat{\vec y}^{(i)}$, and receives a rating $R\left( \hat{\vec y}^{(i)}, \vec x^{(i)} \right)$
 from a human that reflects the quality of the translation.
We seek an algorithm that achieves high reward over $K$ rounds (high cumulative reward).
The challenge is that even though the model knows how good the translation is, 
it knows neither \emph{where} its mistakes are nor \emph{what} the ``correct'' translation looks like.
It must balance exploration (finding new good predictions) with exploitation (producing predictions it already knows are good).
This is especially difficult in a task like machine translation, where, for a twenty token sentence with a vocabulary size of $50k$, there are approximately $10^{94}$ possible outputs, of which the algorithm gets to test exactly one.

\begin{figure}[t]
  \centering
  \includegraphics[width=\linewidth]{images/facebook3}
  \caption{A translation rating interface provided by Facebook. Users see a sentence followed by its machined-generated translation and can give ratings from one to five stars. }
  \label{fig:facebook}
\end{figure}

Despite these challenges, learning from non-expert ratings is desirable.
In real-world scenarios, non-expert ratings are easy to collect but
other stronger forms of feedback are prohibitively expensive.
Platforms that offer translations can get quick feedback ``for free''
from their users to improve their systems (Figure \ref{fig:facebook}).
Even in a setting in which annotators are paid, it is much less expensive to
ask a bilingual speaker to provide a rating of a proposed translation
than it is to pay a professional translator to produce one from scratch.


\ignore{
Another scenario is when we want to train the translation model to adapt to user
preferences.
Since preferences are usually easy to perceive but hard to formalize,
it is easier for user to provide ratings based on their preferences than
to construct explicit examples.}








 
\section{Effective Algorithm for Bandit MT} \label{sec:method}
This section describes the
neural machine translation architecture of our system (\autoref{sec:neural_mt}).
We formulate bandit neural machine translation as a reinforcement learning
problem (\autoref{sec:formulation}) and discuss why standard
actor-critic algorithms struggle with this problem
(\autoref{sec:why_ac_fail}).
Finally, we describe a more effective training approach based on the advantage
actor-critic algorithm (\autoref{sec:a2c}).

\subsection{Neural machine translation}
\label{sec:neural_mt}

Our neural machine translation (NMT) model is a neural encoder-decoder
that directly computes
the probability of translating a
target sentence $\vec y = (y_1, \cdots, y_m)$ from source sentence $\vec x$:
\begin{align}
    P_{\vec \theta}(\vec y \mid \vec x) = \prod_{t = 1}^m P_{\vec \theta}(y_t \mid \vec y_{<t}, \vec x)
  \end{align}
where $P_{\vec \theta}(y_t \mid \vec y_{<t}, \vec x)$ is the probability of
outputting the next word $y_t$ at time step $t$ given a translation prefix $\vec y_{<t}$ and
a source sentence $\vec x$.

We use an encoder-decoder NMT architecture with global attention~\cite{luong2015effective}, where
both the encoder and decoder are recurrent neural networks (RNN)
(see Appendix~A for a more detailed description).
These models are normally trained by supervised learning, but as reference translations are
not available in our setting, we use reinforcement learning methods, which only require
numerical feedback to function.

\subsection{Bandit NMT as Reinforcement Learning} \label{sec:formulation}

NMT generating process can be viewed as a Markov decision process
on a continuous state space.
The states are the hidden vectors $\vec h_t^{dec}$ generated by the
decoder.
The action space is the target language's vocabulary.

To generate a translation from a source sentence $\vec x$, an NMT model starts at an
initial state
$\vec h_0^{dec}$: a representation of $\vec x$ computed by the encoder.
At time step $t$, the model decides the next action to take
by defining a stochastic policy $P_{\vec \theta}(y_t \mid \vec y_{<t}, \vec x)$,
which is directly parametrized by the parameters $\vec \theta$ of the model.
This policy takes the current state $\vec h_{t - 1}^{dec}$ as input and produces a
probability distribution over all actions (target vocabulary words).
The next action $\hat{y}_t$ is chosen by taking $\arg\max$ or sampling from this distribution.
The model computes the next state $\vec h_t^{dec}$ by updating
the current state $\vec h_{t - 1}^{dec}$ by the action taken $\hat{y}_t$.



The objective of bandit NMT is to find a policy that maximizes the expected
reward of translations sampled from the model's policy:
\begin{equation}
  \max_{\vec \theta}\mathcal{L}_{pg}(\vec \theta) =
  \max_{\vec \theta} \mathbb{E}_{\substack{\vec x \sim D_{\textrm{tr}}\\\hat{\vec y} \sim P_{\vec \theta}(\cdot \mid \vec x)}}
  \Big[ R(\hat{\vec y}, \vec x)  \Big]
  \label{eqn:reward_max}
\end{equation} where $D_{tr}$ is the training set and $R$ is the reward function (the rater).\footnote{Our raters are \emph{stochastic}, but for simplicity we denote the reward as a function; it should be expected reward.}
We optimize this objective function with policy gradient methods.
For a fixed $\vec x$, the gradient of the objective in \autoref{eqn:reward_max} is:
\begin{align}
\label{eqn:pg_grad}
&  \nabla_{\vec \theta} \mathcal{L}_{pg}(\vec \theta) =
\mathbb{E}_{\hat{\vec y} \sim P_{\vec \theta}(\cdot)}
  \left[ R(\hat{\vec y}) \nabla_{\vec \theta} \log P_{\vec \theta}(\hat{\vec y})  \right]  \\
  &= \mathbb{E}_{\substack{\hat{\vec y} \sim P_{\vec \theta}(\cdot)}}
  \Big[
    \sum_{t = 1}^m \sum_{y_t}
    Q(\hat{\vec y}_{<t}, \hat{y}_t)
    \nabla_{\vec \theta}
    P_{\vec \theta}(\hat{y}_t \mid \hat{\vec y}_{<t})
    \Big] \nonumber
  \end{align} where $Q(\hat{\vec y}_{<t}, \hat{y}_t)$ is the expected future reward of 
$\hat{y}_t$ given the current prefix $\hat{\vec y}_{<t}$, then continuing
sampling from $P_{\vec \theta}$ to complete the translation:
  \begin{align}
  Q(\hat{\vec y}_{<t}, \hat{y}_t) &=
  \mathbb{E}_{\hat{\vec y}' \sim P_{\vec \theta}(\cdot \mid \vec x)}
   \left[
     \tilde{R}(\hat{\vec y}', \vec x)
  \right] \\
  \textrm{with } \tilde{R}(\hat{\vec y}', \vec x) & \equiv
   R(\hat{\vec y}', \vec x)
   \mathbbm{1}
   \left\{ \hat{\vec y}'_{<t} = \hat{\vec y}_{<t}, \hat{y}'_t = \hat{y}_t \right\} \nonumber
\end{align}
$\mathbbm{1}\{\cdot\}$ is the indicator function, which returns 1 if the logic inside the bracket is true and returns 0 otherwise.

The gradient in \autoref{eqn:pg_grad} requires rating all possible
translations, which is not feasible in bandit NMT.
Na\"ive Monte Carlo reinforcement learning methods such as REINFORCE~\cite{williams1992simple}
estimates $Q$ values by sample means but yields very high variance when the action space is large,
leading to training instability.

\subsection{Why are actor-critic algorithms not effective for bandit NMT?}
\label{sec:why_ac_fail}

Reinforcement learning methods that rely on function approximation are preferred when tackling
bandit structured prediction with a large action space because they can capture
similarities between structures and generalize to unseen regions of the structure space.
The actor-critic algorithm~\cite{konda1999actor} uses function approximation to directly model
the $Q$ function, called the \emph{critic} model. 
In our early attempts on bandit NMT, we adapted the actor-critic algorithm for NMT 
in \citet{bahdanau2016actor}, which employs the algorithm in a supervised learning setting.
Specifically, while an encoder-decoder critic model $Q_{\vec \omega}$
as a substitute for the
true $Q$ function in \autoref{eqn:pg_grad} enables
taking the full sum inside the expectation (because
the critic model can be queried with any state-action pair), we are unable to obtain reasonable results with this approach.



Nevertheless, insights into why this approach fails on our problem 
explains the effectiveness of the approach discussed in the next section.
There are two properties in \citet{bahdanau2016actor} that our problem lacks but are key
elements for a successful actor-critic.
The first is access to reference translations: while the critic model is able
to observe reference translations during training in their setting,
bandit NMT assumes those are never available.
The second is per-step rewards: while the reward function in their setting
is known and can be exploited to compute immediate rewards after taking each action,
in bandit NMT, the actor-critic algorithm struggles with credit assignment
because it only receives reward when a translation is completed.
\citet{bahdanau2016actor} report that
the algorithm degrades if rewards are delayed until the end,
consistent with our observations.

With an enormous action space of bandit NMT, approximating gradients with the $Q$ critic model 
induces biases and potentially drives the model to wrong optima.
Values of rarely taken actions are often overestimated without an explicit constraint between $Q$ values of actions (e.g., a sum-to-one constraint).
\citet{bahdanau2016actor} add an ad-hoc regularization term to the loss function to mitigate this issue and further stablizes the algorithm with a delay update scheme, but at the same time introduces extra tuning hyper-parameters.





\subsection{Advantage Actor-Critic for Bandit NMT} \label{sec:a2c}

We follow the approach of advantage actor-critic~\cite[A2C]{mnih2016asynchronous} and combine it with the neural encoder-decoder architecture.
The resulting algorithm---which we call NED-A2C---approximates the gradient in \autoref{eqn:pg_grad}
by a single sample $\hat{\vec y} \sim P(\cdot \mid \hat{\vec x})$ and centers the
reward $R(\hat{\vec y})$ using
the state-specific expected future reward $V(\hat{\vec y}_{<t})$ to reduce variance:
\begin{align}
\label{eqn:a2c_grad}
  \nabla_{\vec \theta} \mathcal{L}_{pg}(\vec \theta) & \approx
  \sum_{t = 1}^m
  \bar{R}_t(\hat{\vec y})
  \nabla_{\vec \theta}
  \log P_{\vec \theta}(\hat{y}_t \mid \hat{\vec y}_{<t}) \\
  \textrm{with }\bar{R}_t(\hat{\vec y}) &\equiv R(\hat{\vec y}) - V(\hat{\vec y}_{<t}) \nonumber \\
  V(\hat{\vec y}_{<t}) &\equiv \mathbb{E}_{\hat{y}'_t \sim P(\cdot \mid \hat{\vec y}_{<t})}
  \left[  Q(\hat{\vec y}_{<t}, \hat{y}'_t) \right] \nonumber
\end{align}

We train a separate attention-based encoder-decoder model $V_{\vec \omega}$ to estimate
$V$ values.
This model encodes a source sentence $\vec x$ and decodes a sampled
translation $\hat{\vec y}$.
At time step $t$, it computes
$V_{\vec \omega}(\hat{\vec y}_{<t}, \vec x) = \vec w^{\top} \vec h_t^{crt}$,
where $\vec h^{crt}_t$ is the current decoder's hidden vector and
$\vec w$ is a learned weight vector.
The critic model minimizes the MSE between its estimates and the true
values:
\begin{align}
 \label{eqn:vnet}
  \mathcal{L}_{crt}(\vec \omega) & = \mathbb{E}_{\substack{\vec x \sim D_{\textrm{tr}}\\\hat{\vec y} \sim P_{\vec \theta}(\cdot \mid \vec x)}} \left[
  \sum_{t = 1}^m L_t(\hat{\vec y}, \vec x) \right] \\
  \textrm{with } L_t(\hat{\vec y}, \vec x) & \equiv 
  \left[ 
   V_{\vec \omega}(\hat{\vec y}_{<t}, \vec x) - R(\hat{\vec y}, \vec x)   \right]^2. \nonumber
\end{align} We use a gradient approximation to update $\vec \omega$ for a fixed $\vec x$ and $\hat{\vec y} \sim P(\cdot \mid \hat{\vec x})$:
\begin{equation}
  \nabla_{\vec \omega} \mathcal{L}_{crt}(\vec \omega) \approx
 \sum_{t = 1}^m \left[ 
  V_{\vec \omega}(\hat{\vec y}_{<t}) - R(\hat{\vec y}) 
\right]
                      \nabla_{\vec \omega} V_{\vec \omega}(\hat{\vec y}_{<t})
 \label{eqn:critic_grad}
\end{equation} 

NED-A2C is better suited for problems with a large action space and has other
advantages over actor-critic.
For large action spaces, approximating gradients using the $V$ critic model induces 
lower biases than using the $Q$ critic model.
As implied by its definition, the $V$ model is robust to biases incurred by
rarely taken actions since rewards of those actions are weighted by very small
probabilities in the expectation.
In addition, the $V$ model has a much smaller
number of parameters and thus is more sample-efficient and more stable to train than the $Q$ model.
These attractive properties were not studied in A2C's original
paper~\cite{mnih2016asynchronous}.

\begin{algorithm}
  \caption{The NED-A2C algorithm for bandit NMT.}
  \label{alg:a2c}
\begin{algorithmic}[1]
  \small
  \FOR{$i = 1 \cdots K$}
  \STATE receive a source sentence $\vec x^{(i)}$
  \STATE sample a translation: $\hat{\vec y}^{(i)} \sim P_{\vec \theta}(\cdot \mid \vec x^{(i)})$
  \STATE receive reward $R(\hat{\vec y}^{(i)}, \vec x^{(i)})$
  \STATE update the NMT model using \autoref{eqn:a2c_grad}.
  \STATE update the critic model using \autoref{eqn:critic_grad}.
  \ENDFOR
\end{algorithmic}
\end{algorithm}

Algorithm \ref{alg:a2c} summarizes NED-A2C for bandit NMT.
For each $\vec x$, we draw a single sample $\hat{\vec y}$ from the NMT model, which
is used for both estimating gradients of the NMT model and the critic model.
We run this algorithm with mini-batches of $\vec x$ and aggregate
gradients over all $\vec x$ in a mini-batch for each update.
Although our focus is on bandit NMT, this algorithm naturally works with any
bandit structured prediction problem.


 
\section{Modeling Imperfect Ratings} \label{sec:noise_model}
Our goal is to establish the feasibility of using \emph{real} human feedback to optimize a machine translation system,
in a setting where one can collect \emph{expert} feedback as well as a setting in which one only collects \emph{non-expert} feedback.
In all cases, we consider the expert feedback to be the ``gold standard'' that we wish to optimize.
To establish the feasibility of driving learning from human feedback \emph{without} doing a full, costly user study, we begin with a simulation study.
The key aspects (\autoref{fig:perturbation}) of human feedback we capture are:
(a) mismatch between training objective and feedback-maximizing objective,
(b) human ratings typically are binned (\autoref{sec:granular}),
(c) individual human ratings have high variance (\autoref{sec:variance}),
and (d) non-expert ratings can be skewed with respect to expert ratings (\autoref{sec:skew}).

In our simulated study, we begin by modeling gold standard human ratings using add-one-smoothed sentence-level \bleu~\cite{chen2014systematic}.\footnote{``Smoothing 2'' in~\citet{chen2014systematic}. We also add one to lengths when computing the brevity penalty.}
Our evaluation criteria, therefore, is average sentence-\bleu over the run of our algorithm.
However, in any realistic scenario, human feedback will vary from its average, and so the reward that our algorithm receives will be a \emph{perturbed} variant of sentence-\bleu.
In particular, if the sentence-\bleu score is $s \in [0, 1]$, the algorithm will only observe $s' \sim \textrm{pert}(s)$, where $\textrm{pert}$ is a perturbation distribution.
Because our reference machine translation system is pre-trained using log-likelihood, there is already an (a) mismatch between training objective and feedback, so we focus on (b-d) below.


\begin{figure}[t]
  \centering
  \includegraphics[width=0.8\linewidth]{images/perturbation}
  \caption{Examples of how our perturbation functions change the ``true''
    feedback distribution (left) to ones that better capture features
    found in human feedback (right).}
  \label{fig:perturbation}

\end{figure}

\subsection{Humans Provide Granular Feedback} \label{sec:granular}


When collecting human feedback, it is often more effective to collect discrete \emph{binned} scores.
A classic example is the Likert scale for human agreement \cite{likert:1932} or star ratings for product reviews.
Insisting that human judges provide continuous values (or feedback at too fine a
granularity) can demotivate raters without improving rating quality \cite{Preston20001}.

To model granular feedback, we use a simple rounding procedure.
Given an integer parameter $g$ for degree of granularity, we define: 
\begin{align}
  \textrm{pert}^{\textrm{gran}}(s;g)
  &= \frac 1 g \textrm{round}(g s)
\end{align}
This perturbation function divides the range of possible outputs into $g+1$ bins.
For example, for $g=5$, we obtain bins $[0,0.1)$, $[0.1, 0.3)$, $[0.3, 0.5)$, $[0.5, 0.7)$, $[0.7, 0.9)$ and $[0.9,1.0]$. Since most sentence-\bleu scores are much closer to zero than to one, many of the larger bins are frequently vacant.


\subsection{Experts Have High Variance} \label{sec:variance}

Human feedback has high variance around its expected value.
A natural goal for a variance model of human annotators is to simulate---as closely as possible---how human raters actually perform.
We use human evaluation data recently collected as part of the WMT shared task~\cite{graham2017can}.
The data consist of 7200 sentences multiply annotated by giving non-expert annotators on Amazon Mechanical Turk a reference sentence and a \emph{single} system translation, and asking the raters to judge the adequacy of the translation.\footnote{Typical machine translation evaluations evaluate pairs and ask annotators to choose which is better.} 




From these data, we treat the \emph{average} human rating as the ground truth and consider how individual human ratings vary around that mean.
To visualize these results with kernel density estimates (standard normal kernels) of the \emph{standard deviation}.
\autoref{fig:yvettedata} shows the mean rating (x-axis) and the deviation of the human ratings (y-axis) at each mean.\footnote{A current limitation of this model is that the simulated noise is i.i.d. conditioned on the rating (homoscedastic noise). While this is a stronger and more realistic model than assuming no noise, real noise is likely heteroscedastic: dependent on the input.}As expected, the standard deviation is small at the extremes and large in the middle (this is a bounded interval), with a fairly large range in the middle:
a translation whose average score is $50$ can get human evaluation scores anywhere between $20$ and $80$ with high probability.
We use a linear approximation to define our variance-based perturbation function as a Gaussian distribution, which is parameterized by a scale $\lambda$ that grows or shrinks the variances (when $\lambda=1$ this exactly matches the variance in the plot).
\renewcommand{\brack}[1]{\left\{\begin{array}{ll}#1\end{array}\right.}
\begin{align}
  \textrm{pert}^{\textrm{var}}(s;\lambda)
  &= \textrm{Nor}\left(s, \lambda \sigma(s)^2\right) \\
   \sigma(s) &= \brack{~~~0.64 s - 0.02 & \textrm{if } s < 50 \\
                         -0.67 s + 67.0 & \textrm{otherwise} } \nonumber
\end{align}






\begin{figure}[t]
  \centering
  \includegraphics[width=\linewidth,clip=true,trim=35 22 61 311]{images/yvettedata.pdf}
  \caption{Average rating (x-axis) versus a kernel density estimate of the variance of human ratings around that mean, with linear fits. 
  Human scores vary more around middling judgments than extreme judgments.}
  \label{fig:yvettedata}
\end{figure}



\subsection{Non-Experts are Skewed from Experts} \label{sec:skew}

The preceding two noise models assume that the reward closely models the value we want to optimize (has the same mean).
This may not be the case with non-expert ratings.
Non-expert raters are skewed both for reinforcement learning \cite{thomaz2006reinforcement,thomaz2008teachable,loftin2014strategy} and recommender systems \cite{herlocker2000explaining,adomavicius2012impact}, but are typically bimodal: some are harsh (typically provide very low scores, even for ``okay'' outputs) and some are motivational (providing high scores for ``okay'' outputs).

We can model both harsh and motivations raters with a simple deterministic skew perturbation function, parametrized by a scalar $\rho \in [0,\infty)$:
\begin{align}
  \textrm{pert}^{\textrm{skew}}(s;\rho)
  &= s^\rho
\end{align}
For $\rho > 1$, the rater is harsh; for $\rho < 1$, the rater is motivational.









 
\section{Experimental Setup} \label{sec:experiment}
\begin{table}[t]
  \centering
  \small
\label{my-label}
\begin{tabular}{lll}
\toprule
                    & De-En & Zh-En \\ \midrule
Supervised training & 186K  & 190K  \\ 
Bandit training     & 167K  & 165K  \\ 
Development         & 7.7K  & 7.9K  \\ 
Test                & 9.1K  & 7.4K  \\ 
\bottomrule
\end{tabular}
\caption{Sentence counts in data sets.}
\label{tab:data}
\end{table}

We choose two language pairs from different language families with different typological properties: German-to-English and (De-En) and Chinese-to-English (Zh-En).
We use parallel transcriptions of TED talks for these pairs of languages 
from the machine translation track of the IWSLT 2014 and 2015~\cite{cettolo2014report,cettolo2015iwslt,cettoloEtAl:EAMT2012}.
For each language pair, we split its data into four sets for supervised training, 
bandit training, development and testing (Table \ref{tab:data}).
For English and German, we tokenize and clean sentences using Moses~\cite{koehn2007moses}.
For Chinese, we use the Stanford Chinese word segmenter \cite{chang08chinese} to segment sentences and tokenize.
We remove all sentences with length greater than 50, resulting in an average 
sentence length of 18.
We use IWSLT 2015 data for supervised training and development, IWSLT 2014 data 
for bandit training and previous years' development and evaluation data for testing.\footnote{Over 95\% of the bandit learning set's sentences are seen during supervised learning. Performance gain on this set mainly reflects how well a model leverages weak learning signals (ratings) to improve previously made predictions. Generalizability is measured by performance gain on the test sets, which do not overlap the training sets.}

\subsection{Evaluation Framework}


For each task, we first use the supervised training set to pre-train 
a reference NMT model using supervised learning.
On the same training set, we also pre-train the critic model with 
translations sampled from the pre-trained NMT model. 
Next, we enter a bandit learning mode where our models only observe the source
sentences of the bandit training set. 
Unless specified differently, we train the NMT models with NED-A2C for one pass 
over the bandit training set.
If a perturbation function is applied to \persentence scores, it is only applied
in this stage, not in the pre-training stage. 

We measure the \emph{improvement} $\Delta S$ of
an evaluation metric $S$ due to bandit training: $\Delta S = S_{A2C} - S_{ref}$, where $S_{ref}$ is the metric computed on the reference models
and $S_{A2C}$ is the metric computed on models trained with NED-A2C.
Our primary interest is \emph{\persentence}: average sentence-level \bleu of translations that
    are sampled and scored during the bandit learning pass. 
    This metric represents average expert ratings, which we want to optimize for 
    in real-world scenarios. 
We also measure \emph{\heldout}: corpus-level \bleu on an unseen test set, where
    translations are greedily decoded by the NMT models. 
    This shows how much our method improves translation 
    quality, since corpus-level \bleu correlates better with human judgments
    than sentence-level \bleu. 

Because of randomness due to both the random sampling in the model for ``exploration'' as well as the randomness in the reward function, we repeat each experiment five times and 
report the mean results with 95\% confidence intervals.

\subsection{Model configuration}

Both the NMT model and the critic model are encoder-decoder models with global 
attention~\cite{luong2015effective}.
The encoder and the decoder are unidirectional single-layer LSTMs. 
They have the same word embedding size and LSTM hidden size of 500.
The source and target vocabulary sizes are both 50K.
We do not use dropout in our experiments.
We train our models by the Adam optimizer \cite{kingma14adam} with 
$\beta_1 = 0.9, \beta_2 = 0.999$ and a batch size of 64.
For Adam's $\alpha$ hyperparameter, we use $10^{-3}$ during pre-training and $10^{-4}$ during
bandit learning (for both the NMT model and the critic model). 
During pre-training, starting from the fifth pass, we decay $\alpha$ by a factor of 0.5 when perplexity on the development set increases.
The NMT model reaches its highest corpus-level \bleu on the development set after 
ten passes through the supervised training data, while the critic model's training error stabilizes 
after five passes.
The training speed is 18s/batch for supervised pre-training and 41s/batch for
training with the NED-A2C algorithm. 

 
\section{Results and Analysis} \label{sec:results}
In this section, we describe the results of our experiments,
broken into the following questions:
how NED-A2C improves reference models (\autoref{sec:persentence});
the effect the three perturbation functions have on the algorithm 
(\autoref{sec:perturb_results}); and whether the algorithm improves a corpus-level
metric that corresponds well with human judgments (\autoref{sec:heldout_results}).

\subsection{Effectiveness of NED-A2C under Un-perturbed Bandit Feedback}
\label{sec:persentence}

\begin{table*}[!t]
  \small
\centering
\begin{tabular}{l|ccc|ccc}
\toprule
       & \multicolumn{3}{c|}{De-En}          & \multicolumn{3}{c}{Zh-En}   \\
       & Reference  & $\Delta_{sup}$ & $\Delta_{A2C}$     
       & Reference  & $\Delta_{sup}$ & $\Delta_{A2C}$     \\ \midrule
       \multicolumn{7}{c}{Fully pre-trained reference model} \\ \midrule
\persentence & 38.26 $\pm$ 0.02 & 0.07 $\pm$ 0.05 & \textbf{2.82 $\pm$ 0.03} 
             & 32.79 $\pm$ 0.01 & 0.36 $\pm$ 0.05 & \textbf{1.08 $\pm$ 0.03} \\ 
\heldout & 24.94 $\pm$ 0.00 & 1.48 $\pm$ 0.00 & \textbf{1.82 $\pm$ 0.08} 
         & 13.73 $\pm$ 0.00 & \textbf{1.18 $\pm$ 0.00} & 0.86 $\pm$ 0.11 \\ \midrule
       \multicolumn{7}{c}{Weakly pre-trained reference model} \\ \midrule
\persentence & 19.15 $\pm$ 0.01 & 2.94 $\pm$ 0.02 & \textbf{7.07 $\pm$ 0.06} 
             & 14.77 $\pm$ 0.01 & 1.11 $\pm$ 0.02 & \textbf{3.60 $\pm$ 0.04} \\ 
  \heldout   & 19.63 $\pm$ 0.00 & \textbf{3.94 $\pm$ 0.00} & 1.61 $\pm$ 0.17 
             & 9.34 $\pm$ 0.00 & \textbf{2.31 $\pm$ 0.00}  & 0.92 $\pm$ 0.13 \\ \midrule
\end{tabular}
\caption{Translation scores and improvements based on a single round of un-perturbed bandit feedback. \persentence and \heldout are not comparable: the former is sentence-\bleu, the latter is corpus-\bleu.}
\label{tab:clean_bleu}
\end{table*}

We evaluate our method in an ideal setting where \emph{un-perturbed} \persentence simulates
ratings during both training and evaluation (Table \ref{tab:clean_bleu}).

\paragraph{Single round of feedback.}
In this setting, our models only observe each source sentence once and 
before producing its translation.
On both De-En and Zh-En, NED-A2C improves \persentence of
reference models 
after only a single pass (+2.82 and +1.08 respectively). 

\paragraph{Poor initialization.}
Policy gradient algorithms have difficulty improving from poor 
initializations, especially on problems with a large action space, because 
they use model-based exploration, which is ineffective when 
most actions have equal probabilities~\cite{bahdanau2016actor,ranzato2015sequence}.
To see whether NED-A2C has this problem, we repeat the experiment with the same
setup but with reference models pre-trained for only a single pass.
Surprisingly, NED-A2C is highly effective at improving these poorly trained models 
(+7.07 on De-En and +3.60 on Zh-En in \persentence).

\paragraph{Comparisons with supervised learning.}
To further demonstrate the effectiveness of NED-A2C, we compare it
with training the reference models with supervised learning for a single pass on the bandit training set.
Surprisingly, observing ground-truth translations barely improves the models in \persentence 
when they are fully trained (less than +0.4 on both tasks). 
A possible explanation is that the models have already reached full capacity and do not benefit 
from more examples.\footnote{This result may vary if the domains of the supervised learning set and the bandit training set are dissimilar. Our training data are all TED talks. }
NED-A2C further enhances the models because it eliminates the mismatch between the supervised training objective and the evaluation objective. 
On weakly trained reference models, NED-A2C also significantly outperforms supervised learning ($\Delta$\persentence of NED-A2C is over three times as large as those of supervised learning).

\begin{figure}[t]
  \centering
  \includegraphics[width=0.9\linewidth]{images/learning_curve.pdf}
  \caption{Learning curves of models trained with NED-A2C for five epochs.}
  \label{fig:curves}
\end{figure}

\paragraph{Multiple rounds of feedback.}
We examine if NED-A2C can improve the models even further with multiple rounds of feedback.\footnote{The ability to receive feedback on the same example multiple times might 
not fit all use cases though.} 
With supervised learning, the models can memorize the reference translations
but, in this case, the models have to be able to exploit and explore effectively. 
We train the models with NED-A2C for five passes and observe a much more significant 
$\Delta$\persentence than training for a single pass in both pairs of language 
(+6.73 on De-En and +4.56 on Zh-En) (\autoref{fig:curves}).

\begin{figure*}[!t]
  \centering
  \subcaptionbox{Granularity}[.3\linewidth][c]{\includegraphics[width=.3\linewidth,clip=true,trim=28 15 28 8]{images/bin_s_bleu.pdf}\vspace{-2mm}}
  \subcaptionbox{Variance}[.3\linewidth][c]{\includegraphics[width=.3\linewidth,clip=true,trim=28 15 28 8]{images/noise_s_bleu.pdf}\vspace{-2mm}}
  \subcaptionbox{Skew}[.3\linewidth][c]{\includegraphics[width=.3\linewidth,clip=true,trim=28 15 28 8]{images/bias_s_bleu.pdf}\vspace{-2mm}}
  


  \subcaptionbox{Granularity}[.3\linewidth][c]{\includegraphics[width=.3\linewidth,clip=true,trim=28 15 28 8]{images/bin_c_bleu.pdf}\vspace{-2mm}}
  \subcaptionbox{Variance}[.3\linewidth][c]{\includegraphics[width=.3\linewidth,clip=true,trim=28 15 28 8]{images/noise_c_bleu.pdf}\vspace{-2mm}}
  \subcaptionbox{Skew}[.3\linewidth][c]{\includegraphics[width=.3\linewidth,clip=true,trim=28 15 28 8]{images/bias_c_bleu.pdf}\vspace{-2mm}}
  \caption{Performance gains of NMT models trained with NED-A2C in \persentence 
    (top row) and in \heldout(bottom row) under various degrees of granularity, 
    variance, and skew of scores. 
    Performance gains of models trained with un-perturbed scores are within the
    shaded regions. 
  }
  \label{fig:noise}
\end{figure*}


\subsection{Effect of Perturbed Bandit Feedback}
\label{sec:perturb_results}
We apply perturbation functions defined in \autoref{sec:granular} to \persentence scores and 
use the perturbed scores as rewards during bandit training (\autoref{fig:noise}).

\paragraph{Granular Rewards.} We discretize raw \persentence scores using $\textrm{pert}^{gran}(s; g)$ (\autoref{sec:granular}).
We vary $g$ from one to ten (number of bins varies from two to eleven). 
Compared to continuous rewards, for both pairs of languages,
$\Delta$\persentence is not affected with $g$ at least five (at least six bins).
As granularity decreases, $\Delta$\persentence  monotonically degrades.
However, even when $g = 1$ (scores are either 0 or 1), the models still improve by at least a point.

\paragraph{High-variance Rewards.} We simulate noisy rewards using the model of human rating variance 
$\textrm{pert}^{var}(s; \lambda)$ (\autoref{sec:variance}) with 
$\lambda \in \{0.1, 0.2, 0.5, 1, 2, 5 \}$. 
Our models can withstand an amount of about 20\% the variance in our human eval 
data without dropping in $\Delta$\persentence.
When the amount of variance attains 100\%, matching the amount of variance in the human 
data, $\Delta$\persentence go down by 
about 30\% for both pairs of languages. 
As more variance is injected, the models degrade quickly but still improve from
the pre-trained models.
Variance is the most detrimental type of perturbation to NED-A2C 
among the three aspects of human ratings we model. 

\paragraph{Skewed Rewards.} We model skewed raters using $\textrm{pert}^{skew}(s; \rho)$ (\autoref{sec:skew}) with $\rho \in \{0.25, 0.5, 0.67, 1, 1.5, 2, 4\}$.
NED-A2C is robust to skewed scores. 
$\Delta$\persentence is at least 90\% of unskewed scores for most skew values. 
Only when the scores are extremely harsh ($\rho = 4$) does $\Delta$\persentence degrade 
significantly (most dramatically by 35\% on Zh-En). 
At that degree of skew, a score of 0.3 is suppressed to be less than 0.08, giving
little signal for the models to learn from.
On the other spectrum, the models are less sensitive to motivating scores as 
\persentence is unaffected on Zh-En and only decreases by 7\% on De-En.

\subsection{Held-out Translation Quality}
\label{sec:heldout_results}

Our method also improves pre-trained models in \heldout, a metric that
correlates with translation quality better than \persentence
(\autoref{tab:clean_bleu}).  When scores are perturbed by our rating
model, we observe similar patterns as with \persentence: the models
are robust to most perturbations except when scores are very coarse,
or very harsh, or have very high variance (\autoref{fig:noise}, second
row).  Supervised learning improves \heldout better, possibly because
maximizing log-likelihood of reference translations correlates more
strongly with maximizing \heldout of predicted translations than
maximizing \persentence of predicted translations.

 
\section{Related Work and Discussion} \label{sec:related}


Ratings provided by humans can be used as effective learning signals
for machines.
Reinforcement learning has become the \textit{de facto} standard for
incorporating this feedback across diverse tasks such as robot
voice control~\cite{tenorio2010dynamic}, myoelectric control~\cite{pilarski2011online}, and virtual assistants~\cite{isbell2001social}.
Recently, this learning framework has been combined with recurrent neural networks to solve  
machine translation~\cite{bahdanau2016actor}, dialogue generation~\cite{li2016deep}, neural architecture search~\cite{zoph2016neural}, and device placement~\cite{mirhoseini2017device}. 
Other approaches to more general structured prediction under bandit feedback \cite{daume15lols,sokolov2016learning,sokolov2016stochastic} show the broader efficacy of this framework.
\citet{ranzato2015sequence} describe MIXER for training neural encoder-decoder models, 
which is a reinforcement learning approach closely related to ours but requires a policy-mixing strategy and only uses a linear critic model. 
Among work on bandit MT, ours is closest to \citet{kreutzer17bandit}, 
which also tackle this problem using neural encoder-decoder models, 
but we 
(a) take advantage of a state-of-the-art reinforcement learning method;
(b) devise a strategy to simulate noisy rewards; and
(c) demonstrate the robustness of our method on noisy simulated rewards. 

Our results show that bandit feedback can be an effective
feedback mechanism for neural machine translation systems.
This is \emph{despite} that errors in human annotations hurt machine learning models in many NLP tasks~\cite{snow2008cheap}.
An obvious question is whether we could extend our framework to model individual annotator preferences \cite{passonneau2014benefits} or learn personalized models \cite{mirkin2015motivating,rabinovich2016personalized}, and handle heteroscedastic noise \cite{park1966estimation,kersting2007most,antos2010active}.
Another direction is to apply active learning techniques to reduce the
sample complexity required to improve the systems or to extend to
richer action spaces for problems like simultaneous translation, which requires
prediction~\cite{Grissom:He:Boyd-Graber:Morgan-2014} and
reordering~\cite{He-15} among other strategies to both minimize delay
and effectively translate a sentence~\cite{He-2016}.






 
\section*{Acknowledgements}

Many thanks to Yvette Graham for her help with the WMT human evaluations data.
We thank UMD CLIP lab members for useful discussions that led to the
ideas of this paper.
We also thank the anonymous reviewers for their thorough and insightful comments.
This work was supported by NSF grants IIS-1320538.
Boyd-Graber is also partially supported by NSF grants IIS-
1409287, IIS-1564275, IIS-IIS-1652666, and NCSE-1422492.
Daum{\'e} III is also supported by NSF grant IIS-1618193,
as well as an Amazon Research Award.
Any opinions, findings, conclusions,
or recommendations expressed here are those of
the authors and do not necessarily reflect the view of the
sponsor(s).

\appendix
\section{Neural MT Architecture}
Our neural machine translation (NMT) model consists of an encoder and a decoder, 
each of which is a recurrent neural network (RNN).
We closely follow \cite{luong2015effective} for the structure of our model.
It directly models the posterior distribution 
$P_{\vec \theta}(\vec y \mid \vec x)$ of translating a source sentence $\vec x = (x_1, \cdots, x_n)$ to
a target sentence $\vec y = (y_1, \cdots, y_m)$:
\begin{align}
  P_{\vec \theta}(\vec y \mid \vec x) = \prod_{t = 1}^m P_{\vec \theta}(y_t \mid \vec y_{<t}, \vec x)
\end{align}
where $\vec y_{<t}$ are all tokens in the target sentence prior to $y_t$. 

Each local disitribution $P_{\vec \theta}(y_t \mid \vec y_{<t}, \vec x)$ is modeled as a multinomial
distribution over the target language's vocabulary. We compute this distribution by applying a linear transformation followed by a softmax function on the decoder's output vector 
$\vec h_t^{dec}$: 
\begin{align}
  P_{\vec \theta}(y_t \mid \vec y_{<t}, \vec x) &= \mathrm{softmax}(\vec W_s \ \vec h_t^{dec}) \\
  \vec h_{t}^{dec} &= \tanh (\vec W_o [\tilde{\vec h}_t^{dec}; \vec c_t]) \\
  \vec c_t &= \mathrm{attend}(\tilde{\vec h}_{1:n}^{enc}, \tilde{\vec h}_t^{dec})
\label{eqn:softmax}
\end{align} where 
$[\cdot;\cdot]$ is the concatenation of two vectors, 
$\mathrm{attend}(\cdot,\cdot)$ is an attention mechanism,
$\tilde{\vec h}_{1:n}^{enc}$ are all encoder's hidden vectors and 
$\tilde{\vec h}_t^{dec}$ is the decoder's hidden vector at time step $t$.
We use the ``general'' global attention in~\cite{luong2015effective}.

During training, the encoder first encodes $\vec x$ to a continuous
vector $\Phi(\vec x)$, which is used as the initial hidden vector for the decoder. 
In our paper, $\Phi(\vec x)$ simply returns the last hidden vector of the encoder.
The decoder performs RNN updates to produce a sequence of hidden 
vectors:
\begin{equation}
\begin{split}
  \tilde{\vec h}_0^{dec} &= \Phi(\vec x) \\
  \tilde{\vec h}_t^{dec} &= f_{\vec \theta} 
  \left(\tilde{\vec h}_{t - 1}^{dec}, \left[ \vec h_{t-1}^{dec}; e(y_t) \right] \right)
\end{split}
\label{eqn:decoder}
\end{equation} where $e(.)$ is a word embedding lookup function and $y_t$ is the 
ground-truth token at time step $t$. 
Feeding the output vector $\vec h_{t - 1}^{dec}$ to the next step is known as ``input feeding''.

At prediction time, the ground-truth token $y_t$ in \autoref{eqn:decoder} 
is replaced by the model's own prediction $\hat{y}_t$:
\begin{equation}
  \hat{y}_t = \arg \max_y P_{\vec \theta}(y \mid \hat{\vec y}_{<t}, \vec x)
\end{equation}

In a supervised learning framework, an NMT model is typically trained under the 
maximum log-likelihood objective:
\begin{equation}
\begin{split}
  \max_{\vec \theta} \mathcal{L}_{sup}(\vec \theta) &= 
  \max_{\vec \theta} \mathbb{E}_{(\vec x, \vec y) \sim D_{\textrm{tr}}} 
  \left[ \log P_{\vec \theta} \left( \vec y \mid \vec x \right) \right]
\end{split}
\end{equation} where $D_{\textrm{tr}}$ is the training set.  
However, this learning framework is not applicable to bandit learning since 
ground-truth translations are not available. 



 
\bibliography{emnlp2017}
\bibliographystyle{emnlp_natbib}

\end{document}