diff --git "a/data_all_eng_slimpj/shuffled/split2/finalzzlipz" "b/data_all_eng_slimpj/shuffled/split2/finalzzlipz"
new file mode 100644--- /dev/null
+++ "b/data_all_eng_slimpj/shuffled/split2/finalzzlipz"
@@ -0,0 +1,5 @@
+{"text":"\\section{Introduction}\n\nFor more than a decade experiments at LEP (CERN) and SLC (SLAC) \ngathered  a wealth of high precision high energy hadronic data\nfrom electron-positron annihilation at a range of centre-of-mass \nenergies~\\cite{ALEPH-qcdpaper,lep,sld}. \nThis data provides one of the    \n cleanest\nways of probing our quantitative understanding of QCD. \nThis is particularly so because the strong interactions occur only in \nthe final state and are not entangled with the parton density functions associated \nwith beams of hadrons.\nAs the understanding of the strong interaction, and the capability of \nmaking more precise theoretical predictions, develops, \nmore and more stringent comparisons of theory and experiment are possible,\nleading to improved measurements\nof fundamental quantities such as the strong \ncoupling constant~\\cite{expreview}.\n\nIn addition\nto measuring multi-jet production rates, more specific information  about the\ntopology of the events can be extracted. To this end, many variables  have been\nintroduced which characterise the hadronic structure of an event. \nWith the precision data from LEP and SLC, experimental\ndistributions for such event shape variables have been extensively  studied and\nhave been compared with theoretical calculations based on next-to-leading order\n(NLO)  parton-level event generator  programs~\\cite{ERT,kunszt,event}, \n  improved by\nresumming kinematically-dominant leading and next-to-leading logarithms\n(NLO+NLL)~\\cite{ctwt}  and by the inclusion of  \nnon-perturbative models of power-suppressed hadronisation\neffects~\\cite{power}. \n\nThe precision of the strong coupling constant \ndetermined from event shape data has been limited up to now \nlargely by the scale\nuncertainty of the perturbative NLO calculation. We report here on the \nfirst calculation of NNLO corrections to event shape variables, and discuss \ntheir phenomenological impact.\n\n\n\\section{Event shape variables}\n\\label{sec:shapes}\n\nIn order to characterise hadronic final states in electron-positron\nannihilation, a variety of event shape variables have been proposed in \nthe literature, for a review see e.g.~\\cite{QCDbooks}. These variables can be categorised \ninto different classes, \naccording to the minimal number of final-state particles required for them \nto be non-vanishing: In the following we shall only consider three particle final states which are thus closely related to three-jet final states.\n\nAmong those shape variables,\nsix variables~\\cite{shapes}\n were studied in great detail: the thrust $T$, the\nnormalised heavy jet mass $\\rho$, \nthe wide and total jet\nbroadenings $B_W$ and $B_T$,  \nthe $C$-parameter and the transition from three-jet to \ntwo-jet final states in the Durham jet algorithm $Y_3$.\n\n\nThe perturbative expansion for the distribution of a \ngeneric observable $y$ up to NNLO at $e^+e^-$ centre-of-mass energy $\\sqrt{s}$, \nfor a renormalisation scale $\\mu^2$  is given by\n\\begin{eqnarray}\n\\frac{1}{\\sigma_{{\\rm had}}}\\, \\frac{\\hbox{d}\\sigma}{\\hbox{d} y} (s,\\mu^2,y) &=& \n\\left(\\frac{\\alpha_s{}(\\mu^2)}{2\\pi}\\right) \\frac{\\hbox{d} \\bar A}{\\hbox{d} y} +\n\\left(\\frac{\\alpha_s{}(\\mu^2)}{2\\pi}\\right)^2 \\left( \n\\frac{\\hbox{d} \\bar B}{\\hbox{d} y} + \\frac{\\hbox{d} \\bar A}{\\hbox{d} y} \\beta_0 \n\\log\\frac{\\mu^2}{s} \\right)\n\\nonumber \\\\ &&\n+ \\left(\\frac{\\alpha_s{}(\\mu^2)}{2\\pi}\\right)^3 \n\\bigg(\\frac{\\hbox{d} \\bar C}{\\hbox{d} y} + 2 \\frac{\\hbox{d} \\bar B}{\\hbox{d} y}\n \\beta_0\\log\\frac{\\mu^2}{s}\n\\nonumber \\\\ &&\n\\hspace{24mm} + \\frac{\\hbox{d} \\bar A}{\\hbox{d} y} \\left( \\beta_0^2\\,\\log^2\\frac{\\mu^2}{s}\n+ \\beta_1\\, \\log\\frac{\\mu^2}{s}   \\right)\\bigg)+ {\\cal O}(\\alpha_s{4})  \\;.\n\\label{eq:NNLOmu} \n\\end{eqnarray}\nThe dimensionless \nperturbative coefficients $\\bar A$, $\\bar B$ and $\\bar C$ depend only \non the event shape variable $y$. They are computed by a fixed-order \nparton-level calculation, which includes final states with three partons \nat LO, up to four partons at NLO and up to five partons at NNLO. \nLO and NLO corrections to event shapes have been available already for \na long time~\\cite{ERT,kunszt,event}. \n\n The calculation of the NNLO corrections is carried out using \na newly developed\nparton-level event generator programme {\\tt EERAD3} which contains \nthe relevant \nmatrix elements with up to five external partons~\\cite{3jme,muw2,V4p,tree5p}. \nBesides explicit infrared divergences from the loop integrals, the \nfour-parton and five-parton contributions yield infrared divergent \ncontributions if one or two of the final state partons become collinear or \nsoft. In order to extract these infrared divergences and combine them with \nthe virtual corrections, the antenna subtraction method~\\cite{ant} \nwas extended to NNLO level~\\cite{ourant} and implemented\nfor $e^+e^- \\to 3\\,\\mathrm{jets}$ and related event-shape variables~\\cite{eerad3}. The analytical cancellation of all \ninfrared divergences serves as a very strong check on the implementation. \n{\\tt EERAD3} yields the perturbative  $A$, $B$ and $C$ coefficients as \nhistograms for all infrared-safe event-shape variables \nrelated to three-particle \nfinal states at leading order. From these, \n $\\bar A$, $\\bar B$ and $\\bar C$ are computed by normalising to the total \nhadronic cross section.\nAs a cross check, the $A$ and $B$  coefficients have also been obtained from an independent integration~\\cite{event}\nof the NLO matrix elements~\\cite{ERT}, showing excellent agreement. \n\nFor small values of the event shape variable $y$, the fixed-order expansion, \neq.\\ (\\ref{eq:NNLOmu}), fails to converge, \nbecause the fixed-order coefficients are enhanced by powers of $\\hbox{ln}(1\/y)$.\nIn order to obtain reliable predictions\nin the region of $y \\ll 1$ it is necessary to resum entire sets of logarithmic terms at all orders in $\\alpha_s$. \nA detailed description of the predictions at next-to-leading-logarithmic approximation (NLLA) can\nbe found in Ref.\\ \\cite{as_theory-uncertainties}. \n\n\n\\section{NNLO results}\n\n\nThe precise size and shape of the NNLO corrections depend on the observable \nin question. Common to all observables is the divergent behaviour of \nthe fixed-order prediction in the two-jet limit, where soft-gluon effects \nat all orders become important, and where resummation is needed. For several \nevent shape variables \n (especially $T$ and $C$) the full kinematical range is not yet realised \nfor three partons, but attained only in the multi-jet limit. In this case,\nthe fixed-order description is also insufficient since it is  limited \nto a fixed multiplicity (five partons at NNLO). Consequently, the \nfixed-order description is expected to be reliable in a restricted \ninterval bounded by the two-jet limit on one side and the multi-jet \nlimit on the other side. \n\nIn this intermediate region, we observe that \ninclusion of  NNLO corrections (evaluated at the $Z$-boson mass, and \nfor fixed value of the strong coupling constant) typically increases \nthe previously available NLO prediction. \nThe magnitude of this increase differs considerably between \ndifferent observables\\cite{ourevent}, \nit is substantial for $T$ (18\\%), $B_T$ (17\\%)  and \n$C$ (15\\%), moderate for $\\rho$ and $B_W$ (both 10\\%) and small for \n$Y_3$ (6\\%). For all shape variables, we observe that the renormalisation\nscale uncertainty of the NNLO prediction is reduced by a factor 2 or more\ncompared to the NLO prediction. \nInclusion of the NNLO corrections modifies the shape of the event shape \ndistributions. We observe that \nthe NNLO prediction describes the shape of the measured event shape \ndistributions over a wider kinematical range than the NLO prediction, both \ntowards the two-jet and the multi-jet limit. To illustrate the \nimpact of the NNLO corrections, we compare the fixed-order predictions \nfor $Y_3$ to LEP2-data obtained by the ALPEH experiment in \nFigure~\\ref{fig:y23}, which illustrates especially the improvement\nin the approach to the two-jet region (large $-\\hbox{ln}(Y_3)$).   \n\\begin{figure}[t]\n\\begin{center}\n\\includegraphics[angle=-90,width=10cm]{aleph.y23.ps}\n\\end{center}\n\\caption{\\small Perturbative fixed-order predictions \nfor the $Y_3$-distribution, compared to LEP2 data from ALEPH.} \n\\protect\\label{fig:y23}\n\\end{figure}\n\nThe information contained in the event shape distributions can be \nrestructured by computing individual moments. Moments of event shape \ndistributions have been studied \ntheoretically and experimentally in particular in view of \nunderstanding non-perturbative power corrections~\\cite{power}.\nConsequently, perturbative NNLO corrections will improve the discrimination \nbetween higher perturbative orders and genuine non-perturbative effects. \nFor the first moment $\\langle 1-T \\rangle$ of the thrust distribution, we find\nthe integrated coefficients\n\\begin{displaymath}\n{\\cal A} = 2.101\\,\\qquad {\\cal B} = 44.98\\,\\qquad \n{\\cal C} = 1095 \\pm 130\\;,\n\\end{displaymath}\nwhich yields for $\\sqrt{s}=\\mu=M_Z$:\n\\begin{displaymath}\n\\langle 1-T \\rangle(\\alpha_s(M_Z) = 0.1189) \n= 0.0398\\, ({\\rm LO})\\; +\\; 0.0146\\, ({\\rm NLO})  \\; \n+ \\; 0.0068 \\, ({\\rm NNLO})\\;.\n\\end{displaymath}\nWork on moments of the event shapes is ongoing.\n\n\\section{Determination of the strong coupling constant}\nUsing the newly computed NNLO corrections to event shape variables, we\nperformed\\cite{ouras} \na new extraction of $\\alpha_s$ from data on the standard set of \nsix event shape variables, measured \n by the ALEPH\\ collaboration \\cite{ALEPH-qcdpaper}\nat centre-of-mass energies of 91.2, 133, 161, 172, 183, 189, 200 and 206 GeV.\nThe combination of \nall NNLO determinations from all shape variables  yields \n\\begin{displaymath}\n    \\alpha_s(M_Z) = 0.1240 \\;\\pm\\; 0.0008\\,\\mathrm{(stat)}\n     \t\t\t\t\t \\;\\pm\\; 0.0010\\,\\mathrm{(exp)}\n                                   \\;\\pm\\; 0.0011\\,\\mathrm{(had)}\n                                   \\;\\pm\\; 0.0029\\,\\mathrm{(theo)} .\n \\end{displaymath}\nWe observe a clear improvement in the fit quality when going to\nNNLO accuracy. Compared to NLO the value of $\\alpha_s$ is lowered \nby about 10\\%, but still higher than for NLO+NLLA~\\cite{ALEPH-qcdpaper},\n which \nshows the obvious need for a matching of NNLO+NLLA for a fully reliable \nresult.  \n The scatter among the\n $\\alpha_s$-values extracted from different shape variables is \nlowered considerably, and the theoretical uncertainty is decreased by \na factor 2 (1.3) compared to NLO (NLO+NNLA). \n\nThese observations visibly illustrate the improvements gained from \nthe inclusion of the NNLO corrections, and highlight the need for \nfurther studies on the matching of NNLO+NLLA, and on the \nderivation of NNLLA resummation terms.\n\n\n\\section{Outlook}\nOur results for the NNLO corrections open up a whole \nnew range of possible \ncomparisons with the LEP data.\nThe potential of these studies is\nillustrated by the new determination of \n$\\alpha_s$ reported here, which can be \nfurther improved by the matching NLLA+NNLO, currently in progress. \nSimilarly, our results will also allow a renewed study of\npower corrections, now matched to NNLO. \n\n\n\n\\bibliographystyle{JHEP}\n","meta":{"redpajama_set_name":"RedPajamaArXiv"}}
+{"text":"\\section{Introduction}\n\nNeural network models have recently contributed towards a great amount of progress in natural language processing. These models typically share a common backbone: recurrent neural networks (RNN), which have proven themselves to be capable of tackling a variety of core natural language processing tasks \\cite{hochreiter1997long,elman1990finding}.\nOne such task is language modeling, in which we estimate a probability distribution over sequences of tokens that corresponds to observed sentences (\\S\\ref{sec:background}). Neural language models, particularly models conditioned on a particular input, have many applications including in machine translation \\cite{bahdanau2016end}, abstractive summarization \\cite{chopra2016abstractive}, and speech processing \\cite{graves2013speech}. Similarly, state-of-the-art language models are almost universally based on RNNs, particularly long short-term memory (LSTM) networks \\cite{jozefowicz2016exploring,inan2016tying,merity2016pointer}.\n\n\\begin{figure}\n    \\centering\n    \\includegraphics[scale=.15,trim=1.2cm 0 0 0]{newlatticelm}\n    \\caption{Lattice decomposition of a sentence and its corresponding lattice language model probability calculation}\n    \\vspace{-2mm}\n    \\label{fig:latticelm}\n\\end{figure}\n\nWhile powerful, LSTM language models usually do not \\textit{explicitly} model many commonly-accepted linguistic phenomena. As a result, standard models lack linguistically informed inductive biases, potentially limiting their accuracy, particularly in low-data scenarios \\cite{adams2017,koehn}. In this work, we present a novel modification to the standard LSTM language modeling framework that allows us to incorporate some varieties of these linguistic intuitions seamlessly:\n\\textit{neural lattice language models} (\\S\\ref{sec:proposed}). Neural lattice language models define a lattice over possible paths through a sentence, and maximize the marginal probability over all paths that lead to generating the reference sentence, as shown in Fig. \\ref{fig:latticelm}. Depending on how we define these paths, we can incorporate different assumptions about how language should be modeled.\n\nIn the particular instantiations of neural lattice language models covered by this paper, we focus on two properties of language that could potentially be of use in language modeling: the existence of multi-word lexical units \\cite{zgusta1967multiword} (\\S\\ref{sec:multitoken}) and polysemy \\cite{ravin2000polysemy} (\\S\\ref{sec:polysemy}). Neural lattice language models allow the model to incorporate these aspects in an end-to-end fashion by simply adjusting the structure of the underlying lattices.\n\nWe run experiments to explore whether these modifications improve the performance of the model (\\S\\ref{sec:experiments}). Additionally, we provide qualitative visualizations of the model to attempt to understand what types of multi-token phrases and polysemous embeddings have been learned.\n\n\n\\section{Background}\n\\label{sec:background}\n\n\\subsection{Language Models}\n\nConsider a sequence $X$ for which we want to calculate its probability.\nAssume we have a vocabulary from which we can select a unique list of $|X|$ tokens $x_1,x_2,\\ldots,x_{|X|}$ such that $X = [x_1;x_2;\\ldots;x_{|X|}]$, i.e. the concatenation of the tokens (with an appropriate delimiter).\nThese tokens can be either on the character level \\cite{hwang2017character,DBLP:journals\/corr\/LingTDB15} or word level \\cite{inan2016tying,merity2016pointer}.\nUsing the chain rule, language models generally factorize $p(X)$ in the following way:\n\\begin{align}\n\\label{eq:regmarg}\np(X) &= p(x_1,x_2,\\ldots,x_{|X|}) \\nonumber \\\\\n     &= \\prod_{t=1}^{|X|}p(x_t\\mid x_1,x_2,\\ldots,x_{t-1})\n\\end{align}\n\nNote that this factorization is exact only in the case where the segmentation is unique.\nIn character-level models, it is easy to see that this property is maintained, because each token is unique and non-overlapping.\nIn word-level models, this also holds, because tokens are delimited by spaces, and no word contains a space.\n\n\\subsection{Recurrent Neural Networks}\n\nRecurrent neural networks have emerged as the state-of-the-art approach to approximating $p(X)$.\nIn particular, the LSTM cell \\cite{hochreiter1997long} is a specific RNN architecture which has been shown to be effective on many tasks, including language modeling \\cite{press2016using,jozefowicz2016exploring,merity2016pointer,inan2016tying}.%\n\\footnote{In this work, we utilize an LSTM with linked input and forget gates, as proposed by \\newcite{greff2016lstm}.}\nLSTM language models recursively calculate the hidden and cell states ($h_t$ and $c_t$ respectively) given the input embedding $e_{t-1}$ corresponding to token $x_{t-1}$:\n\\begin{align}\n\\label{eqn:lstm}\nh_t, c_t = \\text{LSTM}(h_{t-1},c_{t-1},e_{t-1},\\theta),\n\\end{align}\nthen calculate the probability of the next token given the hidden state, generally by performing an affine transform parameterized by $W$ and $b$, followed by a softmax:\n\\begin{align}\n\\label{eq:softmax}\np(x_t \\mid h_t) := \\text{softmax}(W * h_t + b).\n\\end{align}\n\n\n\n\n\\section{Neural Lattice Language Models}\n\n\\subsection{Language Models with Ambiguous Segmentations}\n\\label{sec:proposed}\n\nTo reiterate, the standard formulation of language modeling in the previous section requires splitting sentence $X$ into a unique set of tokens $x_1,\\ldots,x_{|X|}$.\nOur proposed method generalizes the previous formulation to remove the requirement of uniqueness of segmentation, similar to that used in non-neural $n$-gram language models such as \\newcite{dupont1997lattice} and \\newcite{goldwater2007distributional}.\n\nFirst, we define some terminology.\nWe use the term ``token'', designated by $x_i$, to describe any indivisible item in our vocabulary that has no other vocabulary item as its constituent part.\nWe use the term ``chunk'', designated by $k_i$ or $x_i^j$, to describe a sequence of one or more tokens that represents a portion of the full string $X$, containing the unit tokens $x_i$ through $x_j$: $x_i^j = [x_i,x_{i+1};\\ldots;x_j]$.\nWe also refer to the ``token vocabulary'', which is the subset of the vocabulary containing only tokens, and to the ``chunk vocabulary'', which similarly contains all chunks.\n\nNote that we can factorize the probability of any sequence of chunks $K$ using the chain rule, in precisely the same way as sequences of tokens:\n\\begin{align}\n\\label{eq:regmarg}\np(K) &= p(k_1,k_2,\\ldots,k_{|K|}) \\nonumber \\\\\n     &= \\prod_{t=1}^{|K|}p(k_t\\mid k_1,k_2,\\ldots,k_{t-1})\n\\end{align}\n\nWe can factorize the overall probability of a token list $X$ in terms of its chunks by using the chain rule, and marginalizing over all segmentations. \nFor any particular token list $X$, we define a set of valid segmentations $\\mathcal{S}(X)$, such that for every sequence $s \\in \\mathcal{S}(X)$, $X = [x_{s_0}^{s_1-1};x_{s_1}^{s_2-1};\\ldots;x_{s_{|s|-1}}^{s_{|s|}}]$.\nThe factorization is:\n\\small\n\\begin{align}\n\\label{eq:latmarg}\np(X) &= \\sum_S p(X, S) = \\sum_S p(X|S) p(S) = \\sum_{S \\in \\mathcal{S}(X)} p(S) \\nonumber \\\\\n     &= \\sum_{S \\in \\mathcal{S}(X)}\\prod_{t=1}^{|S|}p(x_{s_{t-1}}^{s_t-1}\\mid x_{s_0}^{s_1-1},x_{s_1}^{s_2-1},\\ldots,x_{s_{t-2}}^{s_{t-1}-1})\n\\end{align}\n\\normalsize\n\nNote that, by definition, there exists a unique segmentation of $X$ such that $x_1,x_2,\\ldots$ are all tokens, in which case $|S|=|X|$.\nWhen only that one unique segmentation is allowed per $X$, $\\mathcal{S}$ contains only that one element, so summation drops out, and therefore for standard character-level and word-level models, Eq.~(\\ref{eq:latmarg}) reduces to Eq.~(\\ref{eq:regmarg}), as desired. \nHowever, for models that license multiple segmentations per $X$, computing this marginalization directly is generally intractable.\nFor example, consider segmenting a sentence using a vocabulary containing all words and all 2-word expressions.\nThe size of $\\mathcal{S}$ would grow exponentially with the number of words in $X$, meaning we would have to marginalize over trillions of unique segmentations for even modestly-sized sentences.\n\n\\subsection{Lattice Language Models}\n\n\nTo avoid this, it is possible to re-organize the computations in a lattice, which allows us to dramatically reduce the number of computations required \\cite{dupont1997lattice,neubig2010learning}.\n\nAll segmentations of $X$ can be expressed as the edges of paths through a lattice over token-level prefixes of $X$: $x_{<1}, x_{<2}, \\ldots, X$. The infimum is the empty prefix $x_{<1}$; the supremum is $X$; an edge from prefix $x_{<i}$ to prefix $x_{<j}$ exists if and only if there exists a chunk $x_i^j$ in our chunk vocabulary such that $[x_{<i};x_i^j] = x_{<j}$.\nEach path through the lattice from $x_{<1}$ to $X$ is a segmentation of $X$ into the list of tokens on the traversed edges, as seen in Fig. \\ref{fig:latticelm}.\n\nThe probability of a specific prefix $p(x_{<j})$ is calculated by marginalizing over all segmentations leading up to $x_{j-1}$\n\\begin{equation}\n  p(x_{<j}) = \\sum_{S \\in \\mathcal{S}(x_{<j})} \\prod_{t=1}^{|S|} p(x_{s_{t-1}}^{s_t-1} \\mid x_{<s_{t-1}}),\n\\end{equation}\nwhere by definition $s_{|S|}=j$.\nThe key insight here that allows us to calculate this efficiently is that this is a recursive formula and that instead of marginalizing over all segmentations, we can marginalize over immediate predecessor edges in the lattice, $A_j$. Each item in $A_j$ is a location $i$ ($=s_{t-1}$), which indicates that the edge between prefix $x_{<i}$ and prefix $x_{<j}$, corresponding to token $x_i^j$, exists in the lattice. We can thus calculate $p(x_{<j})$ as\n\\begin{align}\n\\label{eq:neuralsum}\np(x_{<j}) = \\sum_{i \\in A_j}p(x_{<i})p(x_i^j \\mid x_{<i}).\n\\end{align}\n\nSince $X$ is the supremum prefix node, we can use this formula to calculate $p(X)$ by setting $j = |X|$. In order to do this, we need to calculate the probability of each of its $|X|$ predecessors. Each of those takes up to $|X|$ calculations, meaning that the computation for $p(X)$ can be done in O($|X|^2$) time. If we can guarantee that each node will have a maximum number of incoming edges $D$ so that $|A_j| \\leq D$ for all $j$, then this bound can be reduced to O($D|X|$) time.%\n\\footnote{Thus, the standard token-level language model where $D=1$ takes $O(|X|)$ computations.}\n\nThe proposed technique is completely agnostic to the shape of the lattice, and Fig. \\ref{fig:lattice} illustrates several potential varieties of lattices. Depending on how the lattice is constructed, this approach can be useful in a variety of different contexts, two of which we discuss in \\S\\ref{sec:instantiations}. \n\n\\subsection{Neural Lattice Language Models}\n\\label{sec:hs}\n\nThere is still one missing piece in our attempt to apply neural language models to lattices.\nWithin our overall probability in Eq.~(\\ref{eq:neuralsum}), we must calculate the probability $p(x_i^j \\mid x_{<i})$ of the next segment given the history.\nHowever, given that there are potentially an exponential number of paths through the lattice leading to $x_i$, this is not as straightforward as in the case where only one segmentation is possible.\nPrevious work on lattice-based language models \\cite{neubig2010learning,dupont1997lattice} utilized count-based $n$-gram models, which depend on only a limited historical context at each step making it possible to compute the marginal probabilities in an exact and efficient manner through dynamic programming.\nOn the other hand, recurrent neural models depend on the entire context, causing them to lack this ability. Our primary technical contribution is therefore to describe several techniques for incorporating lattices into a neural framework with infinite context, by providing ways to approximate the hidden state of the recurrent neural net.\n\n\n\\begin{figure}\n    \\centering\n        \\begin{tikzpicture}[->,auto,node distance=1cm,\n          thick,main node\/.style={circle,draw,font=\\sffamily\\Large\\bfseries}]\n        \n          \\node[main node] (1) {};\n          \\node[main node] (2) [right of=1, right=.3cm] {};\n          \\node[main node] (3) [right of=2, right=.3cm] {};\n          \\node[main node] (4) [right of=3, right=.3cm] {};\n          \\node[main node] (5) [right of=4, right=.3cm] {};\n        \n          \\path[every node\/.style={font=\\sffamily\\small}]\n            (1) edge node [below=.1cm] {the} (2)\n            (2) edge node [below=.1cm] {dog} (3)\n            (3) edge node [below=.1cm] {barked} (4)\n            (4) edge node [below=.25cm] {.} (5);\n\n          \\node[main node] (11) [below of=1, below=1cm] {};\n          \\node[main node] (12) [below of=2, below=1cm] {};\n          \\node[main node] (13) [below of=3, below=1cm] {};\n          \\node[main node] (14) [below of=4, below=1cm] {};\n          \\node[main node] (15) [below of=5, below=1cm] {};\n        \n          \\path[every node\/.style={font=\\sffamily\\small}]\n            (11) edge node [below=.1cm] {the} (12)\n            (12) edge node [below=.1cm] {dog} (13)\n            (13) edge node [below=.1cm] {barked} (14)\n            (14) edge node [below=.25cm] {.} (15)\n            (11) edge[bend left] node [above] {the\\_dog} (13)\n            (12) edge[bend left] node [above] {dog\\_barked\\_.} (15);\n\n          \\node[main node] (21) [below of=11, below=1cm] {};\n          \\node[main node] (22) [below of=12, below=1cm] {};\n          \\node[main node] (23) [below of=13, below=1cm] {};\n          \\node[main node] (24) [below of=14, below=1cm] {};\n          \\node[main node] (25) [below of=15, below=1cm] {};\n        \n          \\path[every node\/.style={font=\\sffamily\\small}]\n            (21) edge node [below=.1cm] {the} (22)\n            (22) edge node [below=.1cm] {dog} (23)\n            (23) edge node [below=.1cm] {barked} (24)\n            (24) edge node [below=.25cm] {.} (25)\n            (21) edge[bend left] node [above] {the\\_dog} (23)\n            (22) edge[bend left] node [above=.3cm] {dog\\_barked} (24)\n            (23) edge[bend left] node [above] {barked\\_.} (25);\n            \n            \n          \\node[main node] (31) [below of=21, below=.7cm] {};\n          \\node[main node] (32) [below of=22, below=.7cm] {};\n          \\node[main node] (33) [below of=23, below=.7cm] {};\n          \\node[main node] (34) [below of=24, below=.7cm] {};\n          \\node[main node] (35) [below of=25, below=.7cm] {};\n        \n          \\path[every node\/.style={font=\\sffamily\\small}]\n            (31) edge node [above=.1cm] {the} (32)\n            (32) edge[bend left] node [above=.1cm] {dog$_1$} (33)\n            (33) edge[bend left] node [above=.1cm] {barked$_1$} (34)\n            (34) edge node [above=.15cm] {.} (35)\n            (32) edge[bend right] node [below=.1cm] {dog$_2$} (33)\n            (33) edge[bend right] node [below=.1cm] {barked$_2$} (34);\n            \n        \\node (0) [left of=1] {(a)};\n        \\node (10) [left of=11] {(b)};\n        \\node (20) [left of=21] {(c)};\n        \\node (30) [left of=31] {(d)};\n        \n        \\end{tikzpicture}\n    \\caption{Example of (a) a single-path lattice, (b) a sparse lattice, (c) a dense lattice with $D = 2$, and (d) a multilattice with $D = 2$, for sentence ``the dog barked .''}\n    \\label{fig:lattice}\n\\end{figure}\n\n\n\\subsubsection{Direct Approximation}\n\\label{subsec:da}\n\nOne approach to approximating the hidden state is the TreeLSTM framework described by \\newcite{tai2015improved}.%\n\\footnote{This framework has been used before for calculating neural sentence representations involving lattices by \\newcite{DBLP:journals\/corr\/SuTXL16} and \\newcite{sperber2017neural}, but not for the language models that are the target of this paper.}\nIn the TreeLSTM formulation, new states are derived from multiple predecessors by simply summing the individual hidden and cell state vectors of each of them.\nFor each predecessor location $i \\in A_j$, we first calculate the local hidden state $\\tilde{h}$ and local cell state $\\tilde{c}$ by combining the embedding $e_i^j$ with the hidden state of the LSTM at $x_{<i}$ using the standard LSTM update function as in Eq.~(\\ref{eqn:lstm}):\n\\begin{align*}\n\\tilde{h}_i, \\tilde{c}_i = \\text{LSTM}(h_i,c_i,e_i^j,\\theta) \\text{ for } i \\in A_j\n\\end{align*}\n\nWe then sum the local hidden and cell states:\n\\begin{align*}\n\\begin{split}\nh_j = \\sum_{i \\in A_j} \\tilde{h}_i\n\\end{split}\n\\begin{split}\nc_j = \\sum_{i \\in A_j} \\tilde{c}_i\n\\end{split}\n\\end{align*}\n\nThis formulation is powerful, but comes at the cost of sacrificing the probabilistic interpretation of which paths are likely.\nTherefore, even if almost all of the probability mass comes through the ``true'' segmentation, the hidden state may still be heavily influenced by all of the ``bad'' segmentations as well.\n\n\\subsubsection{Monte-Carlo Approximation}\n\\label{subsec:af}\n\nAnother approximation that has been proposed is to sample one predecessor state from all possible predecessors, as seen in \\newcite{chan2016latent}. We can calculate the total probability that we reach some prefix $x_{<j}$, and we know how much of this probability comes from each of its predecessors in the lattice, so we can construct a probability distribution over predecessors in the lattice:\n\\begin{align}\n\\label{eqn:preddist}\nM(x_{<i} \\mid \\theta) = \\frac{p(x_{<i} \\mid \\theta)p(x_i^j\\mid x_{<i}; \\theta)}{p(x_{<j} \\mid \\theta)}\n\\end{align}\n\nTherefore, one way to update the LSTM is to sample one predecessor $x_{<i}$ from the distribution $M$ and simply set $h_j = \\tilde{h}_i$ and $c_j = \\tilde{c}_i$. However, sampling is unstable and difficult to train: we found that the model tended to over-sample short tokens early on during training, and thus segmented every sentence into unigrams. This is similar to the outcome reported by \\newcite{chan2016latent}, who accounted for it by incorporating an $\\epsilon$ encouraging exploration.\n\n\\subsubsection{Marginal Approximation}\n\\label{subsec:we}\n\nIn another approach, which allows us to incorporate information from all predecessors while maintaining a probabilistic interpretation, we can utilize the probability distribution $M$ to instead calculate the expected value of the hidden state:\n\\begin{align*}\nh_j = \\bm{E}_{x_{<i}\\sim M} [\\tilde{h_i}] = \\sum_{i \\in A_j} M(x_{<i} \\mid \\theta)\\tilde{h}_i \\\\\nc_j = \\bm{E}_{x_{<i}\\sim M} [\\tilde{c_i}] = \\sum_{i \\in A_j} M(x_{<i} \\mid \\theta)\\tilde{c}_i\n\\end{align*}\n\n\n\\subsubsection{Gumbel-Softmax Interpolation}\n\\label{subsec:gs}\n\nThe Gumbel-Softmax trick, or concrete distribution, described by \\newcite{jang2016categorical} and \\newcite{maddison2016concrete}, is a technique for incorporating discrete choices into differentiable neural computations. In this case, we can use it to select a predecessor.\nThe Gumbel-Softmax trick works by taking advantage of the fact that adding Gumbel noise to the pre-softmax predecessor scores and then taking the argmax is equivalent to sampling from the probability distribution.\nBy replacing the argmax with a softmax function scaled by a temperature $\\tau$, we can get this pseudo-sampled distribution through a fully differentiable computation:\n\\small\n\\begin{align*}\nN(x_{<i} \\mid \\theta) = \\frac{\\text{exp}((\\text{log}(M(x_{<i} \\mid \\theta)) + g_i)\/\\tau)}{\\sum_{k \\in A_j} \\text{exp}((\\text{log}(M(x_{<k} \\mid \\theta)) + g_k)\/\\tau)}\n\\end{align*}\n\\normalsize\n\nThis new distribution can then be used to calculate the hidden state by taking a weighted average of the states of possible predecessors:\n\\begin{align*}\n\\begin{split}\nh_j = \\sum_{i \\in A_j}^{j-1} N(x_{<i} \\mid \\theta)\\tilde{h}_i\n\\end{split}\n\\begin{split}\nc_j = \\sum_{i=j-L}^{j-1} N(x_{<i} \\mid \\theta)\\tilde{c}_i\n\\end{split}\n\\end{align*}\n\nWhen $\\tau$ is large, the values of $N(x_{<i} \\mid \\theta)$ are flattened out; therefore, all the predecessor hidden states are summed with approximately equal weight, equivalent to the direct approximation (\\S\\ref{subsec:da}). On the other hand, when $\\tau$ is small, the output distribution becomes extremely peaky, and one predecessor receives almost all of the weight. Each predecessor $x_{<i}$ has a chance of being selected equal to $M(x_{<i} \\mid \\theta)$, which makes it identical to ancestral sampling (\\S\\ref{subsec:af}). By slowly annealing the value of $\\tau$, we can smoothly interpolate between these two approaches, and end up with a probabilistic interpretation that avoids the instability of pure sampling-based approaches.\n\n\\section{Instantiations of Neural Lattice LMs}\n\\label{sec:instantiations}\n\nIn this section, we introduce two instantiations of neural lattice languages models aiming to capture features of language: the existence of coherent multi-token chunks, and the existence of polysemy.\n\n\\subsection{Incorporating Multi-Token Phrases}\n\\label{sec:multitoken}\n\n\\subsubsection{Motivation}\n\n\n\n\nNatural language phrases often demonstrate significant non-compositionality: for example, in English, the phrase ``rock and roll'' is a genre of music, but this meaning is not obtained by viewing the words in isolation. In word-level language modeling, the network is given each of these words as input, one at a time; this means it must capture the idiomaticity in its hidden states, which is quite roundabout and potentially a waste of the limited parameters in a neural network model. A straightforward solution is to have an embedding for the entire multi-token phrase, and use this to input the entire phrase to the LSTM in a single timestep. However, it is also important that the model is able to decide whether the non-compositional representation is appropriate given the context: sometimes, ``rock'' is just a rock.\n\nAdditionally, by predicting multiple tokens in a single timestep, we are able to decrease the number of timesteps across which the gradient must travel, making it easier for information to be propagated across the sentence.\nThis is even more useful in non-space-delimited languages such as Chinese, in which segmentation is non-trivial, but character-level modeling leads to many sentences being hundreds of tokens long.\n\nThere is also psycho-linguistic evidence which supports the fact that humans incorporate multi-token phrases into their mental lexicon. \\newcite{siyanova2011adding} show that native speakers of a language have significantly reduced response time when processing idiomatic phrases, whether they are used in an idiomatic sense or not, while \\newcite{bannard2008stored} show that children learning a language are better at speaking common phrases than uncommon ones.\nThis evidence lends credence to the idea that multi-token lexical units are a useful tool for language modeling in humans, and so may also be useful in computational models.\n\n\\subsubsection{Modeling Strategy}\n\nThe underlying lattices utilized in our multi-token phrase experiments are ``dense'' lattices: lattices where every edge (below a certain length $L$) is present (Fig. \\ref{fig:lattice}, c).\nThis is for two reasons.\nFirst, since every sequence of tokens is given an opportunity to be included in the path, all segmentations are candidates, which will potentially allow us to discover arbitrary types of segmentations without a prejudice towards a particular theory of which multi-token units we should be using.\nSecond, using a dense lattice makes minibatching very straightforward by ensuring that the computation graphs for each sentence are identical. If the lattices were not dense, the lattices of various sentences in a minibatch could be different; it then becomes necessary to either calculate a differently-shaped graph for every sentence, preventing minibatching and hurting training efficiency, or calculate and then mask out the missing edges, leading to wasted computation. Since only edges of length $L$ or less are present, the maximum in-degree of any node in the lattice $D$ is no greater than $L$, giving us the time bound O($L|X|$).\n\n\\subsubsection{Token Vocabularies}\n\nStoring an embedding for every possible multi-token chunk would require $|V|^L$ unique embeddings, which is intractable. Therefore, we construct our multi-token embeddings by merging compositional and non-compositional representations.\n\n\\paragraph{Non-compositional Representation}\n\nWe first establish a priori a set of ``core'' chunk-level tokens that each have a dense embedding. In order to guarantee full coverage of sentences, we first add every unit-level token to this vocabulary, e.g. every word in the corpus for a word-level model. Following this, we also add the most frequent n-grams (where $1 < n \\leq L$). This ensures that the vast majority of sentences will have several longer chunks appear within them, and so will be able to take advantage of tokens at larger granularities.\n\n\\paragraph{Compositional Representation}\n\n\nHowever, the non-compositional embeddings above only account for a subset of all $n$-grams, so we additionally construct compositional embeddings for each chunk by running a BiLSTM encoder over the individual embeddings of each unit-level token within it \\cite{dyer2016recurrent}. In this way, we can create a unique embedding for every sequence of unit-level tokens.\n\nWe use this composition function on chunks regardless of whether they are assigned non-compositional embeddings or not, as even high-frequency chunks may display compositional properties.\nThus, for every chunk, we compute the chunk embedding vector $x_i^j$ by concatenating the compositional embedding with the non-compositional embedding if it exists, or otherwise with an $\\textless$UNK$\\textgreater$ embedding.\n\n\\paragraph{Sentinel Mixture Model for Predictions}\n\nAt each timestep, we want to use our LSTM hidden state $h_t$ to assign some probability mass to every chunk with length less than $L$.\nTo do this, we follow \\newcite{merity2016pointer} in creating a new ``sentinel'' token $\\textit{\\textless s\\textgreater}$ and adding it to our vocabulary. At each timestep, we first use our neural network to calculate a score for each chunk $C$ in our vocabulary, including the sentinel token. We do a softmax across these scores to assign a probability $p_{\\textit{main}}(C_{t+1} \\mid h_t; \\theta)$ to every chunk in our vocabulary, and also to $\\textit{\\textless s\\textgreater}$. For token sequences not represented in our chunk vocabulary, this probability $p_{\\textit{main}}(C_{t+1} \\mid h_t; \\theta) = 0$.\n\nNext, the probability mass assigned to the sentinel value, $p_{\\textit{main}}(\\textit{\\textless s\\textgreater} \\mid h_t; \\theta)$, is distributed across all possible tokens sequences of length less than $L$, using another LSTM with parameters $\\theta_{\\textit{sub}}$. Similar to \\newcite{jozefowicz2016exploring}, this sub-LSTM is initialized by passing in the hidden state of the main lattice LSTM at that timestep. This gives us a probability for each sequence $p_{\\textit{sub}}(c_1,c_2,\\ldots,c_L \\mid h_t; \\theta_\\textit{sub})$.\n\nThe final formula for calculating the probability mass assigned to a specific chunk $C$ is:\n\\begin{align*}\np(C \\mid h_t; \\theta) = &p_{\\textit{main}}(C \\mid h_t; \\theta) + \\\\\n                        &p_{\\textit{main}}(\\textit{\\textless s\\textgreater} \\mid h_t; \\theta) p_{\\textit{sub}}(C \\mid h_t; \\theta_\\textit{sub}) \\nonumber\n\\end{align*}\n\n\\subsection{Incorporating Polysemous Tokens}\n\\label{sec:polysemy}\n\n\\subsubsection{Motivation}\n\nA second shortcoming of current language modeling approaches is that each word is associated with only one embedding.\nFor highly polysemous words, a single embedding may be unable to represent all meanings effectively.\n\nThere has been past work in word embeddings which has shown that using multiple embeddings for each word is helpful in constructing a useful representation. \\newcite{athiwaratkun2017multimodal} represented each word with a multimodal Gaussian distribution and demonstrated that embeddings of this form were able to outperform more standard skip-gram embeddings on word similarity and entailment tasks. Similarly, \\newcite{DBLP:journals\/corr\/ChenQJH15} incorporate standard skip-gram training into a Gaussian mixture framework and show that this improves performance on several word similarity benchmarks.\n\nWhen a polysemous word is represented using only a single embedding in a language modeling task, the multimodal nature of the true embedding distribution may causes the resulting embedding to be both high-variance and skewed from the positions of each of the true modes. Thus, it is likely useful to represent each token with multiple embeddings when doing language modeling.\n\n\\subsubsection{Modeling Strategy}\n\nFor our polysemy experiments, the underlying lattices are ``multilattices'': lattices which are also multigraphs, and can have any number of edges between any given pair of nodes (Fig. \\ref{fig:lattice}, d). Lattices set up in this manner allow us to incorporate multiple embeddings for each word. Within a single sentence, any pair of nodes corresponds to the start and end of a particular subsequence of the full sentence, and is thus associated with a specific token; each edge between them is a unique embedding for that token.\nWhile many strategies for choosing the number of embeddings exist in the literature \\cite{neelakantan2014efficient}, in this work, we choose a number of embeddings $E$ and assign that many embeddings to each word. This ensures that the maximum in-degree of any node in the lattice $D$, is no greater than $E$, giving us the time bound O($E|X|$).\n\nIn this work, we do not explore models that include both chunk vocabularies and multiple embeddings. However, combining these two techniques, as well as exploring other, more complex lattice structures, is an interesting avenue for future work.\n\n\\section{Experiments}\n\\label{sec:experiments}\n\n\\subsection{Data}\n\nWe perform experiments on two languages: English and Chinese, which provide an interesting contrast in linguistic features.%\n\\footnote{Code to reproduce datasets and experiments is available at: \\url{http:\/\/github.com\/jbuckman\/neural-lattice-language-models}}\n\nIn English, the most common benchmark for language modeling recently is the Penn Treebank, specifically the version preprocessed by \\newcite{mikolovptb}.\nHowever, this corpus is limited by being relatively small, only containing approximately 45,000 sentences, which we found to be insufficient to effectively train lattice language models.%\n\\footnote{Experiments using multi-word units resulted in overfitting, regardless of normalization and hyperparameter settings.}\nThus, we instead used the Billion Word Corpus \\cite{chelba2013one}.\nPast experiments on the BWC typically modeled every word without restricting the vocabulary, which results in a number of challenges regarding the modeling of open vocabularies that are orthogonal to this work. Thus, we create a preprocessed version of the data in the same manner as Mikolov, lowercasing the words, replacing numbers with $<$N$>$ tokens, and $<$UNK$>$ing all words beyond the ten thousand most common. Additionally, we restricted the data set to only include sentences of length 50 or less, ensuring that large minibatches could fit in GPU memory. Our subsampled English corpus contained 29,869,166 sentences, of which 29,276,669 were used for training, 5,000 for validation, and 587,497 for testing. To validate that our methods scale up to larger language modeling scenarios, we also report a smaller set of large-scale experiments on the full billion word benchmark in Appendix A.\n\nIn Chinese, we ran experiments on a subset of the Chinese GigaWord corpus.\nChinese is also particularly interesting because unlike English, it does not use spaces to delimit words, so segmentation is non-trivial.\nTherefore, we used a character-level language model for the baseline, and our lattice was composed of multi-character chunks. We used sentences from \\textit{Guangming Daily}, again $<$UNK$>$ing all but the 10,000 most common tokens and restricting the selected sentences to only include sentences of length 150 or less. Our subsampled Chinese corpus included 934,101 sentences for training, 5,000 for validation, and 30,547 for testing.\n\n\n\\subsection{Main Experiments}\n\nWe compare a baseline LSTM model, dense lattices of size 1, 2, and 3, and a multilattice with 2 and 3 embeddings per word. \n\nThe implementation of our networks was done in DyNet \\cite{neubig2017dynet}.%\n All LSTMs had 2 layers, each with hidden dimension of 200. Variational dropout \\cite{gal2016theoretically} of .2 was used on the Chinese experiments, but hurt performance on the English data, so it was not used. The 10,000 word embeddings each had dimension 256. For lattice models, chunk vocabularies were selected by taking the 10,000 words in the vocabulary and adding the most common 10,000 $n$-grams with $1 < n \\leq L$. The weights on the final layer of the network were tied with the input embeddings, as done by \\cite{press2016using,inan2016tying}. In all lattice models, hidden states were computed using weighted expectation (\\S\\ref{subsec:we}) unless mentioned otherwise. In multi-embedding models, embedding sizes were decreased so as to maintain the same total number of parameters. All models were trained using the Adam optimizer with a learning rate of .01 on a NVIDIA K80 GPU.\nThe results can be seen in Table \\ref{lm-results-en} and Table \\ref{lm-results-zh}.\n\nIn the multi-token phrase experiments, many additional parameters are accrued by the BiLSTM encoder and sub-LSTM predictive model, making them not strictly comparable to the baseline. To account for this, we include results for $L=1$, which, like the baseline LSTM approach, fails to leverage multi-token phrases, but includes the same number of parameters as $L=2$ and $L=3$.\n\nIn both the English and Chinese experiments, we see the same trend: increasing the maximum lattice size decreases the perplexity, and for $L=2$ and above, the neural lattice language model outperforms the baseline. Similarly, increasing the number of embeddings per word decreases the perplexity, and for $E=2$ and above, the multiple-embedding model outperforms the baseline.\n\n\\begin{table}[]\n\\centering\n\\caption{Results on English language modeling task}\n\\label{lm-results-en}\n\\begin{tabular}{|c|c|c|}\n\\hline\nModel             & Valid. Perp.     & Test Perp.  \\\\ \\hline \\hline\nBaseline          &  47.64           & 48.62       \\\\ \\hline \\hline\nMulti-Token ($L=1$)   &  45.69           & 47.21       \\\\ \\hline\nMulti-Token ($L=2$)   &  44.15           & 46.12       \\\\ \\hline\nMulti-Token ($L=3$)   &  45.19           & 46.84       \\\\ \\hline \\hline\nMulti-Emb ($E=2$)        &  44.80           & 46.32       \\\\ \\hline\nMulti-Emb ($E=3$)        &  \\textbf{42.76}  &  \\textbf{43.78}    \\\\ \\hline\n\\end{tabular}\n\\end{table}\n\n\\begin{table}[]\n\\centering\n\\caption{Results on Chinese language modeling task}\n\\label{lm-results-zh}\n\\begin{tabular}{|c|c|c|}\n\\hline\nModel             & Valid. Perp.      & Test Perp.  \\\\ \\hline \\hline\nBaseline          &  41.46            & 40.72       \\\\ \\hline \\hline\nMulti-Token ($L=1$)   &  49.86            & 50.99       \\\\ \\hline\nMulti-Token ($L=2$)   &  38.61            & 37.22       \\\\ \\hline\nMulti-Token ($L=3$)   &  \\textbf{33.01}   & \\textbf{32.19}       \\\\ \\hline \\hline\nMulti-Emb ($E=2$) &  40.30            & 39.28       \\\\ \\hline\nMulti-Emb ($E=3$) &  45.72            & 44.40       \\\\ \\hline\n\\end{tabular}\n\\end{table}\n\n\\subsection{Hidden State Calculation Experiments}\n\nWe compare the various hidden-state calculation approaches discussed in Section \\ref{sec:hs} on the English data using a lattice of size $L=2$ and dropout of .2. These results can be seen in Table \\ref{hs-results}.\n\nFor all hidden state calculation techniques, the neural lattice language models outperform the LSTM baseline. The ancestral sampling technique used by \\newcite{chan2016latent} is worse than the others, which we found to be due to it getting stuck in a local minimum which represents almost everything as unigrams. There is only a small difference between the perplexities of the other techniques.\n\n\\begin{figure*}[t!]\n    \\centering\n    \\includegraphics[scale=.5]{segmentations}\n    \\caption{Segmentation of three sentences randomly sampled from the test corpus, using $L=2$. Green numbers show probability assigned to token sizes. For example, the first three words in the first sentence have a 59\\% and 41\\% chance of being ``please let me'' or ``please let\\_me'' respectively. Boxes around words show greedy segmentation.}\n    \\label{fig:segmentations}\n\\end{figure*}\n\n\\begin{table}[]\n\\centering\n\\caption{Hidden state calculation comparison results}\n\\label{hs-results}\n\\small\n\\begin{tabular}{|c|c|c|}\n\\hline\nModel                & Valid. Perp.           & Test Perp.       \\\\ \\hline \\hline\nBaseline              &  64.18                & 60.67           \\\\ \\hline\nDirect (\\S\\ref{subsec:da}) &  59.74                & 55.98           \\\\ \\hline\nMonte Carlo (\\S\\ref{subsec:af}) &  62.97                & 59.08           \\\\ \\hline\nMarginalization (\\S\\ref{subsec:we}) &  \\textbf{58.62}                & \\textbf{55.06}           \\\\ \\hline\nGS Interpolation (\\S\\ref{subsec:gs}) &  59.19                & 55.73           \\\\ \\hline\n\\end{tabular}\n\\end{table}\n\n\n\n\n\n\n\n\n\n\n\\subsection{Discussion and Analysis}\n\\label{sec:discussion}\n\nNeural lattice language models convincingly outperform an LSTM baseline on the task of language modeling.\nOne interesting note is that in English, which is already tokenized into words and highly polysemous, utilizing multiple embeddings per word is more effective than including multi-word tokens.\nIn contrast, in the experiments on the Chinese data, increasing the lattice size of the multi-character tokens is more important than increasing the number of embeddings per character. \nThis corresponds to our intuition; since Chinese is not tokenized to begin with, utilizing models that incorporate segmentation and compositionality of elementary units is very important for effective language modeling.\n\n\\begin{table*}[t!]\n\\centering\n\\caption{Comparison of randomly-selected contexts of several words selected from the vocabulary of the Billion Word Corpus, in which the model preferred one embedding over the other.}\n\\label{multi-viz}\n\\begin{tabular}{|l||l|}\n\n\\hline\n\\textbf{rock$_1$} & \\textbf{rock$_2$} \\\\ \\hline\n...at the $<$unk$>$ pop , \\textit{rock} and jazz... & ...including hsbc , northern \\textit{rock} and...                       \\\\ \\hline\n...a little bit $<$unk$>$ \\textit{rock} ,...        & ...pakistan has a $<$unk$>$ \\textit{rock} music scene...          \\\\ \\hline\n...on light \\textit{rock} and $<$unk$>$ stations... & ...spokesman for round \\textit{rock} , $<$unk$>$... \\\\ \\hline \\hline\n\n\\textbf{bank$_1$} & \\textbf{bank$_2$} \\\\ \\hline\n...being a \\textit{bank} holiday in... & ...the \\textit{bank} of england has...                       \\\\ \\hline\n...all the us \\textit{bank} runs and...        & ...with the royal \\textit{bank} of scotland...          \\\\ \\hline\n...by getting the \\textit{bank} 's interests... & ...development \\textit{bank} of japan and the... \\\\ \\hline \\hline\n\n\\textbf{page$_1$} & \\textbf{page$_2$} \\\\ \\hline\n...on \\textit{page} $<$unk$>$ of the... & ...was it front \\textit{page} news...                       \\\\ \\hline\n...a source told \\textit{page} six ....        & ...himself , tony \\textit{page} , the former ...          \\\\ \\hline\n...on \\textit{page} $<$unk$>$ of the... & ...sections of the \\textit{page} that discuss... \\\\ \\hline \\hline\n\n\\textbf{profile$_1$} & \\textbf{profile$_2$} \\\\ \\hline\n...( $<$unk$>$ : quote , \\textit{profile} , research )... & ...so $<$unk$>$ the \\textit{profile} of the city...                       \\\\ \\hline\n...( $<$unk$>$ : quote , \\textit{profile} , research )...        & ...the highest \\textit{profile} $<$unk$>$ held by...          \\\\ \\hline\n...( $<$unk$>$ : quote , \\textit{profile} , research )... & ...from high i , elite schools ,... \\\\ \\hline \\hline\n\n\\textbf{edition$_1$} & \\textbf{edition$_2$} \\\\ \\hline\n... of the second \\textit{edition} of windows... & ...of the new york \\textit{edition} . ...                       \\\\ \\hline\n... this month 's \\textit{edition} of$<$unk$>$ , the ...        & ...of the new york \\textit{edition} . ...          \\\\ \\hline\n...forthcoming d.c. \\textit{edition} of the hit... & ...of the new york \\textit{edition} . ... \\\\ \\hline \\hline\n\n\\textbf{rodham$_1$} & \\textbf{rodham$_2$} \\\\ \\hline\n...senators hillary \\textit{rodham} clinton and... &                     \\\\ \\hline\n...making hillary \\textit{rodham} clinton his...        &       \\\\ \\hline\n...hillary \\textit{rodham} clinton 's campaign has... &   \\\\ \\hline\n\n\\end{tabular}\n\\end{table*}\n\nTo calculate the probability of a sentence, the neural lattice language model implicitly marginalizes across latent segmentations. By inspecting the probabilities assigned to various edges of the lattice, we can visualize these segmentations, as is done in Fig. \\ref{fig:segmentations}. The model successfully identifies bigrams which correspond to non-compositional compounds, like ``prime minister'', and bigrams which correspond to compositional compounds, such as ``a quarter''. Interestingly, this does not occur for all high-frequency bigrams; it ignores those that are not inherently meaningful, such as ``$<$UNK$>$ in'', yielding qualitatively good phrases.\n\nIn the multiple-embedding experiments, it is possible to see which of the two embeddings of a word was assigned the higher probability for any specific test-set sentence. In order to visualize what types of meanings are assigned to each embedding, we select sentences in which one embedding is preferred, and look at the context in which the word is used. Several examples of this can be seen in Table \\ref{multi-viz}; it is clear from looking at these examples that the system does learn distinct embeddings for different senses of the word. What is interesting, however, is that it does not necessarily learn intuitive semantic meanings; instead it tends to group the words by the context in which they appear. In some cases, like \\textbf{profile} and \\textbf{edition}, one of the two embeddings simply captures an idiosyncrasy of the training data.\n\nAdditionally, for some words, such as \\textbf{rodham} in Table \\ref{multi-viz}, the system always prefers one embedding. This is promising, because it means that in future work it may be possible to further improve accuracy and training efficiency by assigning more embeddings to polysemous words, instead of assigning the same number of embeddings to all words.\n\n\n\\section{Related Work}\n\\label{related}\n\nPast work that utilized lattices in neural models for natural language processing centers around using these lattices in the encoder portion of machine translation. \\newcite{DBLP:journals\/corr\/SuTXL16} utilized a variation of the Gated Recurrent Unit that operated over lattices, and preprocessed lattices over Chinese characters that allowed it to effectively encode multiple segmentations. Additionally, \\newcite{sperber2017neural} proposed a variation of the TreeLSTM with the goal of creating an encoder over speech lattices in speech-to-text.\nOur work tackles language modeling rather than encoding, and thus addresses the issue of marginalization over the lattice.\n\nAnother recent work which marginalized over multiple paths through a sentence is \\newcite{ling2016latent}. The authors tackle the problem of code generation, where some components of the code can be copied from the input, via a neural network.\nOur work expands on this by handling multi-word tokens as input to the neural network, rather than passing in one token at a time.\n\nNeural lattice language models improve accuracy by helping the gradient flow over smaller paths, preventing vanishing gradients. Many hierarchical neural language models have been proposed with a similar objective \\newcite{koutnik2014clockwork,zhou2017chunk}.  Our work is distinguished from these by the use of latent token-level segmentations that capture meaning directly, rather than simply being high-level mechanisms to encourage gradient flow.\n\n\\newcite{chan2016latent} propose a model for predicting characters at multiple granularities in the decoder segment of a machine translation system. Our work expands on theirs by considering the entire lattice at once, rather than considering a only a single path through the lattice via ancestral sampling. This allows us to train end-to-end without the model collapsing to a local minimum, with no exploration bonus needed. Additionally, we propose a more broad class of models, including those incorporating polysemous words, and apply our model to the task of word-level language modeling, rather than character-level transcription.\n\nConcurrently to this work, \\newcite{van2017multiscale} have proposed a neural language model that can similarly handle multiple scales.\nOur work is differentiated in that it is more general: utilizing an open multi-token vocabulary, proposing multiple techniques for hidden state calculation, and handling polysemy using multi-embedding lattices.\n\n\\section{Future Work}\n\nIn the future, we would like to experiment with utilizing neural lattice language models in extrinsic evaluation, such as machine translation and speech recognition. Additionally, in the current model, the non-compositional embeddings must be selected a priori, and may be suboptimal. We are exploring techniques to store fixed embeddings dynamically, so that the non-compositional phrases can be selected as part of the end-to-end training.\n\n\\section{Conclusion}\n\n\nIn this work, we have introduced the idea of a neural lattice language model, which allows us to marginalize over all segmentations of a sentence in an end-to-end fashion. In our experiments on the Billion Word Corpus and Chinese GigaWord corpus, we demonstrated that the neural lattice language model beats an LSTM-based baseline at the task of language modeling, both when it is used to incorporate multiple-word phrases and multiple-embedding words.\nQualitatively, we observed that the latent segmentations generated by the model correspond well to human intuition about multi-word phrases, and that the varying usage of words with multiple embeddings seems to also be sensible.\n\n\n\n\\bibliographystyle{acl2012}\n","meta":{"redpajama_set_name":"RedPajamaArXiv"}}
+{"text":"\\section{Introduction}\nAnalyzing social media becomes a crucial task, due to the frequently usage of social media platforms. Sarcasm detection, the conflict of using the verbal meaning of a sentence and its intended meaning \\cite{clift_1999,doi:10.1207\/s15327868ms1301}, is an important task. Sarcasm detection is a challenge, since sarcastic contents are used to express the opposing of what is being said. Recently sarcasm detection has been studied from a computational perspective as one of classification problems that separates sarcastic from non-sarcastic contents\\cite{Reyes:2013:MAD:2447287.2447294,nayel-etal-2021-machine-learning}. \n\\par{}Arabic is an important natural language having an extensive number of speakers. The research in Natural Language Processing (NLP) for Arabic is continually increasing. However, there is still a need to handle the complexity of NLP tasks in Arabic. This complexity arises from various aspects, such as orthography, morphology, dialects, short vowels, and word order. Sarcasm detection in Arabic is a particularly challenging task \\cite{Alayba_2018}. \n\\par{}In this paper, we describe the system submitted to the iSarcasm detection shared task\\cite{abufarha-etal-2022-semeval}. The shared task aims at detecting the sarcasm contents in Arabic tweets. In this work, a machine learning framework has been developed and various machine learning algorithms have been implemented. Term Frequency-Inverse Document Frequency (TF-IDF) has been used as vector space model for tweet representation. The rest of this paper is organized as follows: in section 2, a background about sarcasm detection is given. Section 3 and section 4 overview the dataset and the system respectively. Experimental setup and results are given in section 5 and section 6 respectively. Finally, section 7 concludes the proposed work and suggests future work to be continued. \n\\section{Background}\nThe research work have been done on Arabic sarcasm detection were mainly focused on creating datasets and establish a baseline for each created dataset \\cite{10.1007\/978-3-030-45442-5_18}. \\citet{karoui2017soukhria} created a corpus of sarcastic Arabic tweets that are related to politics. Distant supervision has been used for the creation of corpus. The authors used keywords that are like sarcastic contents in Arabic to label the tweets as sarcastic tweets. They implemented different machine learning algorithms such as SVM, logistic regression, Na\u00efve Bayes, and other classifiers on the developed corpus.\n\\par{}An ensemble classifier of XGBoost, random forest and fully connected neural networks has been designed by \\citet{khalifa-2019-ensemble}. They extracted a set of features that consists of sentiment and statistical features, in addition to word $n$-grams, topic modelling features and word embeddings. \\citet{nayel-2019-benha} developed an ensemble-based system for irony detection in Arabic Tweets. A set of classification algorithms namely Random forests, multinomial Na\u00efve Bayes, linear, and SVM classifiers have been used as base-classifiers. In \\cite{nayel-etal-2021-machine-learning}, sarcasm detection has been formulated as a binary classification problem and SVM has been implemented. \n\\section{Dataset}\nA new data collection method has been introduced, where the sarcasm labels for texts are provided by the authors themselves. The author of each sarcastic text rephrased the text to convey the same intended message without using sarcasm. \\citet{leggitt2000emotional} defined a set categories of ironic speech namely; sarcasm, irony, satire, understatement, overstatement, and rhetorical question. Linguistic experts have been asked to further label each text into one of these categories. Each text in the Arabic dataset has the following information attached to it:\n\\begin{itemize}\n\\item a label specifying the text dialect;\n\\item a label specifying the nature of sarcasm (sarcastic or non-sarcastic), provided by its author;\n\\item a rephrase provided by its author that conveys the same message non-sarcastically.\n\\end{itemize}\n\\section{System Overview}\nIn this section, we review the main structure of the proposed model. The proposed system, as shown in figure \\ref{diagram}, consists of three phases namely; preprocessing, feature extraction and training the classification algorithms. Then, the resulted model used to predict the unseen test data. \n\\begin{figure}[htb!]\n\\centering\\includegraphics[height=2.8in,width=0.5\\textwidth]{model}\n\\caption{\\label{diagram}The structure of the proposed model}\n\\end{figure}\n\\subsection{Preprocessing}\nThe first stage of developing systems is preprocessing, where unwanted and uninformative piece of text has to be removed, it is also called text cleaning. We performed text cleaning by removing:\n\\begin{itemize}\n\\item special symbols, such as $\\{+, -, =, \\$,....\\}$;\n\\item repeated characters such as (\"\\emph{hhhhhhhh}\" will be normalized to \"\\emph{hh}\"); \n\\item non-Arabic words, such as English characters or any other language;\n\\item punctuations and Arabic diacritics.\n\\end{itemize}\n\\subsection{Features Extraction}\nTo prepare features to build classification model and before feeding the text into the classifier and after performing text cleaning,  Term Frequency-Inverse Document Frequency (TF-IDF) technique was used to change over content to vectors and all the algorithms to investigate the best performing algorithm.\\\\\n\\indent TF-IDF has been used to represent comments as vectors. If $ <\\!\\!\\!w_1,w_2, \\ldots, w_k\\!\\!\\!> $ are the tokenized words of a comment $ \\mathcal{T}_j$, the vector associated to the comment $ \\mathcal{T}_j$ will be represented as $<\\!\\!\\!v_{j1}, v_{j2},\\ldots ,v_{jk}\\!\\!\\!>$ where $v_{ji}$ is the weight of the token $w_i$ in tweet $ \\mathcal{T}_j$ which is calculated as:- \\[v_{ji} = tf_{ji} * \\log\\left(\\frac{N+1}{df_i+1}\\right)\\] where $tf_{ji}$ is the total number of occurrences of token $w_i$ in the comment $ \\mathcal{T}_j$, $df_i$ is the number of comments in which the token $w_i$ occurs and $N$ is the total number of comment.\\\\\n\\subsection{Methodology} \nWe explored various classification algorithms as well as ensemble approach by combining the output of these classifiers (also known as base classifiers) using hard voting. The base classifiers used in this work are listed below:\n\\begin{itemize}\n\\item{Support Vector Machines (SVMs)} \n\\item{Random Forest (RF)}\n\\item{K-Nearest Neighbours (KNN)}\n\\item{Multinomial Na\u00efve Bayes (M-NB)}\n\\item{Multi-Layer Perceptron (MLP)}\n\\item{Stochastic Gradient Descent (SGD)}\n\\item{AdaBoost Classifier}\n\\item{Voting Classifier}\n\\end{itemize}\n\\section{Experimental Setup}\nFor feature extraction phase we used unigram model. For the purpose of training the model, we have used 5-fold cross-validation technique to adjust the parameters.\\\\\n\\indent The Scikit-Learn library implementation of classification algorithms were used in the training phase. \\indent For SVM, two kernels have been tested: linear kernel and RBF with two parameters $\\gamma = 2 $ and $C = 1$. While, for SGD classifier the loss function used was Hinge and the maximum iteration was set at 10000 iterations.\\\\\n\\indent The number of nodes in the hidden layer of MLP was set at 20, logistic function was used as activation function and Adam solver was used. The maximum number of decision trees in random forests is set at 300.\n\\subsection{Evaluation Metrics}\n\\par{}F1-score has been used to evaluate the performance of all submissions. F1-score is a harmonic mean of Precision (P) and Recall (R) and calculated as follow: \n\\[ F\\!\\!-\\!\\!score = \\frac{2*P*R}{P + R }\\]\nF1-score for the sarcastic class (F1-sarcastic) has been used for final evaluation.\n\\section{Results}\nThe cross validation accuracy of all training classifiers for the training set is given in Table \\ref{tab1}. It is clear that MLP gives the best accuracy with moderate Standard Deviation (STD) for the five folds while development phase, so we decided to submit the output of this classifier.\\\\\n\\begin{table}\n\\centering\n\\caption{5-fold Cross-Validation accuracy for all classifiers in the training set}\\label{tab1}\n\\begin{tabular}{l|c|c}\\hline\nClassifier & Accuracy &  STD \\\\\\hline\n SVM-Linear&81.0\\% & 0.055  \\\\\n SVM-RBF&76.6\\% & 0.003  \\\\\n MNB&76.6\\% & 0.005\\\\\n SGD&80.0\\% & 0.045\\\\\n MLP&83.6\\% & 0.045\\\\\n RF&75.8\\% & 0.056\\\\ \n KNN &79.7\\% & 0.058\\\\\nAdaBoost &75.2\\% & 0.052\\\\\nVoting&80.4\\% & 0.043\\\\\\hline\n\\end{tabular}\n\\end{table}\n\n\\begin{table}\n\\centering\n\\caption{Results of MLP classifier for the test set }\\label{tab2}\n\\begin{tabular}{l|c|c}\\hline\nMeasure & Value &  Rank \\\\\\hline\nF-1 sarcastic & 0.3746 & 14  \\\\\nF-score & 0.6024 & 11  \\\\\nPrecision (P) & 0.5968 &15\\\\\nRecall (R) &0.6608 & 17\\\\\nAccuracy&0.7329 & 8\\\\\\hline\n\\end{tabular}\n\\end{table}\n\\indent Results for test set is given in Table \\ref{tab2}. The reported results show that, while training MLP gives better accuracy among implemented machine learning classifiers. Also, it gives better rank in accuracy for the unlabelled test set. While in other metrics, the performance was not satisfied. This may resulted because of using accuracy metric while comparing different classifiers in development phase.\\\\\n\\indent A good suggestion is to use different evaluation metrics while developing the system. In addition, using different word representation models such as word embeddings, which encompasses the semantic meaning of words could improve the performance. Complex models such as deep learning models is promising, but the challenge in such models is the availability of suitable resources.    \n\\section{Conclusion}\nIn this work, a classical machine learning framework has been designed for sarcasm detection in Arabic tweets. The proposed framework reported reasonable results. The future work may include applying complex framework such as deep learning structure. In addition, word representation is very important factor that can be used in different manner such as word embeddings and transformers. \n","meta":{"redpajama_set_name":"RedPajamaArXiv"}}
+{"text":"\\section{INTRODUCTION}\n\\subsection{ Problem Definition}\nLimbs are hugely valuable to many people, in that they improve mobility and the ability to manage daily activities, as well as provide the means to stay independent. It is costly (50K USD) and time-consuming for the manufacturers to design artificial limbs customized for one person, Designing intelligence prosthetics which deal with the large differences between humans (like human body dimensions, weights, height and walking styles) is so complicated by the large variability in response among many individuals. One key reason for this is that our understanding of the interactions between humans and prostheses is not well-understood, which limits our ability to predict how a human will adapt his or her movement. Physics-based, biomechanical simulations are well-positioned to advance this field as it allows for many experiments to be run at low cost.\n\\subsection{Environment}\nWe use OpenSim \"ProstheticsEnv\" environment, which models one human leg and prosthetic in another leg see in fig(1), OpenSim is a 3D human model simulator, which consists of observations of joints, muscles and tendons, 19 actions, and the reward $R_{t}$ is the negative distance from the desired velocity in eq(~\\ref{eq:reward}).\n\\begin{figure}[ht!]\n\\begin{center}\n\\includegraphics[width=0.3\\textwidth]{figures\/OpenSim1.png}\n\\label{fig:OpenSim ProstheticEnv Environment}\n\\caption {OpenSim ProstheticEnv Environment.}\n\\end{center}\n\\end{figure}\n\\begin{equation}\n{R_{t}=9-(3-V_{t})^2}\n\\label{eq:reward}\n\\end{equation}\nwhere $V_{t}$ is the horizontal velocity vector of the pelvis.\nOpenSim environment has a limitation it is very slow to run due to the high number of observations and state variables.\n\n\\subsection{Reinforcement Learning (RL) algorithms}\nReinforcement Learning (RL) will help prosthetics to calibrate with differences between humans and differences between walking environments \\cite{c1}, RL is a machine learning paradigm, where an agent learns the optimal policy for performing a sequential decision making without complete knowledge of the environment \\cite{c2}. The agent must explore the environment by taking action $A_{t}$ and edit the policy according to the reward function to maximize the reward $R_{t}$.\nWe use the DDPG algorithm \\cite{c3}, TRPO and PPO to train the agent. DDPG is a model-free, off-policy actor-critic algorithm using deep function approximators that can learn policies in high-dimensional, continuous action spaces.\n\\subsection{Imitation Learning}\nThe main problem with RL algorithms is the time needed to solve the problem -training time- because the algorithm must explore the environment and adapt its policy according to the reward at every timestep. Imitation learning is a specific subset of RL where the learner tries to mimic an expert's action in order to achieve the best performance. The main advantage of DAgger is that the expert teaches the learner how to recover from past mistakes \\cite{c4}, and we aim to leverage this to illustrate behaviour learning. \nThere are many ways to accelerate the learning process in RL, such as Cross-Domain Transfer \\cite{c2}, Inter-task Mapping via Artificial Neural Network (ANN) \\cite{c5}. We use Imitation learning to achieve that by implementing DAgger algorithm. The DAgger algorithm has shown to be able to achieve expert-level performance after a few data aggregation iterations \\cite{c6}.\nTo use imitation learning there are two assumptions:\n\\begin{enumerate}\n    \\item Similarity between the expert and the target agent in actions, observations space and the reward function.\n    \\item Environment must be described by a Markov Decision Process (MDP).\n\\end{enumerate}\nIn the standard DAgger algorithm, the target agent exploits the expert policy and stops exploring the environment. This may be a problem, as the target agent should balance between exploitation and exploration. We propose some improvements to the DAgger algorithm to encourage the exploration.\n\\section{Experiments}\nWe run the following experiments:\\footnote{codes available at \\url{github.com\/montaserFath\/Reinforcement-Learning-for-Prosthetics}}\n\\begin{enumerate}\n    \\item Run RL algorithms (DDPG, TRPO and PPO) in OpenSim ProstheticsEnv, 2,000 episodes and 1,000 timesteps in the episode to give an agent more time to walk or stand up.\n    \\item we trained a DDPG agent to achieve positive reward (around +100) in the standing up task.\n    \\item we use that agent as an expert to evaluate the DAgger algorithm.\n    \\item we modify DAgger so that the expert agent labels the target agent's actions based on the timestep reward, by comparing between the timestep reward of the expert agent and the target agent on a given timestep: if the expert agent has less reward than the target agent, the expert keeps the target agent's action and the opposite is true.\n    \\item we use the target action value instead of timestep reward to do the comparison, and we sum the timestep rewards from a given state and action pair until the end of the episode\n    \\item we used the epsilon-greedy method \\cite{c2}, where the algorithm has the choice to select between taking the target action with a probability $ 1-\\epsilon $ or the expert action with a probability $\\epsilon$.\n\\end{enumerate} \n\\section{Results}\nThe maximum reward mean achieved by TRPO (see table~\\ref{table:OpenSim_ProstheticsEnv} and fig~\\ref{fig:Number_of_Iterations}), but it takes more time comparing with PPO and DDPG because it need to find the inverse of matrix which takes time. Although of this reward the agent can not walk for more than one step and sometimes it falls before the first step.\nDagger algorithm achieved the best average reward comparing with other algorithms which balance between exploiting and exploring (see fig~\\ref{fig:imitation_learning}), we think the reasons behind that:\n\\begin{enumerate}\n    \\item The expert policy has a high reward.\n    \\item The high similarity between expert and naive agent.\n    \\item The naive agent needs more time to run by increasing the number of iterations.\n\\end{enumerate} \nThe main problem with timestep reward modification, it compares timestep reward (short-term) adding to this the large variation between timesteps. When the variation between episodes is small in Action-value.\nThe naive agent has gotten a reward greater than the expert agent, so roles can be exchanged, the expert can be naive and the naive can be an expert which will decrease training time significantly.\n\\begin{figure}[ht!]\n\\begin{center}\n\\includegraphics[width=0.4\\textwidth]{figures\/pro_mean.png}\n\\caption{Number of Iterations VS Reward Mean in OpenSim ProstheticsEnv Environment.}\n\\label{fig:Number_of_Iterations}\n\\end{center}\n\\end{figure}\n\\begin{table}[ht!]\n\\begin{center}\n\\begin{tabular}{|c|c|c|}\n \\hline\n\\textbf{Algorithm} & \\textbf{Maximum reward} & \\textbf{Mean reward} \\\\  \\hline\n\\textbf{DDPG} &  113 & -42 \\\\  \\hline\n\\textbf{TRPO} & 194 & 43 \\\\  \\hline\n\\textbf{PPO} & 70 & -58 \\\\  \\hline\n\\end{tabular}\n\\caption{Comparison between algorithms in ProstheticsEnv.}\n\\label{table:OpenSim_ProstheticsEnv}\n\\end{center}\n\\end{table}\n\\begin{figure}[ht!]\n\\begin{center}\n\\includegraphics[width=0.45\\textwidth]{figures\/plots.png}\n\\caption{Comparison between DAagger algorithm, Timestep Reward, action value and Epsilon-greedy}\n\\label{fig:imitation_learning}\n\\end{center}\n\\end{figure}\n\\section{CONCLUSIONS}\nWe have applied imitation learning in a humanoid environment to accelerate the learning process. The naive agent reaches convergence within 5  iterations while the expert reaches it after 100 iterations which means reducing training time by 95\\%. \nThe DAgger algorithm achieved the best average reward comparing with other algorithms which balance between exploiting and exploring, these algorithms will work better when there is some degree of variation between expert and naive agent and this is what we are planning to do in the future by apply imitation learning from normal human legs to prosthetic, the main challenge will be how to figure out the differences and similarities between it.\n\\section{Research Limitations}\n\\begin{enumerate}\n    \\item The prosthetic model can not walk for large distances even can falls before completing the first step.\n    \\item Each experiment runs for one time, So we are planing to repeat each experiment number of times with different random seeds and take the average and variance.\n    \\item We used same hyperparameters for all algorithm to benchmark algorithms, we need to select the best hyperparameters for each algorithm and environment.\n    \\item We benchmarcked three RL algorithms only and from one library(ChainerRL). So we are planing to use different implementations.\n\\end{enumerate}\n\\addtolength{\\textheight}{-12cm}  \n","meta":{"redpajama_set_name":"RedPajamaArXiv"}}
+{"text":"\\section{Introduction}\nApproximate nearest neighbor (ANN) search plays a crucial and long standing role in various domains, including databases, computer vision and machine learning.\nSince collecting large amounts of data became easier, any algorithm involved in indexing and searching such data must be sufficiently scalable. Therefore, the creation of a scalable and efficient data structure for retrieving similar items has become an active research topic.\nEven when leveraging modern hardware, it remains impractical to perform an exhaustive search over billions of high-dimensional data points. This is especially true when tackling this problem under additional constrains such as a reasonable memory consumption and low latency.\nTo keep up with the scale of data, modern approaches use index structures that that are heavily tailored towards exploiting the massive parallelism of GPUs~\\cite{wieschollek2016efficient,johnson2019billion,chen2019vlq,harwood2016fanng} or custom hardware~\\cite{PQFPGA} compared to previous CPU-based methods~\\cite{flann_pami_2014,PQ,1BPQ,localPQ,optimizedPQ,invertedmultiindex,Babenko_2015_CVPR,Babenko_2014_CVPR}.\n\nDespite all recent advances, the only available method for guaranteed retrieval of the exact nearest neighbor is still exhaustive search due to the curse of dimensionality~\\cite{Weber1998AQA}. Instead, most popular methods relax the problem by searching for an entry that is likely to be the nearest neighbor, accepting a minimal loss in accuracy. The quality of the recall however heavily depends both on the choice of the search structure and the executed query. Structures based on quantization or hashing\/binning schemes~\\cite{PQ,1BPQ,localPQ,optimizedPQ,invertedmultiindex,Babenko_2015_CVPR,Babenko_2014_CVPR,wieschollek2016efficient,chen2019robustiq,johnson2019billion,Matsui2015PQTableFE} can be efficiently built but typically suffer from relatively low recall rates as enumerating and visiting neighboring cells is exhaustive in high dimensions. Better recall rates are recently achieved by graph-based methods~\\cite{harwood2016fanng,dong2011efficient,chen2009fast,Warashina2014EfficientKN,fu2016efanna,fu2019fast}, but building effective graph-based index structures requires global optimization or sequential updates on edges. Their construction time has to be measured in hours or days~\\cite{Matsui2015PQTableFE}.\n\nWe propose a novel hierarchical construction scheme that allows for fully parallel construction of a highly effective search structure, which is based on a kNN-graph with additional links.\nThe structure is designed to be built and traversed on the GPU, \\emph{e.g}\\onedot} \\def\\Eg{\\emph{E.g}\\onedot, the graph contains a fixed number of outgoing links per data point.\nCoarsened graphs, by selecting only a subset of the data base, are used to build a search tree.\nThe kNN-tree is built hierarchically via bottom-up merging of concurrently constructed sub-trees, where each sub-tree already provides a consistent kNN-graph for the contained data points at each layer.\nQueries from the top of the hierarchy are used to locate nearest neighbors in the other sub-trees to merge the trees layer by layer. A parallel local scheme optimizes for both very consistent local neighborhoods as well as additional links that are important for precise traversal (graph-diversification).\nThese symmetric links ensure that each data point inside a neighborhood can be found from its own neighbors or any query from any direction. The hierarchy is necessary to build up a high-quality kNN-graph in parallel. During the final query, our algorithm however\ndirectly descents\nfrom the top to the bottom layer, which turned out to be more efficient.\n\nAs evidenced by our empirical evaluation,\nthe presented scheme outperforms existing approaches concerning both the construction as well as the query time.\nAt the same time, the recall rate is consistently high and can be traded in for only even faster query or build time.\nWe present a multi-GPU scheme that is capable of achieving above 99\\% recall even for large data sets with billions of high-dimensional entries.\n\\section{Related Work}\nA large amount of literature exists on designing structures that accelerate a nearest neighbor search. Besides traditional approaches~\\cite{KD-tree, flann_pami_2014} most popular techniques rely either on data quantization in clusters~\\cite{PQ,1BPQ,localPQ,optimizedPQ,invertedmultiindex,Babenko_2015_CVPR,Babenko_2014_CVPR,wieschollek2016efficient,chen2019robustiq,johnson2019billion,Matsui2015PQTableFE} or building neighborhood graphs~\\cite{harwood2016fanng,dong2011efficient,chen2009fast,Warashina2014EfficientKN,fu2016efanna,fu2019fast}. To achieve peak performance, most of these methods compute a compressed representation for each entry as large datasets will not fit in fast memory. There exists several strategies to compute such a compression. While hashing methods~\\cite{LSH,Andoni2008,Korman2011} produce compact binary codes, quantization-based methods reuse centroids by assigning each data point a unique identifier based on the centroid to which they belong. It has been empirically shown, that quantization methods are more accurate than various hashing methods~\\cite{PQ,flann_pami_2014}.\n\n\\textit{Quantization methods} for nearest neighbor search using clustering methods were popularized by J{\\'e}gou~\\emph{et al}\\onedot~\\cite{PQ} while originally being introduced in~\\cite{originalPQ}. Such index structures like IVFADC~\\cite{PQ} partition the high-dimensional search space into disjoint Voronoi cells described by a set of centroids obtained by Vector Quantization (VQ)~\\cite{VQ}. The idea has been extended later by Babenko~\\emph{et al}\\onedot~\\cite{invertedmultiindex}, where the high-dimensional vector-space is factored in orthogonal subspaces. Hereby, each vector is assigned to a centroid independently for each subspace according to a separate codebook that resides there. Wieschollek~\\emph{et al}\\onedot~\\cite{wieschollek2016efficient} proposed a hierarchical representation of the codebook besides demonstrating superior performance using a GPU. Johnson~\\emph{et al}\\onedot~\\cite{johnson2019billion} ported IVFADC~\\cite{PQ} to the GPU in combination with a fast GPU-based implementation for k-selection, \\emph{i.e}\\onedot} \\def\\Ie{\\emph{I.e}\\onedot returning the $k$ lowest-valued elements from a given list (a crucial part of quantization based methods). They are the first employing multi-GPU parallelism by replication and sharding. Their work forms the library ``FAISS''. Eventually, Chen~\\emph{et al}\\onedot~\\cite{chen2019robustiq} proposed a GPU based method RobustiQ overcoming the memory limitations of FAISS by extending the idea of Line Quantization from ~\\cite{wieschollek2016efficient} in a hierarchical fashion. Still, the reported distances are only an approximation of the true distance.\n\nAll hashing and quantization-based indexing schemes share the same problem that they partition the space into cells.\nWhile the containing cell for a query might be found very efficiently, the exact nearest neighbor might be across the boundary to one of the neighboring cells. Determining and visiting all neighboring cells in high dimension is a problem severely limiting these approaches.\n\n\\textit{kNN-graph} based methods are another way to accelerate the query process. Our approach presented in this paper belongs to this category. The main idea is to link each point from the search space to $k$ of its nearby points. Each query will start at a random guess in the dataset. Then, the guess itself is refined by replacing it with a better point from the $k$ linked points. Chen~\\emph{et al}\\onedot~\\cite{chen2009fast} propose a fast divide and conquer strategy for computing such kNN-graphs. Done~\\emph{et al}\\onedot~\\cite{dong2011efficient} introduced NN-descent for using kNN-graphs to accelerate NN-search. Hereby, each point maintains a list of its own nearest neighbors and points where itself is considered as a nearest neighbor. This has been later extended~\\cite{Warashina2014EfficientKN} to make use of MapReduce. EFANNA as a multiple hierarchical index structure uses a truncated KD-tree to build a kNN-graph~\\cite{fu2016efanna}. In the ideal case, a kNN-graph augmented with additional links could guarantee that for an arbitrary start point the NN-descent will converge to the correct solution. Computing such a graph with additional links at scale is not practicable. Therefore, several methods exist to at least approximate such a graph~\\cite{fu2019fast,harwood2016fanng}. Fu~\\emph{et al}\\onedot~\\cite{fu2019fast} introduce NSG as an approximation.\nTo reduce the overall number of edges, their optimization tries to lower the out-degree individually per node.  Their method can scale beyond multiple cores, outperforming a GPU approach~\\cite{johnson2019billion} on a benchmark dataset.\nHarwood~\\emph{et al}\\onedot~\\cite{harwood2016fanng} suggest an alternative approach for constructing such a graph. Starting from a fairly dense graph, they remove ``shadowed edges'', which are redundant when considering traversing paths during a query. They showed promising results using the GPU but only on rather small datasets as their build time is rather high.\nMalkov~\\emph{et al}\\onedot~\\cite{malkov2018efficient} build a hierarchical graph structure to accelerate the nearest neighbor search.\n\nWhile ours uses a hierarchy as well to build the index structure, ours differs during the query process.\nWe will describe the usage of kNN-graphs in more detail in the next section.\n\\section{Background}\n\\label{sec:background}\nIn this section, we formally introduce the approximate nearest neighbor problem statement and used notations.\n\\subsection{ANN Search}\n\\label{subsec:annsearch}\nThe nearest neighbor problem retrieves a point from a dataset $x\\in\\mathcal{X}=\\left\\{x_1,\\ldots,x_n\\right\\}$ that has the smallest distance to a query $q$. For the sake of simplicity, we assume an Euclidean space ($\\mathcal{X}\\subseteq\\mathbb{R}^d$). Other distance metrics could easily be incorporated. The nearest neighbor $x^\\star\\in\\mathcal{X}$ of $q\\in\\mathbb{R}^d$ therefore is defined as\n\\begin{align}\n    x^\\star = \\argmin_{x\\in \\mathcal{X}} \\norm{q-x}_2, \\label{eq:nnsearch}\n\\end{align}\nwhere $\\norm{\\cdot}_2$ denotes the Euclidean distance.\nSimilarly, the $k$-nearest neighbor search retrieves the $k$ closest entries from $\\mathcal{X}$ for a given query. As finding the exact nearest neighbor might be costly, we accept points in $\\mathcal{X}$ which are close to $q$ and therefore deliver an approximate solution to Eq.~\\eqref{eq:nnsearch}.\n\\subsection{KNN Graph}\n\\label{subsec:knngraph}\nLet $x$ be a fixed but arbitrary point from the dataset $\\mathcal{X}$. We build a graph structure, where each point from $\\mathcal{X}$ represents a node in the graph. Further, we define $\\mathcal{N}_x\\subseteq \\mathcal{X}$ as a local neighborhood of $x$ and defer the details on how to construct $\\mathcal{N}_x$ to the next section.\nThe edges of the graph are then defined as $(u,v)$ where $v\\in \\mathcal{N}_u$. Note, the resulting graph is a directed graph $G=(\\mathcal{X}, E)$, where $E=\\left\\{(u,v)\\;|\\;u\\in\\mathcal{X}, v \\in \\mathcal{N}_u\\right\\}$.\n\nOne greedy algorithm to find the nearest neighbor for a query point $q$ is \\textit{NN-descent}~\\cite{dong2011efficient}.\nStarting from an initial guess $\\hat{x}\\in\\mathcal{X}$, the distance between $q$ and each point $y\\in \\mathcal{N}_{\\hat{x}}$ is computed.\nIf any $y\\in \\mathcal{N}_{\\hat{x}}$ is closer to $q$ than $\\hat{x}$, the guess $\\hat{x}$ is replaced by the closest point from $\\mathcal{N}_{\\hat{x}}$ to $q$. This process repeats until no point in $\\mathcal{N}_{\\hat{x}}$ has a smaller distance to $q$ than $\\hat{x}$.\nHowever, as the current $\\hat{x}$ might not provide an edge into the right search direction, this greedy algorithm might get stuck in a local optimum on a pure kNN-graph.\n\nBefore explaining our proposal of how to efficiently construct the kNN-graph $G$, we outline common pitfalls that impair the performance of NN-descent.\n\\paragraph{Common pitfalls.}\nSince the NN-descent is a greedy search, it offers no guarantee of finding the exact solution. Some of the reasons are listed below:\n\n\\textit{Connectivity:}\nAs a kNN-graph is a directed graph, $v$ might be directly connected to $u$ being the nearest neighbor, hence $v\\in\\mathcal{N}_u$. But this does not imply that the inverse link exists ($u\\in\\mathcal{N}_v$). Therefore, the construction of a kNN-graph has to deal with synchronizing outgoing and incoming (inverse) edges.\n\n\\textit{Gaps in high-dimensional spaces:} As each point is only linked to a finite number of local neighbors, there exist pathological cases (even in 2D), where close-by points are not directly connected at all.\nSuch a case is illustrated in Figure~\\ref{fig:slack}.\nDue to the gap, the true nearest neighbor will not be found.\nComputing an idealized monotonic relative neighborhood graph~\\cite{fu2019fast} (MRNG) would avoid this issue, but it would require a strongly varying connectivity, which is not suitable for parallel approaches -- besides the additional computational burden.\n\n\\textit{Degree of nodes:} There exists a trade-off when choosing the size of $\\mathcal{N}_{x}$ for any $x\\in\\mathcal{X}$. Too few edges amplify the previously described issues, but reduce the number of necessary comparisons. While many edges allow the greedy search to escape from local neighborhoods, they increase the cost for each iteration.\n\\newcommand{$k_\\text{nn}$}{$k_\\text{nn}$}\n\\newcommand{$k_\\text{sym}$}{$k_\\text{sym}$}\n\\SetStartEndCondition{ }{}{}\\SetKwProg{Fn}{Function}{:}{end}\n\\SetKwFunction{BT}{BuildGraph}\\SetKwFunction{Init}{init\\_tree}\\SetKwFunction{Merge}{merge}\\SetKwFunction{Sym}{sym}\\SetKwFunction{Query}{query}\\SetKwFunction{SymQuery}{sym\\_links}\\SetKwFunction{Stats}{compute\\_stats}\\SetKwFunction{Select}{select}\n\\SetKw{KwTo}{ to }\n\\SetKwFor{For}{for}{\\string:}{}\\SetKwFor{ParFor}{for all}{\\string do in parallel:}{}\\SetKwIF{If}{ElseIf}{Else}{if}{:}{elif}{else:}{}\\SetKwFor{While}{while}{:}{fintq}\\AlgoDontDisplayBlockMarkers\n\\SetAlgoNoEnd\n\\SetAlgoNoLine\n\\SetKwData{LT}{$l_{top}$}\n\\SetKwData{LB}{$l_{btm}$}\n\\SetKwData{Layer}{$l$}\n\\SetKwData{L}{$l$}\n\\SetKwData{Li}{$l_i$}\n\\SetKwData{K}{$k$}\n\\SetKwData{KL}{$k_{nn}$}\n\\SetKwData{KF}{$k_{sym}$}\n\\SetKwData{XIb}{$\\tau_{b}$}\n\\SetKwData{XIq}{$\\tau_{q}$}\n\\SetKwData{XIg}{$\\tau$}\n\\SetKwData{Base}{\\texttt{base}}\n\\SetKwData{Tree}{\\texttt{graph}}\n\\SetKwData{Buffer}{$b$}\n\\SetKwData{N}{$n$}\n\\SetKwData{Q}{$q$}\n\\SetKwData{X}{$x$}\n\\SetKwData{Sbf}{$\\mathbf{s}$}\n\\SetKwData{S}{$s$}\n\\SetKwData{Si}{$\\S_{i}$}\n\\SetKwData{Pbf}{$\\mathbf{{p}}$}\n\\SetKwData{P}{$p$}\n\\SetKwData{A}{$a$}\n\\SetKwData{Cache}{$cache$}\n\\SetKwData{Best}{$best$}\n\\SetKwData{PrioQ}{$prioQ$}\n\\SetKwData{Dist}{$dist$}\n\\SetKwFunction{TopSeg}{getTopSegment}\\SetKwFunction{StartPoint}{getStartPoint}\\SetKwFunction{Fetch}{fetch}\\SetKwFunction{Init}{init}\\SetKwFunction{Add}{add}\\SetKwFunction{Push}{push}\\SetKwFunction{Pop}{pop}\\SetKwFunction{Connected}{is\\_connected}\\SetKwFunction{Transform}{transform}\\SetKwFunction{Clear}{clear\\_visited}\\SetKwFunction{Skip}{skip\\_criteria}\\SetKwFunction{SkipSym}{skip\\_criteria\\_sym}\\SetKwFunction{Tlayer}{layer}\n\\section{Approximate Symmetric Nearest Neighborhood Graph Construction}\n\\label{sec:method}\n\\subsection{Overview}\nThe core of our method exploits kNN-graph structures to support high-quality recall queries.\nAs a pure unidirectional kNN-graph is not well suited for searching, it is augmented by two important link types. On the one hand, symmetric links are inserted where necessary to ensure that a query point which happens to lie between two data points is guaranteed to reach both independently from where the search started. The second ingredient is to support a hierarchy of coarsened sub-graphs similar to \\cite{malkov2018efficient} to ensure that all parts of the graph are connected and gaps in the data set are bridged. In addition, the hierarchy minimizes the number of hops between any pair of sub-graphs.\n\\begin{figure}[tb]\n\\centering\n \\includegraphics[width=.9\\columnwidth]{figures\/merging_tree.pdf}\n \\caption{Several steps of building the hierarchical structure.}\n \\label{fig:tree_construction}\n\\end{figure}\n\nBesides the quality of the results, our approach also focuses on the execution time, both for carrying out a query as well as for constructing the search graph. Both operations are supported on the GPU. Parallelization is enabled by a constant connectivity $k$ for all nodes. Constructing the hierarchy exploits very efficient distance computations between all points within a small batch to initialize kNN sub-graphs. The sub-graphs are recursively fused into sub-trees by selecting a few samples from each sub-graph to form a coarser top layer. Adding another layer is efficiently used to establish and update the correct NN-links between all points in the sub-layers by executing a query from the top of the currently built structure (see Figure~\\ref{fig:tree_construction}). This bottom-up construction creates a robust searchable kNN-graph for each merged tree. It can be parallelized on multiple GPUs to even support datasets with large memory requirements.\n\nThe hierarchy is mainly used to quickly construct a high-quality search structure. To answer a query in the refined graph, traversing the various layers is, however, too expensive. It is significantly faster to start a search directly at the bottom layer, given the right starting points.\n\\subsection{Query}\n\\label{subsec:query}\nSearching for $k$ nearest neighbors is the central operation both in answering a query as well as in building the kNN search graph. The graph consists of $n$ points $x$, for each of which a list of $k = k_\\text{nn} + k_\\text{sym}$ outgoing links are stored, representing the local neighborhood $\\mathcal{N}_x$.\nUp to $k_\\text{nn}$, these links represent the true nearest neighbors found so far while the remaining $k_\\text{sym}$ represent potential inverse or symmetric links to points which have $x$ in their nearest neighbor list (see Section~\\ref{subsec:symmetry}).\n\nGiven a starting point $x$ for query $q$, a greedy downhill search with backtracking is executed. Starting with $x$, the distance of $q$ to all neighbors of $x$, $y \\in \\mathcal{N}_x$, is computed and all points are inserted into a priority queue. The same procedure is repeated for the best point in the queue. A cache structure (Section~\\ref{subsec:caching}) stores which points already have been visited to avoid revisiting the same point over and over again. Finally, the best $k$ points found so far are returned.\n\n\n\\noindent \\textbf{Stopping Criterion.} In order to estimate when the $k$-closest point has been found, the search will terminate once the distance $d_\\text{next}$ to the best not yet visited point exceeds a threshold $\\xi$ beyond the distance to the $k$-closest known point $d_{\\text{best}_k}$, i.e.\\ if\n\\begin{equation}\n\\label{eq:stopping}\nd_\\text{next} > d_{\\text{best}_k} + \\xi =  d_{\\text{best}_k} + \\tau \\cdot \\min\\{d^+_{\\text{nn}_{1}}, d_{\\text{best}_1}\\}\n\\end{equation}\nholds, where $d^+_{\\text{nn}_{1}}$ denotes the maximum distance of the data points to their closest neighbor within a region of the graph (Figure~\\ref{fig:slack}).\nThe parameter $\\tau$ controls the size of the safety margin, while $d_{\\text{best}_1}$ serves as an estimate of the average local distance between points and $d^+_{\\text{nn}_{1}}$ provides a global limit.\n\\newline\n\\noindent \\textbf{Hierarchical Query.} Building up the search structure creates a tree of multiple layers. Starting at the coarsest layer, a query is carried out by brute force comparison against all nodes in the top layer segment. The best $k$ points found there will be the starting points on the next finer level, where a downhill search is executed as just explained. Again, the best $k$ points are used in the next finer layer. This is important to ensure that the final nearest neighbors are actually being approached from multiple sides to circumvent potential gaps. All points at a coarser level are also represented at a finer level, but at both levels with a different neighborhood. Thus, at coarser layers, the points are simply replicated.\nThe computed distances between points remain valid across levels.\n\\begin{figure}[tb]\n    \\centering\n    \\begin{subfigure}[t]{.45\\linewidth}\n        \\centering\n        \\includegraphics{figures\/slack}\n        \\caption{Adding a slack $\\xi$ allows to escape a local minimum $\\hat{x}$ eventually reaching the solution $x^\\star$ for a query $q$.}\n        \\label{fig:slack}\n    \\end{subfigure}\n    \\hfill\n    \\begin{subfigure}[t]{.45\\linewidth}\n        \\centering\n        \\includegraphics{figures\/unsymmetric}\n        \\caption{Maintaining symmetric links. The edge $e$ is added to allow propagating nearest neighbor information between $z$ and $\\hat{x}$.}\n        \\label{fig:symmetric_links}\n    \\end{subfigure}\n    \\caption{Design options to prevent the greedy search algorithm from getting trapped in a local neighborhood.}\n\\end{figure}\n\\subsection{Symmetry}\n\\label{subsec:symmetry}\nIn order to reach any point from any direction, every edge of the graph, in principle, should be undirected.\nWhen every point should at least know its $k_\\text{nn}$ nearest neighbors, the total number of edges per point $x$ would vary significantly for an undirected graph as the number of points which have $x$ as their nearest neighbor will heavily depend on the geometry of the local neighborhood. However, to maintain a fixed number of edges $k$, our graph consists only of directed, \\emph{i.e}\\onedot} \\def\\Ie{\\emph{I.e}\\onedot, outgoing edges (Section~\\ref{subsec:query}).\nThe list of links of point $x$ however is split into $k_\\text{nn}$ direct links to nearest neighbors of $x$ as well as $k_\\text{sym}$ potential inverse links to points which have $x$ in their nearest neighbor list.\nIn our implementation, the number of utilized inverse entries can vary, but it is guaranteed that that at least $k_\\text{nn} \\ge k\/2$ nearest neighbors are kept and will not be overwritten.\n\nAs the number of representable inverse links is limited, one has to determine which of the inverse links are necessary.\nHarwood and Drummond~\\cite{harwood2016fanng} introduce the concept of shadowed links, where a link from $x$ to $z$ is removed from the graph if a one-hop connection exists $(x \\rightarrow y \\rightarrow z)$ with $d(x,y) < d(x,z)$. Optimizing the entire graph to remove all potential shadow edges requires a complex global optimization. The same holds for the construction of monotonic relative neighborhood graphs~\\cite{fu2019fast} .\n\nInstead, we propose a relatively simple but effective, local criterion which enables faster construction times: It is clear, that an inverse link $x \\rightarrow z$ only needs to be considered if $z$ is not already in $x$'s $k_\\text{nn}$ nearest neighbor list (Figure~\\ref{fig:symmetric_links}).\nIn addition, the link is only considered to be included if there does not yet exist an indirect path back from $x$ to $z$ within the current graph structure.\nThis is checked by launching a query. If there is no path within the $\\xi$ range, the link is added.\n\nDuring construction, all points in parallel test for their $k_\\text{nn}$ neighbors if an inverse link should be added.\nFor the potentially $k_\\text{nn}$ queries, we maintain one local cache per point such that the cost of testing for indirect paths is really small as the query already starts within the direct vicinity and most distance calculations can be reused.\n\nInserting $z$ into $x$'s inverse list is done using an atomic increment on $k_\\text{sym}$. On average, less than $k\/4$ inverse links are necessary this way.\nIf $k_\\text{sym}$ is already full, the link is entered in the next best candidate along the path.\nIf no candidate is found the link is ignored. In our setting, this is, however, a very rare case and $z$ might potentially still be reachable through the hierarchy.\n\\subsection{Hierarchical Construction}\n\\label{subsec:hierarchy}\nIn order to cope with large-scale datasets or to allow for dynamic updates, there is a need to also scale the index construction according to modern hardware by a highly parallelizable approach.\n\nTypically, the construction of graph based-index structures is performed on CPUs \\citet{harwood2016fanng, fu2019fast, fu2016efanna, malkov2018efficient,li2019approximate}. Theses approaches rely on a global optimization schemes, where new edges are added sequentially (graph-diversification). While \\citet{malkov2018efficient} already leverage some sort of parallelization in the construction, their approach is still very dependent on global memory synchronization. Hence, their speed-up for each additional core is in logarithmic-scale. Additionally, all approaches work with dynamic edge lists for each point that vary heavily over the course of the construction. Thus, resulting in potentially high peak memory consumption and unconstrained access patterns.\n\nSuch graph-diversification methods already generate all relevant links ensuring global connectivity and avoiding local gaps, thus resulting in an effective search graph.\nUnfortunately, their construction time is generally very long -- even for million-scale point sets.\n\nThe goal of our parallel hierarchical construction scheme is to easily scale to large datasets.\nAs each sub-tree can be constructed independently, build-up times are within seconds for million-scale datasets and the scheme can easily be implemented via sharding in a multi-GPU setup. While flat, locally constructed kNN-based graphs might contain gaps impairing the query performance, the hierarchical structure will automatically provide bridges in these cases at some higher level.\n\nOur hierarchical construction procedure is illustrated in Figure~\\ref{fig:merging_new}.\nWe start with partitioning the complete dataset into $b$ batches of size $s$ and compute the brute-force kNN-graph for each batch.\nSince $s$ is generally small, e.g. $32$, this can be done quickly. After adding symmetric links, the batches form flat kNN-graphs that can also be seen as a hierarchical search graph of height $l=1$. First, $s$ points are selected equally from the current top layers of the $g$ sub-trees. For the top layer, a kNN-graph is constructed using brute-force distance calculations followed by symmetrization. Starting from the top, for each layer, one after the other, a query for all points is performed to find all nearest neighbors in that layer across all $g$ sub-trees and the kNN lists are updated accordingly. Afterwards, symmetric links are inserted. This way, all $g$ partitions of this layer are merged to form one consistent kNN-graph.\n\nAs the initial query into the $g$ sub-graphs might not always report the correct nearest neighbor at the first trial, one can run a couple of refinement iterations per layer. The quality of the initially imprecise kNN-graphs will improve with each iteration.\nAll layers are fused together top-down and a new search-tree emerges.\n\nEvery time the bottom layer is reached, we also save the distance to the first nearest neighbor $d_{nn_1}$ for each point and compute the mean and max over the dataset. This allows for an easy adaption of our stopping criterion (Eq.~\\eqref{eq:stopping}) to the given dataset. For selecting the points for the top layer, weighted reservoir sampling with $d_{nn_1}$ as weights is used with the method of \\citet{EFRAIMIDIS2006181}.\n\nThe entire merging approach for three sub-graphs is illustrated in Figure~\\ref{fig:tree_construction}.\n\n\n\\noindent \\textbf{Discussion.}\nThrough the bottom-up construction, an almost perfectly balanced tree is constructed. The number of points in each bottom layer batch might be  equally reduced if the total number of points does not match the tree geometry $(s\\times g)^l$  perfectly.\n\nThe bottom-up construction scheme creates an almost optimal search graph for each independent sub-tree.\nThus, during tree merging, the search query finds its true nearest neighbor with a very high probability in any of the search sub-trees. Since this means that all points in the bottom layer are updated with every new level, a high-quality search-graph is constructed. Using a sufficiently large branching factor $g$, the height $l$ of the tree is rather small even for huge datasets.\n\nPlease see the supplementary for pseudo code of the search and construction algorithms.\n\\subsubsection{Distance Caching on GPUs}\n\\label{subsec:caching}\nOne of the major deficits of GPUs is their limited memory. In particular, kNN-graphs constructions have a high demand for highly dynamic structures like unpredictably growing edge-lists, e.g.\\ a list of potential points to visit or that have already been visited. Our approach is to have a single query point per thread-block, where we use the shared memory as a multi-purpose cache. It consists out of three parts: 1) a best-list that stores the currently found best points and their distance to the query as a sorted list,  2) a priority queue that manages the points to be visited as a distance-sorted ring buffer, 3) a simple ring buffer that  holds the ids of points that have already been visited.\n\nWhen the next point to be visited is popped from the priority queue, the distances to all its $k$ neighbors have to be calculated and they need to be inserted into the three parts of the cache.\nBefore computing any distances, there is a parallelized check that tests in if any index is already known -- those points are discarded. For all unknown points, the distance to the query is computed. If the stopping criteria for the potential points is not exceeded, we perform a parallel insertion in the combined best-list and priority queue.\nPoints that drop out of the best-list, but are not visited yet are included in the priority queue buffer. Points that drop out of the priority queue buffer, which are already visited, are added to the ring buffer (3) to prevent cycles.\nThis approach enables very long paths while still being efficient with the resources a GPU has to offer.\n\\subsubsection{Multi-GPU}\nSince our approach is computing the correct distances on every comparison, it is important to always have fast access to the base vectors $\\mathcal{X}$ and the graph structure. They should reside on the GPU device memory.\nIn order to allow for large-scale datasets, we propose a very simple but effective multi-GPU scheme. $\\mathcal{X}$ is partitioned into shards that still fit onto the device. For each shard, an individual hierarchical search structure is assembled. The trees are kept separated. There is no need for merging the full kNN-graph on the bottom layer.\n\nFor a query point, each GPU computes the nearest neighbors in individually for its own sub-graph and reports the determined nearest neighbors. The results of the sub-graphs are finally merged together.\n\nThis scheme can also be carried out when the number of necessary shards exceeds the number of available GPUs. In this case, the GPUs load the data for each sub-graph sequentially.\n\\subsection{Starting Points}\n\\label{subsec:startingPoint}\nThe number of hops executed and the points visited and thus the number of distance calculations carried out does have major impact on the runtime of a query. Furthermore, the number of hops between any two points increases with the local point density. The effect is however less strong in high-dimensonal data sets.\n\nWith that in mind, we will discuss different strategies to select one or multiple starting points for a query:\n\n\\noindent\\textbf{Centroid.} Li~\\emph{et al}\\onedot \\cite{li2019approximate} start their query always from the centroid of the data set.\nAs the number of points grows, the distance to the centroid grows as well.\nIn addition, with a single starting point, any goal point will be approached from just one direction.\nThe search might be prone to gaps or linking problems inside the search-graph.\n\n\\noindent\\textbf{Hierarchical.} As explained above, during construction, we traverse the hierarchy from top to bottom, generating multiple seeds by fully exploring the top level.\nAlways starting with $k$ different points on the next layer allows for approaching any point from multiple directions.\nThis  results in very robust queries even if the search-graph is not yet perfect, which is the case during the construction phase.\nWhile in each layer there is only a small number of steps the complete the search visits a large number of points total. The distance calculations\nexceeds what has been reported in \\cite{harwood2016fanng}, leading to overall slower query times.\n\n\\noindent\\textbf{Jumping from Top to Bottom.}\nFor the final query, it turned out to be most efficient to first perform a brute-force search on the top level which allows for quick selection of multiple promising entry points,\nfollowed by a regular search on the bottom layer.\nSince the top layer consists of points which are also contained in the bottom layer, they can be used to initialize the priority queue as well as the cache.\nHaving multiple points of entry helps to make the query more robust against gaps in the graph as the query point is approached from multiple directions.\n\\section{Empirical Evaluation}\n\\label{sec:evalution}\nIn the following, we evaluate the performance of the proposed approach on several publicly available benchmark datasets and report qualitative and quantitative results in terms of timings and accuracy.\n\\paragraph{Datasets}\nWe ran experiments on SIFT1M~\\cite{PQ} and SIFT1B~\\cite{PQ} containing SIFT vectors of dimension 128.\nTo evaluate our approach on features extracted using convolutional neural networks, we ran experiments on 1 billion 96-dimensional feature representations of images in DEEP1B~\\cite{Babenko2016EfficientIO}.\nFor all evaluation on SIFT1M, we use a NVIDIA Titan RTX, whereas for SIFT1B and DEEP1B we use a machine with 8 NVIDIA Geforce GTX 1080 Ti.\n\\begin{table*}[tb]\n  \\caption{Comparison on different datasets. ${}^{(t)}$ indicates that this results is based on $t$ GPUs. For our proposed method (GGNN), we additionally report the required time to construct the index structure.}\n  \\label{tab:SIFT1M_comparision}\n  \\resizebox{\\textwidth}{!}{\\centering\n  \\begin{tabular}{\n  lS[table-format=3.2]ccccS[table-format=3.2]S[table-format=3.2]cccS[table-format=3.2]S[table-format=3.2]ccc\n  }\n  \\toprule\n  & \\multicolumn{4}{c}{SIFT1M} &\n  & \\multicolumn{4}{c}{SIFT1B} &\n  & \\multicolumn{4}{c}{DEEP1B}\\\\\n  \\cmidrule{2-5}\n  \\cmidrule{7-10}\n  \\cmidrule{12-15}\n  \\multirow{2}{*}{Approach}\n  & {Query time} & {Recall}  & {Recall} & {Recall} &\n  & {Query time} & {Recall}  & {Recall} & {Recall} &\n  & {Query time} & {Recall}  & {Recall} & {Recall}\n  \\\\\n  & {\\si{\\micro\\second}\/query} & {@1} & @10 & @100&\n  & {\\si{\\micro\\second}\/query} & {@1} & @10 & @100&\n  & {\\si{\\micro\\second}\/query} & {@1} & @10 & @100\n  \\\\\n  \\midrule\n     Exhaustive Search\n     & 23700~~ & 1.00 & {-} & {-} &\n     & {-} & {-} & {-} & {-}&\n     & {-} & {-} & {-} & {-}\n     \\\\\n  \\midrule\n     LOPQ~\\cite{localPQ}\n     & 51100 & 0.51 & 0.93 & 0.97 &\n     & 8000 & {-} & 0.20 & {-} &\n     & {-} & {-} & {-} & {-}\n     \\\\\n     IVFPQ~\\cite{PQ}\n     & 11200 & 0.28 & 0.70 & 0.93 &\n     & 74000 & 0.08 & 0.37 & 0.73 &\n     & {-} & {-} & {-} & -\n     \\\\\n     FLANN~\\cite{flann_pami_2014}\n     & 5320 & 0.97 & {-} & {-} &\n     & {-} & {-} & {-} & {-} &\n     & {-} & {-} & {-} & {-}\n     \\\\\n     Multi-D-ADC~\\cite{invertedmultiindex}\n     & {-} & {-}& {-}& {-}&\n     & 1600 & 0.33 & 0.80 & 0.97&\n     & 1500 & 0.36 & 0.71 & 0.91\n     \\\\\n  \\midrule\n     PQT~\\cite{wieschollek2016efficient}\n     & 20 & 0.51 & 0.83 & 0.86&\n     & 150 & 0.14 & 0.35 & 0.57&\n     & {-} & {-} & {-} & {-}\n     \\\\\n     FAISS~\\cite{johnson2019billion}\n     & 20 & 0.80 & 0.88& 0.95&\n     & 17.7 & {-} & 0.37 & {-} &\n     & 13 ${}^{(4)}$ & 0.45 & {-} & {-}\n     \\\\\n     PQFPGA~\\cite{PQFPGA}\n     & 20 & 0.88 & 0.94& 0.97&\n     & 20 & {-} & 0.55 & -&\n     & {-} & {-} & {-} & -\n     \\\\\n     RobustiQ~\\cite{chen2019robustiq}\n     & {-} & {-} & {-} & -&\n     & 33 & 0.33 & 0.76 & 0.90&\n     & 30 & 0.38 & 0.75 & 0.89\n     \\\\\n\\midrule\n  &  &  &  $\\tau$  & index &\n  &  &  &  $\\tau$  & index &\n  &  &  &  $\\tau$  & index\n  \\\\ \\cmidrule{4-5} \\cmidrule{9-10} \\cmidrule{14-15}\n     GGNN\n     & 4.2 & \\textbf{0.99} & 0.60 & 17.8s &\n     & 38${}^{(8)}$ & {~~~~\\textbf{0.99}} & 0.6 & 87 min &\n     & 90${}^{(8)}$ & {~~~~\\textbf{0.98}} & 0.6 & 101 min\n     \\\\\n     GGNN\n     & 1.1& 0.95& 0.42 & 17.8s &\n     & 20${}^{(8)}$ & 0.97 & 0.5 & 87 min &\n     & 48${}^{(8)}$ & 0.96 & 0.5 & 101 min\n     \\\\\n     GGNN\n     & 0.7 & 0.90 & 0.35 & 17.8s &\n     & 58${}^{(8)}$ & 0.98 & 0.7 & 34 min &\n     & 124${}^{(8)}$ & 0.97 & 0.7 & ~~40 min\n     \\\\\n  \\bottomrule\n  \\end{tabular}\n  }\n\\end{table*}\n\\begin{figure}[htb]\n    \\centering\n    \\includegraphics[width=\\columnwidth]{figures\/SIFT1M_comparison.pdf}\n    \\caption{Accuracy on SIFT1M for varying query time. Compared to other graph-based approaches at the same accuracy for the 10 nearest neighbors, our single-GPU based query is sped up by more than one order of magnitude.}\n    \\label{fig:sift1m_comparison}\n\\end{figure}\n\\subsection{Query Time and Recall}\nWhen comparing results to other approaches, one has to carefully look at the employed metric.\nThe query performance is typically measured in recall (R@k), \\emph{i.e}\\onedot} \\def\\Ie{\\emph{I.e}\\onedot the fraction of the nearest neighbors found in the first $k$ proposed vectors.\nAs our algorithm uses exact distance calculations, the true nearest neighbor is either reported as the first element in an answer or not found at all. Therefore, only R@1 is reported for our method.\nTable~\\ref{tab:SIFT1M_comparision} compares the query time and R@1 for recent CPU and GPU-based approaches on SIFT1M.\nBesides being significantly faster (around 1 $\\mu$s per query), our method can also achieve very high recall rates, close to perfect.\n\nSimilar accuracy can also be achieved with other graph-based approaches but their query time on the CPU is significantly larger (see Figure~\\ref{fig:sift1m_comparison}). CPU based reference implementations for the graph based methods \\cite{malkov2018efficient,li2019approximate,fu2019fast} are computed on a Intel Core i7-9700K.\nFANNG~\\cite{harwood2016fanng} report results for SIFT1M that come relatively close to ours in computation time and accuracy but we did not manage to reproduce their results with our reimplementation.\n\\subsection{Graph Construction and Quality}\n\\label{subsec:graph_quality}\nThe quality of our graphs can be controlled by the number of iterations used for refinement. We analyze both the quality of the construction in terms of finding the true $k_\\text{nn}$ nearest neighbors of the original data points as well as the influence on any other query.\n\nWhen looking at determining $k$ nearest neighbors, we report the following consensus measure\n\\begin{align}\n    C@k=\\frac{\\left\\vert \\mathcal{N}_x^\\text{gt}(k) \\cap \\mathcal{N}_x(k)\\right\\vert}{\\left\\vert \\mathcal{N}_x^\\text{gt}(k) \\right\\vert},\n\\end{align}\nwhich counts the overlap between the ground truth $k$ nearest neighbors and the reported $k$ points.\n\\begin{figure}[tb]\n    \\centering\n    \\includegraphics[width=\\columnwidth]{figures\/construction_time_vs_query_time.pdf}\n\\caption{Trade-off between construction and query time on SIFT1M. Higher graph quality obtained by increasing $k$ and by varying the number of refinement iterations results in fewer steps during query.\n    However, increasing $k$ also increases the cost of each step.}\n    \\label{fig:build_vs_query}\n\\end{figure}\n\nOn SIFT1M, our algorithm achieves C@10 of 0.987 without refinement and 0.996 with 5 refinement iterations.\nIn Figure~\\ref{fig:build_vs_query}, the trade off between build time and query time for a fixed recall rate is visualized.\nThe build time is controlled by slack variable $\\tau$ and how many refinement iterations are carried out.\nThe longer the construction time, the more precise the resulting graph.\nA quickly assembled graph will have worse edges and a query might need to visit more nodes until fulfilling the stopping criterion.\n\nIn Table~\\ref{tab:SIFT1M_comparision}, the construction time of our method is listed for the standard datasets.\nFor comparison, FAISS~\\cite{johnson2019billion} report construction times between 4 and 24 hours for DEEP1B.\nThe hierarchical tree-merge algorithm speeds up the construction time by a large factor while the quality is similar or even improved.\n\nOur algorithm is the first graph-based approach that is able to construct an effective kNN-graph-based search structure even for the billion-scale data sets SIFT1B and DEEP1B for which it can reach up to 0.99 R@1.\n\\subsection{Query Behaviour}\n\\label{subsec:query_behaviour}\nThe runtime and the quality of a query can be controlled by adapting the stopping criterion through the slack variable $\\tau$. As can be seen in Table~\\ref{tab:SIFT1M_comparision}, by increasing $\\tau$, a larger safety margin is considered during query,\nresulting in better recall rates at the cost of visiting more points and consequently longer query time.\n\\begin{figure}[htb]\n    \\centering\n    \\includegraphics[width=\\columnwidth]{figures\/distance_to_query_at_k.pdf}\n\\caption{Development of the distance to the 10th best point over the execution of multiple queries.\n    The marker indicates the iteration in which the last improvement is found. The plot visualizes the effectiveness of our termination criterion.}\n    \\label{fig:termination_criterion}\n\\end{figure}\n\nIt is instructive to look at the behaviour of the query over time. In Figure~\\ref{fig:termination_criterion}, the initial distance of the query to the starting point, i.e.\\ the closest point on the top layer, is drastically reduced already after very few iterations. Here, an iteration stands for fetching the best point from the priority queue and calculating the distance to all its neighbors. Most time is spent to carefully explore the neighborhood around the true nearest neighbor. The marks indicate that the last improvement in distance occurs relatively shortly before the search is terminated. This demonstrates that our termination criterion in Eq. \\eqref{eq:stopping} is effectively preventing too many iterations.\n\\section{Conclusion}\n\\label{sec:conclusion}\nOur algorithm accelerated the construction time for graph-based search structures by a large factor and represents the fastest kNN query technique while maintaining a recall rate between 0.9 and 1.\nDue to the parallel construction and merging of sub-graphs, our hierarchical construction scheme creates a high-quality kNN graph with graph-diversification links for very efficient traversal. It is easily deployed in multi-GPU systems to cope with very large-scale datasets. It is the first graph-based kNN method to report results on billion-scale data sets like SIFT1B and DEEP1B. In addition, it is the first ANN search method overall that achieves 0.99 Recall@1 for those, and it is by far the fastest.\nFor million-scale datasets, search-graphs of sufficient quality can be constructed within seconds, allowing for quick nearest-neighbor searches on intermediate data structures as a part of larger GPU-based algorithms.\nUpon acceptance, we will release an OpenSource\\footnote{\\url{https:\/\/github.com\/cgtuebingen\/ggnn}} implementation of our approach for easy inclusion in other projects.\n\nCurrently, our scheme computes the exact distance to all visited high-dimensional points.\nAs the number of distance calculations dominates the query time, a compressed representation of the data vectors could lead to further acceleration.\n{\\small\n\\bibliographystyle{ieee_fullname}\n","meta":{"redpajama_set_name":"RedPajamaArXiv"}}